Spring Boot Interview Questions and Answers

Spring Boot interview questions help candidates prepare for technical interviews by covering core concepts, annotations, REST APIs, Spring Data JPA, security, microservices, and real-world application development. These questions are suitable for freshers as well as experienced Java developers.

• Covers frequently asked Spring Boot interview questions with clear and concise answers.
• Helps beginners and professionals strengthen their Spring Boot concepts and interview preparation.

Interview Questions for Freshers

1. What is Spring Boot?

Spring Boot is a Java-based framework built on top of the Spring Framework that simplifies the development of stand-alone, production-ready applications. It minimizes configuration by providing auto-configuration, starter dependencies, and embedded servers.

• Simplifies application development with auto-configuration, starter dependencies, and embedded web servers.
• Widely used for building REST APIs, microservices, and enterprise Java applications.

2. What are the Features of Spring Boot?

Spring Boot provides several features that simplify application development and deployment. There are many useful features of Spring Boot. Some of them are mentioned below:

• Auto Configuration: Automatically configures Spring beans based on the libraries available in the classpath.
• Starter Dependencies: Predefined dependency bundles that simplify Maven and Gradle configuration.
• Embedded Servers: Includes Tomcat, Jetty, and Undertow, eliminating the need for external deployment.
• Spring Boot Actuator: Provides production-ready features such as health checks, metrics, monitoring, and application information.
• Spring Boot CLI: Allows developers to create and run Spring applications using command-line commands.
• Externalized Configuration: Supports configuration using application.properties, application.yml, environment variables, and command-line arguments.
• DevTools: Provides automatic restart, LiveReload, and improved developer productivity.

3. What are the advantages of using Spring Boot?

Spring Boot simplifies Spring application development by reducing manual configuration and providing production-ready features. Some advantages are :

• Provides embedded web servers.
• Simplifies dependency management using starter dependencies.
• Supports rapid development through auto-configuration.
• Includes production-ready monitoring with Actuator.
• Easy integration with Spring projects and third-party libraries.

4. Define the Key Components of Spring Boot.

The key components of Spring Boot are listed below:

• Starter Dependencies: Predefined dependency packages that simplify project setup (e.g., Spring Web, Spring Data JPA).
• Auto Configuration: Automatically configures Spring application components based on the dependencies present in the project.
• Spring Boot CLI: Command-line tool used to run and test Spring applications quickly.
• Actuator: Provides production-ready features such as monitoring, health checks, and application metrics.
• Embedded Servers: Includes built-in servers like Apache Tomcat, Jetty, and Undertow, eliminating the need for external deployment.
• Spring Boot Annotations: Annotations such as @SpringBootApplication, @RestController, and @Autowired simplify application development.

5. Why do we prefer Spring Boot over Spring?

Spring Boot is preferred because it simplifies the development and deployment of Spring applications through auto-configuration, starter dependencies, and embedded servers.

6. Explain the internal working of Spring Boot.

Spring Boot follows a layered architecture to process client requests efficiently.

• The client sends an HTTP request (GET, POST, PUT, DELETE) to the application.
• The request is received and mapped to the appropriate Controller method.
• The Controller forwards the request to the Service layer, where the business logic is executed.
• The Service layer interacts with the Repository layer to perform database operations using JPA/Hibernate.
• The Repository communicates with the database and returns the result.
• The response is sent back to the Controller, which returns data (JSON/XML) or a view (JSP/Thymeleaf) to the client.

7. What are the Spring Boot Starter Dependencies?

Spring Boot Starter Dependencies are preconfigured dependency descriptors that simplify project setup by including commonly used libraries for a specific functionality.

Common starter dependencies are:

8. How does a spring application get started?

A Spring application gets started by calling the main() method with @SpringBootApplication annotation in the SpringApplication class. This method takes a SpringApplicationBuilder object as a parameter, which is used to configure the application.

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);
  }
}

Internal Working

When SpringApplication.run() is executed, Spring Boot:

• Creates the ApplicationContext.
• Performs component scanning.
• Registers Spring beans.
• Applies auto-configuration.
• Loads configuration properties.
• Starts the embedded web server (for web applications).
• Makes the application ready to handle client requests.

9. What does the @SpringBootApplication annotation do internally?

The @SpringBootApplication annotation combines three annotations. Those three annotations are: @Configuration, @EnableAutoConfiguration, and @ComponentScan.

• @AutoConfiguration: This annotation automatically configuring beans in the class path and automatically scans the dependencies according to the application need.
• @ComponentScan: This annotation scans the components (@Component, @Service, etc.) in the package of annotated class and its sub-packages.
• @Configuration: This annotation configures the beans and packages in the class path.

@SpringBootApplication automatically configures the application based on the dependencies added during project creation and bootstraps the application by using run() method inside the main class of an application.

@SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan

10. What is Spring Initializr?

Spring Initializr is an online project generation tool that creates the basic structure of a Spring Boot project with the required dependencies and build configuration. It helps developers quickly start a Spring Boot project without manually configuring Maven or Gradle.

• Generates Maven or Gradle projects.
• Allows selection of Spring Boot version.
• Supports Java, Kotlin, and Groovy.
• Automatically adds required starter dependencies.

11. What are Spring Boot CLI and the most used CLI commands?

Spring Boot CLI (Command Line Interface) is a command-line tool that allows developers to quickly create, run, and test Spring Boot applications without setting up a complete project. It uses the Groovy language to simplify application development and automatically manages dependencies.

• Rapid application development.
• Automatic dependency management.

Most used CLI commands

Spring Boot Intermediate Interview Questions

12. What are the basic Spring Boot Annotations?

Spring Boot provides several annotations that simplify configuration, dependency injection, and request handling. Some basic annotations are:

• @SpringBootApplication: Marks the main Spring Boot application class.
• @RestController: Creates a REST controller that returns data.
• @Controller: Creates a Spring MVC controller.
• @RequestMapping: Maps HTTP requests to methods.
• @GetMapping: Handles HTTP GET requests.
• @PostMapping: Handles HTTP POST requests.
• @Autowired: Automatically injects Spring beans.
• @Service: Marks a service layer class.
• @Repository: Marks a data access layer class.
• @Component: Marks a class as a Spring-managed bean.

13. What is Spring Boot dependency management?

Spring Boot Dependency Management simplifies managing project dependencies by automatically providing compatible versions of libraries. It uses the Spring Boot Bill of Materials (BOM) to ensure that all dependencies work together correctly.

• Eliminates version conflicts.
• Uses the spring-boot-dependencies BOM.
• Simplifies Maven and Gradle configuration.

To create a web application, we can add the Spring Boot starter web dependency to our application.

Example:

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

14. Is it possible to change the port of the embedded Tomcat server in Spring Boot?

Yes, it is possible to change the port of the embedded Tomcat server in a Spring Boot application. The simple way is to set the server. port property in your application's application.properties file.

For example, to set the port to 8081, add the following property to the application.properties file:

server.port=8081

15. What is the starter dependency of the Spring boot module?

Spring Boot Starters are a collection of pre-configured maven dependencies that makes it easier to develop particular types of applications. These starters include,

• Dependencies
• Version control
• Configuration needed to make certain features.

To use a Spring Boot starter dependency , we simply need to add it to our project's pom.xml file. For example, to add the Spring Boot starter web dependency, add the following dependency to the pom.xml file:

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

16. What is the default port of Tomcat in spring boot?

The default port of the embedded Apache Tomcat server in Spring Boot is 8080. The port can be changed by configuring the server.port property in the application's configuration file.

application.properties

server.port=8081

application.yml

server:
port: 8081

17. Can we disable the default web server in the Spring Boot application?

Yes. Spring Boot allows you to create applications without an embedded web server, such as console applications, batch applications, or scheduled jobs. The recommended approach is to configure the application as a non-web application.

Method 1: Using application.properties

spring.main.web-application-type=none

Method 2: Using Java Code

SpringApplication application = new SpringApplication(MyApplication.class);
application.setWebApplicationType(WebApplicationType.NONE);
application.run(args);

18. How to disable a specific auto-configuration class?

Spring Boot automatically configures beans based on the dependencies available in the classpath. If a particular auto-configuration is not required, it can be excluded using the exclude attribute of @SpringBootApplication or @EnableAutoConfiguration.

Using @SpringBootApplication

@SpringBootApplication(
exclude = DataSourceAutoConfiguration.class
)
public class MyApplication {
}

Using @EnableAutoConfiguration

@EnableAutoConfiguration(
exclude = DataSourceAutoConfiguration.class
)

19. Can we create a non-web application in Spring Boot?

Yes. Spring Boot supports both web and non-web applications. A non-web application runs without an embedded web server and is commonly used for background processing or command-line tasks.

Advantages

• Lightweight and fast startup.
• No embedded web server required.
• Supports Dependency Injection (DI).
• Easy integration with Spring Batch and Scheduling.

20. Describe the flow of HTTPS requests through the Spring Boot application.

When a client sends an HTTPS request, Spring Boot processes it through multiple layers before returning a secure response.

• The client sends an HTTPS request to the server.
• The embedded server receives the encrypted request.
• SSL/TLS decrypts the request before processing.
• DispatcherServlet acts as the Front Controller and routes the request to the appropriate controller.
• The Controller validates and processes the request.
• The Service layer executes business logic.
• The Repository layer interacts with the database using JPA, Hibernate, or JDBC.
• The database returns the requested data.
• The response passes back through the Repository, Service, and Controller.
• Spring Boot serializes the response (typically JSON/XML) and sends it securely over HTTPS to the client.

21. Explain @RestController annotation in Spring Boot.

@RestController is a specialized Spring annotation used to create RESTful web services. It combines the functionality of @Controller and @ResponseBody, allowing every handler method to return data directly as the HTTP response body instead of rendering a view.

• Returns data directly as JSON, XML, or other supported formats.
• Eliminates the need to use @ResponseBody on every method.
• Supports all HTTP request methods such as GET, POST, PUT, DELETE, and PATCH.

Example:

@RestController
@RequestMapping("/employees")
public class EmployeeController {

    @GetMapping
    public List<Employee> getEmployees() {
        return employeeService.getEmployees();
    }
}

22. Difference between @Controller and @RestController

The list of difference between @Controller and @RestController are written below.

Note: Both annotations handle requests, but @RestController prioritizes data responses for building API.

23. What is the difference between RequestMapping and GetMapping?

@RequestMapping and @GetMapping are both used to map incoming HTTP requests to controller methods. The main difference is that @RequestMapping can handle any HTTP method, while @GetMapping is dedicated only to HTTP GET requests.

24. What are the differences between @SpringBootApplication and @EnableAutoConfiguration annotation?

@SpringBootApplication is a combined annotation that configures and starts a Spring Boot application, whereas @EnableAutoConfiguration only enables automatic configuration. Below are the list of difference.

25. What are Profiles in Spring?

Spring Profiles are like different scenarios for the application depending on the environment.

• You define sets of configurations (like database URLs) for different situations (development, testing, production).
• Use the @Profile annotation to clarify which config belongs to where.
• Activate profiles with environment variables or command-line options.

To use Spring Profiles, we simply need to define the spring.profiles.active property to specify which profile we want to use.

26. Mention the differences between WAR and embedded containers.

A WAR (Web Application Archive) is deployed on an external web server such as Tomcat or Jetty, whereas an embedded container packages the web server within the application, making it self-contained and executable.

Spring Boot Interview Questions For Experienced

27. What is Spring Boot Actuator?

Spring Boot Actuator is a production-ready module that provides monitoring, management, and operational features for Spring Boot applications. It exposes several built-in endpoints that help monitor application health, performance, metrics, and configuration.

Common Actuator Endpoints

• /actuator/health
• /actuator/info
• /actuator/metrics
• /actuator/env
• /actuator/beans
• /actuator/loggers
• /actuator/mappings

Dependency:

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

28. How to enable Actuator in the Spring boot application?

Steps to Enable Actuator in Spring Boot

• Step 1: Add the spring-boot-starter-actuator dependency to the project.
• Step 2: Expose the required Actuator endpoints in application.properties or application.yml.
• Step 3: Run the Spring Boot application.
• Step 4: Access the Actuator endpoints using URLs such as /actuator, /actuator/health, and /actuator/metrics.

29. What is the purpose of using @ComponentScan in the class files?

@ComponentScan is used to instruct the Spring IoC container to scan specified packages for Spring-managed components such as @Component, @Service, @Repository, and @Controller. The detected classes are automatically registered as Spring beans.

• Registers detected classes as beans in the Spring IoC container.
• Eliminates the need for manual bean configuration.
• By default, scans the package of the main application class and all its sub-packages.

Common Ways to Use @ComponentScan

• Without arguments (default package scanning)
• Using basePackages
• Using basePackageClasses

30. What are the @RequestMapping and @RestController annotations in Spring Boot used for?

@RequestMapping: @RequestMapping is used to map incoming HTTP requests to controller classes or handler methods. It supports mapping based on URL, HTTP method, request parameters, headers, and media types.

• Can be applied at both class and method levels.
• Supports GET, POST, PUT, DELETE, PATCH, etc.

@RestController: @RestController is a specialized annotation used to create RESTful web services. It combines @Controller and @ResponseBody, so every handler method returns the response body directly instead of

• Returns JSON, XML, or other data directly.
• Eliminates the need to annotate every method with @ResponseBody.

@RestController = @Controller + @ResponseBody

31. How to get the list of all the beans in your Spring boot application?

The ApplicationContext interface manages all Spring beans. We can retrieve the names of all registered beans using the getBeanDefinitionNames() method.

• getBeanDefinitionNames() returns the names of all registered beans.
• Useful for debugging and verifying bean registration.
• Displays both user-defined and auto-configured beans.

32. Can we check the environment properties in your Spring boot application explain how?

Yes, we can check the environment properties in our Spring Boot Application. The Environment object in a Spring Boot application can be used to check the environment's properties.

Configuration settings for the application, includes:

• property files
• command-line arguments
• environment variables

We can get the Environment instance by calling the getEnvironment() method.

33. How to enable debugging log in the spring boot application?

Debug logging provides detailed information about application startup, auto-configuration, bean creation, and request processing.

Ways to Enable Debug Logging:

• Add debug=true in application.properties.
• Set the logging level:

logging.level.org.springframework=DEBUG

Run the application with:

java -jar application.jar --debug

Change the log level at runtime using the Spring Boot Actuator /actuator/loggers endpoint.

34. What is dependency Injection and its types?

Dependency Injection (DI) is a design pattern in which the Spring IoC container automatically provides the required dependencies to an object instead of the object creating them itself. It promotes loose coupling, easier testing, and better maintainability.

Types of Dependency Injection

• Constructor Injection: Dependencies are injected through the constructor. Recommended approach in Spring Boot.
• Setter Injection: Dependencies are injected using setter methods. Suitable for optional dependencies.
• Field Injection: Dependencies are injected directly into class fields using @Autowired.

35. What is an IOC container?

The Inversion of Control (IoC) Container is the core component of the Spring Framework that creates, configures, manages, and destroys Spring beans. It also performs Dependency Injection automatically.

Types of IoC Container

• BeanFactory: Basic IoC container with lazy initialization.
• ApplicationContext: Advanced IoC container with enterprise features like AOP, events, and internationalization.

36. What is the difference between Constructor and Setter Injection?

The main difference is that Constructor Injection provides dependencies through the class constructor, while Setter Injection provides dependencies through setter methods.

37. What are Bean Scopes and its Types in Spring?

Bean Scope defines the lifecycle and visibility of a bean in the Spring IoC container. It determines how many instances of a bean are created and how long they remain available.

Types of Bean Scopes

38. What is the default bean scope in Spring?

The singleton scope is the default bean scope in Spring.

• Only one instance of the bean is created per Spring IoC container.
• The same bean instance is shared across the application.
• Improves memory usage and performance.

39. Difference between Singleton and Prototype scope?

Some basic difference are listed below:

40. When should Prototype scope be used?

The Prototype scope should be used when every request or operation requires a new bean instance and the bean maintains its own state.

• Creates a new object every time the bean is requested.
• Suitable for stateful components.
• Configured using the @Scope("prototype") annotation.

Common Use Cases

• Temporary data holder objects.
• Report or document generators.
• File processing tasks.
• Stateful business objects.
• Objects that should not be shared between requests.

41. What is Thymeleaf?

Thymeleaf is a modern server-side Java template engine used to create dynamic web pages in Spring and Spring Boot applications. It processes HTML templates on the server and generates dynamic content before sending it to the browser.

• Integrates seamlessly with Spring MVC and Spring Boot.
• Supports HTML5, CSS, and JavaScript.
• Uses attributes like th:text, th:if, and th:each.

42. What Are Spring Boot DevTools Used For?

Spring Boot DevTools is a development tool that improves developer productivity by providing automatic restart, LiveReload support, and other development-time features.

• LiveReload support for browser refresh.
• Faster application startup during development.
• Improved development experience.

43. What error do you see if H2 is not present in the class path?

If the H2 database dependency is missing while the application is configured to use H2, Spring Boot cannot load the H2 JDBC driver.

• JDBC driver cannot be loaded.
• Add the H2 dependency to resolve the issue.

Common Error:

java.lang.ClassNotFoundException: org.h2.Driver

44. Explain how to deploy to a different server with Spring Boot?

A Spring Boot application can be deployed either as an executable JAR with an embedded server or as a WAR file on an external application server such as Tomcat.

Steps:

• Build the application using Maven or Gradle.
• Generate a JAR or WAR file.
• Copy the artifact to the target server.
• Configure application properties if required.
• Start the application or deploy it to the application server.

45. How does Spring Boot support Microservices?

Spring Boot simplifies microservice development by providing auto-configuration, embedded servers, and easy creation of RESTful APIs. It also integrates seamlessly with Spring Cloud for building production-ready microservices.

• Easy creation of REST APIs using @RestController.
• Starter dependencies simplify dependency management.
• Integrates with Spring Cloud for service discovery, configuration, and API gateways.

46. What is Service Discovery in Microservices?

Service Discovery is a mechanism that allows microservices to register themselves and discover other services automatically without hardcoding their network addresses.

• Other services query the discovery server to locate them.
• Supports dynamic scaling and load balancing.
• Commonly implemented using Netflix Eureka in Spring Cloud.

47. What are the advantages of Microservices?

Microservices offer several benefits over monolithic applications by allowing applications to be split into smaller, manageable services that operate independently.

Advantages:

• Independent Deployment: Each service can be deployed without affecting others.
• Scalability: Individual services can be scaled based on demand.
• Fault Isolation: Failure in one service does not stop the entire application.
• Technology Flexibility: Different services can use different programming languages or databases.
• Faster Development: Multiple teams can work on different services simultaneously.

48. What is Spring Cloud, and why is it used with Spring Boot?

Spring Cloud is a framework built on top of Spring Boot that provides tools for developing distributed microservices. While Spring Boot creates individual services, Spring Cloud manages communication and infrastructure between them. It has various features like :

• Service Discovery (Eureka)
• API Gateway
• Centralized Configuration
• Load Balancing
• Circuit Breaker

49. What are the advantages of Microservices over Monolithic Architecture?

Microservices provide greater flexibility, scalability, and maintainability by dividing an application into small independent services.

Advantages

• Independent development and deployment.
• Faster release cycles.
• Better scalability.
• Improved fault isolation.
• Easier maintenance and testing.
• Supports different technologies and databases.

50. What is REST API in Microservices?

A REST API (Representational State Transfer API) is the most common way for microservices to communicate over HTTP. It uses standard HTTP methods to perform operations on resources.

Common HTTP Methods

• GET: Retrieve data.
• POST: Create new data.
• PUT: Update existing data.
• DELETE: Remove data.
• PATCH: Partially update data.