10 Basic Spring Boot Questions:

Every Developer Should Know

1. What is the purpose of the @SpringBootApplication annotation in Spring Boot?

The @SpringBootApplication annotation in Spring Boot is a key element that helps

streamline the setup of a Spring Boot application. It's like a shortcut or a magic wand
that bundles several important settings and configurations into one neat package.
What It Does:

This annotation is a convenience feature that does three major things behind the
scenes:

1. @Configuration: It tells Spring Boot that this class will define some settings or
configurations for the application. For example, you might have configurations
for connecting to a database.

2. @EnableAutoConfiguration : This is where Spring Boot shines. It automatically sets

up the application based on the libraries you have. For instance, if you have
web libraries, it prepares your application to work as a web application.

3. @ComponentScan: It instructs Spring Boot to look for other components, services,

and configurations in the same package as the class with this annotation,
allowing the application to recognize and use them throughout.

Practical Use:

Typically, you place @SpringBootApplication on your main application class. When

your application starts, this annotation triggers Spring Boot to set up your
application with necessary configurations automatically.

Example Code:

@SpringBootApplication
public class MyApplication {

10 Basic Spring Boot Questions: Every Developer Should Know 1

 public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}

Here, the MyApplication class is marked with @SpringBootApplication . This single line
tells Spring Boot to get busy setting up your application by combining essential
configurations and scanning for components.

2. How do you run a Spring Boot application?

Running a Spring Boot application is quite straightforward. Here's how you do it:
Through the Main Method:

Spring Boot applications are Java applications that have a main method. This is the
standard entry point where the Java Virtual Machine (JVM) starts execution of an
application.

In a Spring Boot application, the main method does something special: it calls
SpringApplication.run() . This method is responsible for bootstrapping the Spring

application context, which is the central hub of a Spring application. It's where all
the magic of dependency injection, configurations, and more happens.

Example:
Suppose you have a Spring Boot application with a main class called MyApplication .
Running it would look like this:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}

10 Basic Spring Boot Questions: Every Developer Should Know 2

 In this code, @SpringBootApplication is an annotation that sets up various
configurations. The main method calls SpringApplication.run() , passing in
MyApplication.class as an argument, which tells Spring Boot to start this application.

Running the Application:

1. Through an IDE: If you are using an Integrated Development Environment (IDE)

like IntelliJ IDEA or Eclipse, you can simply right-click on the file containing the main
method and select 'Run'.

2. Using a Build Tool: If you're using a build tool like Maven or Gradle, you can use
the command line to run your application.

For Maven, use: mvn spring-boot:run

For Gradle, use: gradle bootRun

Both these methods compile your code, if necessary, and start the Spring application
context, which, among other things, starts an embedded web server if your application
is a web application.

3. What is a Spring Boot Starter? Name one common starter.

A Spring Boot Starter is a special kind of dependency descriptor in Spring Boot that
simplifies the Maven or Gradle build configuration. Starters are essentially a set of
convenient dependency groupings for various types of development in Spring Boot.

Purpose of Spring Boot Starters:

The primary purpose of a Spring Boot Starter is to provide all the necessary
dependencies in one place so that you don't have to hunt down and specify each
one individually.

They help in reducing boilerplate code in your build configuration file ( pom.xml for
Maven or build.gradle for Gradle).

Each starter is tailored to support a specific type of development (web, data,

messaging, etc.) in Spring Boot.

Common Spring Boot Starter:

10 Basic Spring Boot Questions: Every Developer Should Know 3

 spring-boot-starter-web: One of the most commonly used starters, spring-boot-
starter-web is used for building web applications, including RESTful applications

using Spring MVC. It provides all the necessary dependencies to build a web
application.

Example with spring-boot-starter-web :

If you're creating a web application using Spring Boot, you can include the spring-boot-

starter-web dependency in your pom.xml (Maven) or build.gradle (Gradle) file. This

starter will bring in dependencies like Spring MVC, Tomcat (as the default embedded
container), Jackson (for JSON processing), and others needed for web development.

Maven ( pom.xml ):

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

Gradle ( build.gradle ):

dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
}

By adding this starter, you can immediately start developing your web application
without worrying about individual dependencies and version conflicts, as Spring Boot
manages them for you. It's a key feature of Spring Boot that contributes to its
convention-over-configuration approach, making it easier and faster to get a Spring
application up and running.

4. How does Spring Boot achieve auto-configuration?

10 Basic Spring Boot Questions: Every Developer Should Know 4

 Spring Boot's auto-configuration is one of its standout features, making it much easier
and faster to set up and configure Spring-based applications. Here's how it works:

Understanding Auto-Configuration
Concept:

Auto-configuration in Spring Boot is a mechanism that automatically configures your

Spring application based on the jar dependencies you have added. It aims to
reduce or eliminate the need for manual configuration of beans that are commonly
used in Spring applications.

How It Works:

1. Dependency Detection:

Spring Boot looks at the libraries (jar files) in your classpath.

For example, if it sees that you have added a web-related library like Spring
MVC, it assumes you are building a web application and sets up the necessary
configuration accordingly.

2. Conditional Configuration:

Spring Boot uses a series of @Conditional annotations to decide what

configuration should be applied.

For instance, @ConditionalOnClass , @ConditionalOnBean , @ConditionalOnProperty ,

and so on. These annotations help Spring Boot decide whether a specific auto-
configuration class should be applied or not.

If certain conditions are met (like the presence of a specific class in the
classpath), the auto-configuration logic kicks in.

3. Default Configurations with Overriding Capability:

Spring Boot provides sensible defaults for various configurations, but it also
allows you to override these defaults.

For example, if Spring Boot auto-configures an embedded Tomcat server but

you prefer a different server or specific configurations, you can define your own
@Bean for that, and Spring Boot will back off from its default.

Example: Auto-Configuring a Data Source

10 Basic Spring Boot Questions: Every Developer Should Know 5

 Imagine you're building an application that interacts with a database. In a traditional
Spring application, you would need to define a DataSource bean, configure connection
properties, set up a JPA provider, etc.

In Spring Boot, if you include a database driver on your classpath (like H2, MySQL, etc.)
and provide database properties in your application.properties or application.yml ,
Spring Boot will automatically configure a DataSource bean for you.

Example of application.properties :

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypass

Spring Boot will use these properties to auto-configure a connection to your MySQL
database. This process significantly simplifies the setup and reduces the amount of
boilerplate configuration code.

5. What is a Spring Profile?

A Spring Profile in Spring Boot is a feature that allows you to define sets of
configurations that can be selectively enabled under different conditions. It's like having
different settings for an application that you can switch based on the environment or
circumstances.

Understanding Spring Profiles

Purpose:

Spring Profiles provide a way to segregate configuration settings for different

environments, such as development, testing, and production.

This helps in managing application behavior under various conditions without

changing the actual code.

How It Works:

10 Basic Spring Boot Questions: Every Developer Should Know 6

 You can define a profile in a configuration file (like application.properties or
application.yml ) or with annotations in your Java code.

When the application runs, you activate a specific profile, and only the
configurations associated with that profile are applied.

Example Use-Cases:

1. Different Databases: You might want to use an in-memory database like H2 for
testing but a real database like MySQL in production.

2. API Keys: You could have different API keys for development and production
environments.

3. Feature Toggles: Enable or disable certain features in different environments.

Implementing Spring Profiles

Defining Profiles in application.properties :

You can create multiple application-{profile}.properties files for different profiles.

For instance, application-dev.properties for development and application-
prod.properties for production.

Activating a Profile:

You can activate a profile using the spring.profiles.active property in your

application.properties or as a JVM system parameter.

Example in application.properties :

spring.profiles.active=dev

Or, when running the application:

java -jar myapp.jar --spring.profiles.active=prod

Using Annotations:

You can also define beans for specific profiles in your code using the @Profile

annotation.

10 Basic Spring Boot Questions: Every Developer Should Know 7

 Example:

@Configuration
@Profile("dev")
public class DevDatabaseConfig {
// Configuration beans for development
}

@Configuration
@Profile("prod")
public class ProdDatabaseConfig {
// Configuration beans for production
}

In this example, the DevDatabaseConfig class will only be loaded if the dev profile is
active, and similarly for ProdDatabaseConfig with the prod profile.
Spring Profiles are a powerful tool for managing and organizing different configurations
for a Spring Boot application, enabling a clean separation of concerns and making your
application adaptable to various environments.

6. What is the default server port for a Spring Boot application?

The default server port for a Spring Boot web application is 8080 .

Explanation:
When you create a web application using Spring Boot and run it without specifying any
port configuration, it will start up on port 8080 . This means that you can access the
application locally by navigating to http://localhost:8080 in your web browser.

Customizing the Port:

While 8080 is the default, Spring Boot allows you to easily change the server port. This
is commonly done via the application.properties or application.yml file located in the
src/main/resources directory.

Example in application.properties :

10 Basic Spring Boot Questions: Every Developer Should Know 8

 server.port=9090

Setting to 9090 would make your application run on

server.port

http://localhost:9090 instead.

Example in application.yml :

server:
port: 9090

Alternatively, you can specify the port directly when running the application:

java -jar myapp.jar --server.port=9090

Or, if you're using Spring Boot with Maven:

mvn spring-boot:run -Dserver.port=9090

This flexibility in configuring the server port is useful in various scenarios, like avoiding
port conflicts with other running applications or setting up different environments.

7. How can you create a custom banner in a Spring Boot

application?

Creating a custom banner in a Spring Boot application is a fun way to add a

personalized touch when your application starts up. By default, Spring Boot shows its
own banner in the console on startup, but you can easily replace it with your own.

Steps to Create a Custom Banner:

1. Create a Banner File:

10 Basic Spring Boot Questions: Every Developer Should Know 9

 Make a text file containing the custom banner. This can be plain text or ASCII
art.

You can use online ASCII art generators to create text-based graphics if you
like.

2. Place the Banner File:

Name the file banner.txt .

Place it in the src/main/resources directory of your Spring Boot application.

3. Starting the Application:

When you start your Spring Boot application, it will automatically detect the
banner.txt file and display its contents in the console.

Customizing the Banner Programmatically:

If you want to generate the banner programmatically or pull it from an external source,
you can do so by implementing Banner interface.

Example Code:

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MyApplication {

public static void main(String[] args) {

SpringApplication app = new SpringApplication(MyApplication.class);
app.setBanner(new Banner() {
@Override
public void printBanner(Environment environment, Class<?> sourceClass, Pr
intStream out) {
out.println("My Custom Banner");
}
});
ConfigurableApplicationContext context = app.run(args);
}
}

10 Basic Spring Boot Questions: Every Developer Should Know 10

 Custom Banner Variables:
Spring Boot also supports variables in banner.txt that can be useful to display specific
environment properties, like application version. For instance:

Example in banner.txt :

My Application
Version: ${spring.application.version}

The ${spring.application.version} variable will be replaced with the version number

specified in your pom.xml or build.gradle file.

8. Explain the role of the spring-boot-starter-parent POM.

The spring-boot-starter-parent POM plays a crucial role in Spring Boot applications. It

serves as a parent POM (Project Object Model) for your Spring Boot projects and
provides several key features that simplify Maven configurations.

Key Features of spring-boot-starter-parent :

1. Default Dependency Management:

The spring-boot-starter-parent POM comes with pre-defined configurations for

dependency management. This means it already has versions set for common
dependencies, reducing the need to specify version numbers for each
dependency in your project.

2. Default Plugin Configurations:

It provides sensible defaults for Maven plugins. For instance, it configures the
java.version property to define the Java version for compilation, and sets up

configurations for plugins like maven-compiler-plugin .

3. Spring Boot Plugin Configuration:

The parent POM pre-configures the Spring Boot Maven plugin, which is
essential for packaging and running Spring Boot applications. This plugin helps

10 Basic Spring Boot Questions: Every Developer Should Know 11

 in creating executable JARs (Java Archive files) with embedded servers and
other necessary configurations.

4. Resource Filtering:

It includes settings for resource filtering, which can be useful for including
properties files and other resources in your JARs with support for variable
substitution.

5. Inheritance and Customization:

By inheriting from the spring-boot-starter-parent , your project automatically

takes advantage of all these configurations. You can still override or customize
specific settings as needed.

Example:
In your Spring Boot project’s pom.xml , you would typically declare the spring-boot-

starter-parent in the parent section:

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.0</version> <!-- Specify the Spring Boot version here -->
</parent>

By specifying this parent POM, your project inherits all the default configurations set by
Spring Boot, making setup and dependency management much simpler.

Benefits:
Simplifies Maven Configuration: Reduces the amount of Maven configuration
needed in your pom.xml .

Standardizes Your Build: Ensures consistency across Spring Boot projects by

providing a standard setup.

Easy to Update: Simplifies the process of updating Spring Boot versions - you only
need to change the version in the parent POM.

10 Basic Spring Boot Questions: Every Developer Should Know 12

 9. How do you access application properties in a Spring Boot
application?
Accessing application properties in a Spring Boot application is a straightforward
process, primarily done using the @Value annotation or through configuration classes.
These properties can be defined in files like application.properties or application.yml in
the src/main/resources directory.

Using the @Value Annotation:

The @Value annotation allows you to inject property values into fields in your beans
directly.

Example:
Suppose you have a property in your application.properties file:You can access this
property in a Spring component as follows:

app.greeting=Hello, Spring Boot!

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

@Value("${app.greeting}")
private String greeting;

public String getGreeting() {

return greeting;
}
}

Using Configuration Properties:

For more complex configurations or when working with multiple properties, it's more
organized to use configuration classes with @ConfigurationProperties .

Example:
First, define your properties in application.properties :Then, create a configuration

10 Basic Spring Boot Questions: Every Developer Should Know 13

 class:In this setup, the properties app.name and app.version will be automatically
bound to the fields name and version in the AppConfig class.

app.name=My Spring App

app.version=1.0.0

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "app")
public class AppConfig {

private String name;

private String version;

// standard getters and setters

}

Advantages of Using Configuration Properties:

Type Safety: @ConfigurationProperties ensures that properties are cast to the correct
data types.

Validation: You can add validation annotations to your configuration class fields.

Grouping: It’s easier to manage and organize related properties together.

Tips:
Property Source: You can define properties in different profiles like application-
dev.properties or application-prod.properties for different environments.

Default Values: With the @Value annotation, you can specify default values using
the colon : syntax, like @Value("${some.property:default}") .

10. What is the use of the @RestController annotation in Spring

Boot?

10 Basic Spring Boot Questions: Every Developer Should Know 14

 In Spring Boot, the @RestController annotation is used to create RESTful web services.
It simplifies the development of RESTful web APIs.

Key Points of @RestController :

1. Combines @Controller and @ResponseBody :

The @RestController annotation is a specialized version of the @Controller

annotation which adds @ResponseBody . While @Controller is used to mark a class
as a web request handler, @ResponseBody indicates that the return value of a
method should be used as the response body of the request.

2. Simplifies REST API Development:

When you use @RestController , you tell Spring Boot that this controller is going
to handle REST API requests and should serialize/deserialize service
responses/requests to JSON or XML.

3. No Need for @ResponseBody :

With @RestController, you don't need to annotate each method with

@ResponseBody . It's automatically assumed that all methods will define the

endpoint response.

Example Usage:
Here’s an example to illustrate how @RestController can be used in a Spring Boot
application:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyRestController {

@GetMapping("/hello")
public String sayHello() {
return "Hello, World!";
}
}

10 Basic Spring Boot Questions: Every Developer Should Know 15

 In this example, MyRestController is a REST controller. The sayHello method is
mapped to handle GET requests for the /hello URL.

When a GET request is made to /hello , this method returns a simple string "Hello,

World!" . Thanks to the @RestController annotation, Spring Boot automatically

handles the conversion of this string to a HTTP response.

Use Cases:
Creating API Endpoints: Commonly used to create RESTful endpoints in
microservices or web applications.

JSON/XML Responses: Automatically handles JSON or XML serialization for

response objects, ideal for AJAX or mobile app backends.

To learn more about me visit https://ashutosh.net.in, To explore my published books

visit https://www.amazon.com/stores/author/B08B5DHX7N/allbook and to explore my
courses on Udemy visit https://www.udemy.com/user/ashutosh-shashi-4/. You can also
explore my Medium articles by visiting https://medium.com/@ashutoshshashi. Follow
me on LinkedIn https://www.linkedin.com/in/ashutoshshashi/ and join my WhatsApp
channel https://whatsapp.com/channel/0029Va7WqQ0BadmUz9Fpdu2a to get updates
instantly.

10 Basic Spring Boot Questions: Every Developer Should Know 16