100 Spring Boot interview questions and answers for 2025

Spring MVC is a framework for building web applications using the Model-View-Controller (MVC) architectural pattern. It provides features for handling requests, managing controllers, rendering views, and managing data flow.

Spring Boot, on the other hand, is an opinionated framework built on top of Spring that aims to simplify the setup and configuration of Spring applications. It provides out-of-the-box defaults and auto-configuration, reducing the need for manual configuration and boilerplate code.

The @RestController annotation is used to define a RESTful controller in a Spring Boot application. It combines the functionality of the @Controller and @ResponseBody annotations, simplifying the process of building RESTful APIs by automatically serializing the return values of methods into JSON or XML responses.

Exception handling in Spring Boot can be implemented using the @ControllerAdvice annotation. By creating a class annotated with @ControllerAdvice and defining methods annotated with @ExceptionHandler, you can handle specific exceptions and return appropriate responses.

You can also use the @ResponseStatus annotation to specify the HTTP status code for the response.

Dependency injection is a core concept in Spring Boot. It allows objects to be loosely coupled by providing their dependencies from external sources. Spring Boot uses inversion of control (IoC) and the dependency injection pattern to manage dependencies.

Spring Boot automatically resolves and injects the required dependencies at runtime by annotating classes with appropriate annotations such as @Autowired.

Spring Boot provides excellent support for database operations through its integration with Spring Data JPA. By defining entities and repositories, you can perform CRUD (Create, Read, Update, Delete) operations on databases with minimal boilerplate code.

Spring Boot automatically configures the database connection and transaction management, and provides powerful querying capabilities.

Spring Boot Actuator is a feature that provides insight into the runtime of a Spring Boot application. It offers a set of production-ready endpoints that expose information about application health, metrics, environment, logging, and more.

The Actuator enables monitoring and management of the application, making it easier to understand and troubleshoot in production environments.

Caching in a Spring Boot application can be implemented using the @Cacheable, @CacheEvict, and other cache-related annotations provided by the Spring Framework. Adding these annotations to methods lets you cache the results and improve performance. Spring Boot integrates with popular caching providers like Ehcache, Hazelcast, and Redis.

The @Scheduled annotation is used to schedule the execution of a method at fixed intervals or specific times. It allows you to define cron expressions or fixed delay/initial delay values. Spring Boot automatically triggers the annotated method based on the specified schedule, making it suitable for performing recurring tasks such as data synchronization or sending periodic notifications.

To enable CORS in a Spring Boot application, you can use the @CrossOrigin annotation at the controller level or globally configure CORS using a WebMvcConfigurer bean. The annotation allows you to specify the allowed origins, HTTP methods, headers, and other CORS-related settings. Enabling CORS ensures that web browsers can make requests to your application from different domains.

Profiles in Spring Boot allow you to define different configurations for different environments or scenarios. By using the @Profile annotation on classes or methods, you can specify which profiles should be active for the corresponding beans or configurations.

Profiles enable you to have different property values, component configurations, or dependencies based on the active profile. This facilitates easy deployment and testing across different environments.

Spring Boot Actuator provides a set of production-ready features and endpoints that help monitor and manage a Spring Boot application.

Its major features include health checks, which provide information about the application's health; metrics, which gather and expose various runtime metrics; info, which displays custom application information; logging, which allows changing log levels at runtime, and many more endpoints for managing and understanding the application in a production environment.

To integrate Spring Security in a Spring Boot application, you need to add the appropriate dependencies and configure security settings. Spring Security provides comprehensive authentication and authorization mechanisms.

You can configure security rules using Java configuration or annotations, define user roles and permissions, and customize authentication providers, such as in-memory authentication, database-backed authentication, or integration with external identity providers.

The @Transactional annotation is used to mark a method or class for transaction management in Spring Boot. It ensures that the annotated method or all methods within the annotated class are executed within a transactional context.

The @Transactional annotation manages the transaction boundaries, rollback behavior, and other transactional aspects to ensure data consistency and integrity.

Spring Boot automatically resolves the appropriate message based on the user's locale, making it convenient to build multi-language applications. It provides support for internationalization and localization through properties files and the use of the MessageSource interface.

By defining message bundles for different locales and configuring the message source, you can easily retrieve and display localized messages in your application.

The @RestControllerAdvice annotation combines the functionalities of @ControllerAdvice and @ResponseBody annotations. It is used to define a global exception handler for RESTful controllers in a Spring Boot application.

Annotated classes can contain exception-handling methods annotated with @ExceptionHandler which handles exceptions thrown within any @RestController in the application. These methods can return custom error responses or perform other actions based on the exception type.

Spring Data REST is a project built on top of Spring Data, it takes the features of Spring HATEOAS and Spring Data to build Spring MVC-based RESTful services with less code. With Spring Data REST, you can leverage your Spring Data repositories and convert them into full-featured RESTful services with ease.

Some of its advantages are:

Rapid Development: With Spring Data REST, a great deal of your HTTP resource implementation time can be saved. It's quick and easy to build a RESTful service with full CRUD functionality.

Data Access: It leverages Spring Data's repositories and provides seamless, RESTful access to your data model.

HAL Browser: Spring Data REST includes support for the HAL Browser, allowing users to navigate, create, update, and delete resources directly from their web browsers.

Search Support: It has built-in support for searches. Custom repository methods are automatically exposed as HTTP resources.

File upload and download functionality can be implemented in a Spring Boot application by configuring multipart file handling. By using the MultipartFile object as a method parameter, Spring Boot automatically binds uploaded files to it.

For file download, you can return the file as a response with appropriate headers. Additionally, you can leverage storage services like Amazon S3 or Azure Blob Storage for file storage and retrieval.

The @Async annotation is used to indicate that a method should be executed asynchronously. When a method is annotated with @Async, Spring Boot runs it in a separate thread from a task executor, allowing the caller to continue execution without waiting for the asynchronous method to complete.

This annotation is useful for offloading time-consuming tasks, improving performance, and providing a more responsive user experience.

The embedded servlet container in Spring Boot allows you to run web applications without the need for a separate web server. It provides a lightweight servlet container, such as Tomcat, Jetty, or Undertow, that is embedded within the application.

Spring Boot automatically configures and starts the embedded servlet container, simplifying the deployment and execution of web applications.

Request and response logging in a Spring Boot application can be implemented using filters or interceptors. Creating a custom filter or interceptor lets you intercept incoming requests and outgoing responses and log their details, such as headers, payloads, and other relevant information.

Spring Boot allows you to register these filters or interceptors in the application's configuration, enabling centralized logging across the application.

Reactive data access in Spring Boot allows you to build non-blocking and efficient applications that handle a large number of concurrent requests. Spring Data R2DBC provides reactive database access by integrating with R2DBC (Reactive Relational Database Connectivity).

It enables you to perform asynchronous database operations using reactive programming paradigms, such as Flux and Mono, providing better scalability and responsiveness compared to traditional blocking database access.

Asynchronous messaging using Spring Boot and RabbitMQ can be achieved by integrating the Spring AMQP (Advanced Message Queuing Protocol) library. By configuring the RabbitMQ connection details and using the appropriate annotations and components, you can send and receive messages asynchronously.

Spring Boot provides abstractions like @RabbitListener for message consumption and RabbitTemplate for message production. They make it easy to implement asynchronous messaging patterns like publish-subscribe and request-reply.

The @Conditional annotation in Spring Boot allows you to conditionally activate or deactivate beans or configurations based on specific conditions. By annotating a bean or configuration class with @Conditional and providing a condition class implementing the Condition interface, you can control whether the bean or configuration should be created and registered based on runtime conditions. This enables flexible configuration based on environment, properties, or other factors.

The @SpringBootTest annotation is used to bootstrap a Spring Boot application context for testing purposes. It allows you to load the entire application context, including all configurations and beans, during integration tests.

@SpringBootTest provides features like auto-configuration, dependency injection, and easy access to application-specific components, enabling comprehensive testing of Spring Boot applications.

Spring Boot's actuator health checks are endpoints provided by the Actuator that give insights into the application's health. By default, health indicators check the overall system health. You can customize them by implementing the HealthIndicator interface and registering them with the application context.

Custom health indicators allow you to monitor specific aspects of the application's health such as database connectivity, external service availability, or custom health checks.

You can secure REST APIs in a Spring Boot application using JSON Web Tokens (JWT) by integrating Spring Security and JWT libraries. Spring Security provides mechanisms for authentication and authorization, while JWT facilitates token-based authentication.

By configuring Spring Security filters, implementing authentication and authorization providers, and validating JWT tokens, you can protect your REST APIs and control access based on user roles and permissions.

The @EntityScan annotation is used to specify the base packages to scan for entity classes in a Spring Boot application. When using JPA (Java Persistence API) with Spring Boot, @EntityScan helps the JPA provider locate and manage entity classes.

By default, Spring Boot scans the package of the application's main class and its sub-packages. However, if entity classes are located in different packages, you need to use @EntityScan to include those packages.

The @Retryable annotation is used to specify that a method should be retried if it fails due to specified exceptions. Adding @Retryable and configuring the desired retry behavior enables Spring Boot to automatically retry the method when exceptions occur.

This can be useful for handling transient errors, such as network timeouts or temporary resource unavailability, and ensuring the successful execution of critical operations.

Auto-reconfiguration in Spring Boot is a feature that automatically configures certain components and dependencies based on the classpath and available resources. It simplifies the configuration process by detecting and configuring components like data sources, messaging brokers, and caches.

Auto-reconfiguration has limitations when it comes to complex or custom configurations. It may not always provide the desired configuration out of the box. In such cases, manual configuration may be required.

To implement distributed caching in a Spring Boot application with Hazelcast or Redis, you can leverage the respective cache providers' integration libraries. Configuring the cache manager and cache-related settings lets you enable distributed caching.

Spring Boot simplifies the setup and configuration process by providing auto-configuration support for both Hazelcast and Redis. Additionally, you can annotate methods with cache-related annotations like @Cacheable or @CacheEvict to cache and retrieve data efficiently.

To create a Spring Boot application using Gradle, follow these steps:

• Set up a new Gradle project or add Spring Boot dependencies to an existing Gradle project.
• Make sure you have the required plugins configured in the build.gradle file, such as the org.springframework.boot and io.spring.dependency-management plugins.
• Define the necessary dependencies in the dependencies section of the build.gradle file. Specify the desired Spring Boot starter dependencies.
• Create the main application class and annotate it with @SpringBootApplication.
• Implement the application logic within the main application class or other components.
• Use the Gradle command line or an IDE plugin to build and run the application.

To customize the default error pages in a Spring Boot application, you can create an error page template or controller method that handles the error. Defining an error template with the appropriate name and placing it in the src/main/resources/templates/error directory enables Spring Boot to automatically render that template for the corresponding error status code.

Alternatively, you can create a controller method with @ExceptionHandler annotation to handle specific exceptions and return a custom error response.

To create a Spring Boot application using Maven, follow these steps:

• Set up a new Maven project or add Spring Boot dependencies to an existing Maven project.
• Ensure that the project's dependencies include the spring-boot-starter-parent as the parent project.
• Define the necessary dependencies in the project's pom.xml file, such as spring-boot-starter-web for web applications.
• Create the main application class and annotate it with @SpringBootApplication.
• Implement the application logic within the main application class or other components.
• Use the Maven command line or an IDE plugin to build and run the application.

Security can be implemented in a Spring Boot application by adding the appropriate dependencies, such as spring-boot-starter-security, and configuring the security settings. This can be done by creating a security configuration class that extends WebSecurityConfigurerAdapter and overriding its methods to define authentication and authorization rules.

Additionally, you can customize the login page, handle logout, and secure specific endpoints using annotations like @EnableWebSecurity and @EnableGlobalMethodSecurity.

Spring Boot applications can be deployed in various ways including:

Standalone JAR: Packaging the application as a self-contained executable JAR file with an embedded servlet container like Tomcat or Jetty.

WAR deployment: Packaging the application as a traditional WAR file and deploying it to a servlet container.

Docker: Containerizing the application using Docker and running it on Docker containers.

Cloud platforms: Deploy the application to cloud platforms like AWS, Azure, or Google Cloud using platform-specific deployment options such as AWS Elastic Beanstalk or Azure App Service.

To create a RESTful API using Spring Boot, you can follow these steps:

• Define your domain model and business logic.
• Create a Spring MVC controller class and define handler methods annotated with @RequestMapping or other mapping annotations.
• Implement the required CRUD operations within the handler methods using appropriate annotations like @GetMapping, @PostMapping, etc.
• Customize the request and response handling with annotations such as @RequestBody to map request payloads and @ResponseBody to define the response body.
• Configure additional features like exception handling, input validation, and security, if required.
• Run the Spring Boot application and the API endpoints will be accessible based on the mappings defined in the controller.

Spring Boot provides integration with messaging systems like RabbitMQ through the Spring AMQP project. To integrate RabbitMQ with a Spring Boot application, you can include the spring-boot-starter-amqp dependency and configure the necessary properties in the application's configuration file (application.properties or application.yml).

You can use the RabbitTemplate class to send messages to RabbitMQ and consume messages using @RabbitListener annotations on appropriate methods.

Spring Boot Data JPA is a sub-project of Spring Data that provides enhanced support for JPA (Java Persistence API)-based repositories in Spring Boot applications. It simplifies the implementation of the data access layer by automatically generating the boilerplate code for common database operations.

For example, by defining a JPA entity class and extending JpaRepository, you can get CRUD operations for that entity without writing any additional code. You can also define custom queries using method name conventions or @Query annotations

To handle large file uploads in a Spring Boot application, you can configure the maximum file size limit in the application's properties file by setting the spring.servlet.multipart.max-file-size and spring.servlet.multipart.max-request-size properties to appropriate values. Additionally, you can use the MultipartFile parameter in the controller method to receive the uploaded file and process it as needed.

Spring Boot Actuator endpoints provide insights into the internals of a Spring Boot application such as health status, metrics, environment information, and more. These endpoints expose management and monitoring capabilities over HTTP or other protocols, allowing you to monitor and manage the application in production. Actuator endpoints can be customized and secured based on the specific requirements of the application.

Spring Boot Actuator metrics allow you to collect and monitor various application metrics such as HTTP request counts, response times, JVM memory usage, and database connection pool metrics.

Actuator metrics are collected by integrating with metrics libraries like Micrometer and can be exposed through various endpoints such as /actuator/metrics. These metrics can be visualized using monitoring tools like Prometheus, Grafana, or the built-in Actuator endpoints.

To implement a microservices architecture using Spring Boot, you can follow these steps:

• Identify the different business capabilities and boundaries of your application.
• Design and develop each microservice as a separate Spring Boot application, encapsulating a specific business capability.
• Use lightweight communication mechanisms like REST or messaging for inter-service communication.
• Implement service discovery and registration using tools like Netflix Eureka or HashiCorp Consul.
• Apply fault tolerance and resilience patterns like circuit breakers (Hystrix) and distributed tracing (Sleuth) for better reliability.
• Deploy and manage microservices using containerization platforms like Docker and orchestration tools like Kubernetes.

The Spring Cloud Netflix stack provides integration with various Netflix OSS components to simplify the development of distributed systems in a Spring Boot application. It includes modules like Eureka for service discovery, Ribbon for client-side load balancing, Hystrix for fault tolerance, and Zuul for API gateway functionality.
These components enable developers to build scalable and resilient microservices architectures by providing out-of-the-box solutions for common distributed system challenges.

Spring Boot DevTools is a set of developer tools that enhance the development experience for Spring Boot applications. It provides features like automatic application restart on code changes, live reloading of static resources, and enhanced logging during development.

DevTools helps in reducing the development turnaround time by eliminating the need for manual restarts and providing quick feedback on code changes.

To implement distributed tracing in a Spring Boot application with Spring Cloud Sleuth, you can include the necessary dependencies like spring-cloud-starter-sleuth. Sleuth integrates with popular distributed tracing systems like Zipkin or Jaeger.

Once configured, Sleuth automatically adds trace and span identifiers to the application's logs and propagates them across different services. This allows you to trace the flow of requests across multiple services and analyze performance bottlenecks.

Reactive programming in Spring Boot with Spring WebFlux is based on the Reactive Streams specification and enables non-blocking, event-driven programming for building scalable and resilient applications.

Spring WebFlux provides an alternative to the traditional Servlet-based programming model and allows developers to handle requests asynchronously using reactive types like Mono and Flux. This approach is well-suited for handling high concurrency and building reactive systems that can handle a large number of concurrent connections with limited resources.

Spring Boot provides integration with Apache Kafka through the Spring Kafka project. You can include the spring-boot-starter-kafka dependency to get started.

Spring Kafka provides abstractions to produce and consume messages from Kafka topics using the KafkaTemplate and @KafkaListener annotations, respectively. Additionally, Spring Kafka integrates with Spring Boot's auto-configuration to simplify the configuration of Kafka-related properties.

Spring Boot's caching abstraction provides a convenient way to cache the results of expensive operations, reducing the response time and improving application performance. By using annotations like @Cacheable, @CachePut, and @CacheEvict, you can easily cache method results based on specified cache names or keys.

The caching abstraction supports various cache providers, such as Redis or Ehcache, and can be easily configured using the application's properties file.

Include corresponding dependencies (flyway-core or liquibase-core) to perform database migrations in a Spring Boot application using Flyway or Liquibase. By placing the migration scripts in the classpath (src/main/resources/db/migration), Flyway or Liquibase will automatically execute the scripts during application startup.

These migration scripts allow you to manage database schema changes, versioning, and data initialization in a controlled manner.

Externalized configuration in Spring Boot allows you to configure the application using external properties files, environment variables, or command-line arguments. This approach decouples the application configuration from the code, making it more flexible and easier to manage.

The externalized configuration enables the application to be deployed in different environments without modifying the code. Spring Boot provides a standardized and flexible way to read and use these external configurations.

To implement distributed session management in a Spring Boot application using Spring Session, follow these steps:

• Include the necessary dependencies for Spring Session and a session store implementation like Redis or Hazelcast.
• Configure the session store details, such as the connection properties, in the application's configuration file (e.g., application.properties or application.yml).
• Enable Spring Session support by annotating your configuration class with @EnableRedisHttpSession (for Redis) or @EnableHazelcastHttpSession (for Hazelcast).
• Spring Session will automatically handle session creation, serialization, and synchronization with the session store, allowing session data to be shared across multiple instances of your application.

You can use the spring-cloud-function-adapter-aws dependency to implement serverless functions using Spring Boot and AWS Lambda. You can deploy Spring Boot applications as serverless functions on AWS Lambda by creating a function bean and configuring the AWS Lambda handler.

The adapter takes care of the integration between Spring Cloud Function and AWS Lambda, allowing you to develop serverless functions using the familiar Spring Boot programming model.

To implement method-level security in a Spring Boot application, you can use the @PreAuthorize or @PostAuthorize annotations provided by Spring Security. Here's an example:

• Configure Spring Security in your application by including the necessary dependencies and configuration.
• Annotate the methods that require security checks with @PreAuthorize or @PostAuthorize.
• Specify the desired security expressions in the annotations to define the required conditions for method invocation.
• Spring Security will evaluate the expressions and allow or deny access to the methods based on the configured security rules.

To implement server-sent events (SSE) in a Spring Boot application, you can use the SseEmitter class provided by Spring Framework. Here's an example of how to implement SSE:

• Create a controller method that returns an SseEmitter object.
• In this method, use the SseEmitter to send events to the client.
• Use the send() method of SseEmitter to send events periodically or based on specific triggers.
• Set appropriate headers, such as Content-Type and Cache-Control, for SSE support.
• Register the SseEmitter as a handler method in your controller.

You can use the Spring Security OAuth2 module to integrate Spring Boot with OAuth 2.0. By configuring the appropriate OAuth 2.0 provider details and defining the client registration properties, Spring Boot can handle the authentication and authorization flow.

You can secure your endpoints by applying Spring Security annotations like @PreAuthorize or by using declarative configuration. This integration enables secure authentication and authorization using OAuth 2.0 standards.

To implement data caching in a Spring Boot application, you can leverage the Spring Cache Abstraction. Follow these steps:

• Enable caching support by annotating your configuration class with @EnableCaching.
• Add the desired cache implementation library, such as Ehcache or Caffeine, as a dependency.
• Annotate the methods that should be cached with @Cacheable and specify the cache name or key.
• Configure the cache properties, such as eviction policies and time-to-live, in the cache implementation's configuration file or using Spring Boot's properties.

To configure a custom error page in a Spring Boot application, you can create a custom error controller and map it to a specific URL or error status code. Here's an example:

• Create a class implementing the ErrorController interface.
• Annotate the class with @Controller and, optionally, with @RequestMapping to specify the mapping URL or error status code.
• Implement a method that handles the error and returns the desired error page view or response.
• Register the custom error controller as a bean in the application context.
• Optionally, configure the error page mapping in the application.properties or application.yml file using properties like server.error.path or server.error.whitelabel.enabled.

To implement distributed tracing in a Spring Boot application using OpenTelemetry, you can include the necessary OpenTelemetry dependencies such as open telemetry-API and an OpenTelemetry exporter. Configuring the exporter lets you send trace data to a distributed tracing system like Jaeger or Zipkin.

OpenTelemetry automatically instructs the application to capture and propagate trace information across different services, allowing you to trace the execution path of requests in a distributed system.

Spring Boot provides support for asynchronous processing through the use of the @Async annotation and the TaskExecutor interface. To implement asynchronous processing, follow these steps:

• Configure a TaskExecutor bean in your application's configuration. This bean defines the thread pool or executor service used for executing asynchronous tasks.
• Annotate the methods that need to be executed asynchronously with the @Async annotation.
• Invoke the annotated methods from other parts of your application. The invocation will return a Future object which can be used to obtain the result of the asynchronous task or monitor its progress.

To enable HTTPS in a Spring Boot application, you need to configure the appropriate SSL certificate and modify the application's configuration. Here are the general steps:

• Obtain an SSL certificate and private key.
• Configure the certificate and private key in the application's configuration, such as application.properties or application.yml, using properties like server.ssl.key-store and server.ssl.key-password.
• Set the server.ssl.enabled property to true to enable HTTPS.
• Optionally, configure other SSL-related properties like the SSL protocol and cipher suites.
• Restart the application for the changes to take effect.