100 Spring Boot Interview Questions and Answers PDF 2025

Spring Boot is a powerful, open-source Java-based framework designed to simplify the development of production-ready, stand-alone Spring applications. It removes much of the boilerplate configuration required by traditional Spring, making it faster and easier to create web applications, microservices, REST APIs, and enterprise-grade systems. A Spring Boot developer is responsible for building scalable backend services, configuring application components, handling dependencies, and integrating databases, messaging queues, and cloud services using Spring Boot’s auto-configuration and starter modules.

With the rise of microservice architecture and cloud-native development, Spring Boot has become a must have skill for Java developers in top tech companies. Understanding key Spring Boot concepts like dependency injection, RESTful service creation, application configuration, exception handling, and performance tuning is essential.

In this comprehensive guide, we’ve included 100 Spring Boot Interview Questions and Answers for both freshers and experienced professionals, also special section with a strong focus on Java Spring Boot topics.

Spring Boot Interview Questions and Answers for Freshers

Que 1. How does Spring Boot auto-configuration work internally?

Answer:
Spring Boot uses the @EnableAutoConfiguration annotation (internally enabled by @SpringBootApplication) to scan the classpath and automatically configure beans based on available dependencies. It leverages the spring.factories file from all included JARs, loading configuration classes conditionally using annotations like @ConditionalOnClass, @ConditionalOnMissingBean, and @ConditionalOnProperty. This removes the need for boilerplate configurations by creating only the beans that match the application context’s current state.

Que 2. What is the difference between @Component, @Service, and @Repository in Spring Boot?

Answer:
While all three annotations mark a class as a Spring-managed component, they have semantic differences:

• @Component: Generic stereotype for any Spring-managed component.
• @Service: Indicates service-layer logic; helps clarify business logic.
• @Repository: Indicates DAO or persistence logic and adds persistence-related exception translation.

All three are detected during component scanning, but @Repository applies additional features like PersistenceExceptionTranslationPostProcessor.

Que 3. How would you profile different environments in a Spring Boot application?

Answer:
Spring Boot uses profiles to group environment-specific configurations. You can create properties files like application-dev.properties and application-prod.properties and activate them using:

• spring.profiles.active=dev in application.properties
• Command-line: java -jar app.jar –spring.profiles.active=prod
• Programmatically using SpringApplication.setAdditionalProfiles().

Profiles help isolate configurations for development, testing, and production environments.

Que 4. How does Spring Boot handle externalized configuration?

Answer:
Spring Boot follows a predefined property resolution order. Properties can be defined in:

• application.properties or application.yml
• Environment variables
• Command-line arguments
• Config server (Spring Cloud)

The higher the order, the higher the priority. You can inject values using @Value or @ConfigurationProperties. This allows you to modify application behavior without recompiling the code.

Que 5. What is the role of @SpringBootApplication?

Answer:
@SpringBootApplication is a convenience annotation combining:

• @Configuration: Marks the class as a source of bean definitions
• @EnableAutoConfiguration: Enables auto-configuration
• @ComponentScan: Enables scanning for components in the current package and subpackages

Using this single annotation eliminates boilerplate and sets up a Spring Boot application with default configurations.

Que 6. How does Spring Boot simplify dependency management for web applications?

Answer: Spring Boot simplifies dependency management using Spring Boot Starters. These are pre-defined dependency bundles for specific functionalities. For example, spring-boot-starter-web includes everything needed to build a web application such as Spring MVC, an embedded Tomcat server, and JSON libraries.
This approach saves developers from manually searching and adding multiple compatible dependencies.

Example of adding a starter in Maven:

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

Que 7. What is the difference between @Controller and @RestController in Spring Boot?

Answer: @Controller and @RestController are used to define web controllers, but they behave differently. @Controller is used when you want to return a view (like JSP or Thymeleaf), while @RestController is used to return data directly (like JSON or XML).

Here is the difference in a tabular format:

Feature	@Controller	@RestController
Return type	Returns a view name (like JSP)	Returns data directly (JSON/XML)
Annotation use	Requires @ResponseBody explicitly	@ResponseBody is implied automatically
Use case	Traditional web apps with views	RESTful APIs and microservices

Relevant: Top 100 Microservices Interview Questions and Answers PDF

Que 8. How do you secure a Spring Boot REST API using Spring Security?

Answer:

1. Add spring-boot-starter-security to your project.
2. Define a SecurityFilterChain bean using HttpSecurity to configure URL-based access:

@Bean  
SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {  
    return http.csrf().disable()  
              .authorizeHttpRequests()  
              .requestMatchers("/public/**").permitAll()  
              .anyRequest().authenticated()  
              .and()  
              .httpBasic()  
              .build();  
}  

3. Use authentication providers (in-memory, JDBC, or JWT) as per requirements. Spring Boot applies default secure settings, like CSRF and password encoding, unless overridden.

Que 9. How do you create custom starter modules in Spring Boot?

Answer:
To create a custom starter:

1. Create an auto-configuration module with @Configuration classes.
2. Add conditional beans using @ConditionalOnClass or other conditions.
3. Register these classes in META-INF/spring.factories.
4. Provide dependencies via a parent BOM or POM.

This allows other applications to import your starter with minimal setup.

Que 10. What are actuator endpoints and how can you customize them?

Answer:
Spring Boot Actuator exposes endpoints like /actuator/health and /actuator/metrics for monitoring.

Customization options:

• Enable or disable endpoints in application.properties: management.endpoints.web.exposure.include=health,info
• Implement custom health indicators by extending HealthIndicator.
• Secure endpoints with Spring Security to control access.

Que 11. How do you handle exceptions globally in Spring Boot?

Answer:
You can use @ControllerAdvice and @ExceptionHandler to define global exception handlers. Example:

@ControllerAdvice  
public class GlobalExceptionHandler {  

    @ExceptionHandler(RuntimeException.class)  
    public ResponseEntity<String> handleRuntime(RuntimeException ex) {  
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ex.getMessage());  
    }  
}  

This approach provides a centralized error-handling mechanism for controllers, making your code cleaner and more maintainable.

Que 12. How does Spring Boot support database migrations?

Answer:
Spring Boot integrates with tools like Flyway and Liquibase for database migrations.

• Add the dependency (for example, flyway-core).
• Place migration scripts in db/migration (Flyway) or db/changelog (Liquibase).
• Spring Boot automatically executes these migrations at startup.

This ensures database schema changes are version-controlled and applied consistently across environments.

Que 13. How do you implement caching in Spring Boot?

Answer:

1. Enable caching with @EnableCaching on a configuration class.
2. Annotate methods with caching annotations:
   • @Cacheable: Caches method results
   • @CachePut: Updates cache when method is invoked
   • @CacheEvict: Removes cache entries
3. Configure cache providers like Ehcache, Redis, or Caffeine in application.properties.

Que 14. How does Spring Boot integrate with Hibernate for JPA?

Answer:
Spring Boot automatically configures an EntityManagerFactory and TransactionManager when it detects Hibernate and a database driver. Entities are scanned automatically. Configurations like spring.jpa.hibernate.ddl-auto control schema management. Spring Data JPA repositories can be used for CRUD operations without writing boilerplate DAO code.

Que 15. How can you build RESTful services with HATEOAS using Spring Boot?

Answer:
You can add the spring-boot-starter-hateoas dependency and return EntityModel or CollectionModel from controllers:

EntityModel<User> model = EntityModel.of(user);  
model.add(linkTo(methodOn(UserController.class).getUser(user.getId())).withSelfRel());  

Spring Boot configures HATEOAS automatically, allowing links to be embedded in responses for better API navigation.

Que 16. What are some ways to monitor performance in Spring Boot applications?

Answer:

• Use Actuator metrics with Micrometer to track JVM stats, HTTP requests, and custom metrics.
• Integrate with monitoring systems like Prometheus and Grafana.
• Use APM tools such as New Relic, AppDynamics, or Dynatrace for detailed tracing.
• Enable logging with performance-related details to identify bottlenecks.

Que 17. How does Spring Boot handle cross-origin requests (CORS)?

Answer:
You can enable CORS globally by implementing a WebMvcConfigurer:

@Override  
public void addCorsMappings(CorsRegistry registry) {  
    registry.addMapping("/**").allowedOrigins("*").allowedMethods("GET", "POST");  
}  

Alternatively, use @CrossOrigin on controllers or methods to enable CORS selectively.

Que 18. How do you schedule tasks in Spring Boot?

Answer:
Enable scheduling with @EnableScheduling and annotate methods with @Scheduled:

@Scheduled(cron = "0 0 * * * ?")  
public void runTask() {  
    // task logic  
}  

Spring Boot uses TaskScheduler for running background tasks, supporting cron expressions, fixed delays, and intervals.

Que 19. How can you optimize Spring Boot startup time?

Answer:

• Use spring-context-indexer to speed up component scanning.
• Exclude unnecessary auto-configuration classes.
• Enable lazy initialization with spring.main.lazy-initialization=true.
• Profile startup using –debug and remove unused beans or starters.

Que 20. How can you test Spring Boot applications effectively?

Answer:

• Use @SpringBootTest for integration testing.
• Mock dependencies with @MockBean or Mockito.
• Test REST endpoints with TestRestTemplate or WebTestClient.
• Use @DataJpaTest for repository testing with an in-memory database like H2.

Que 21. How does Spring Boot handle asynchronous processing?

Answer:
Enable async support with @EnableAsync and annotate methods with @Async:

@Async  
public CompletableFuture<String> process() {  
    return CompletableFuture.completedFuture("Done");  
}  

Spring Boot uses TaskExecutor to run async tasks in a thread pool, improving application responsiveness.

Que 22. What are the differences between @RestController and @Controller?

Answer:

• @Controller: Returns view names or model data, and requires @ResponseBody to return JSON or XML.
• @RestController: Combines @Controller and @ResponseBody, making all methods return data directly as JSON or XML by default.

Que 23. How does Spring Boot support reactive programming?

Answer:
Spring Boot provides spring-boot-starter-webflux, which is built on Project Reactor. It supports Mono and Flux for asynchronous, non-blocking programming:

@GetMapping("/users")  
public Flux<User> getUsers() {  
    return userService.findAllUsers();  
}  

WebFlux is ideal for applications with high concurrency requirements.

Que 24. How do you configure connection pooling in Spring Boot?

Answer:
Spring Boot uses HikariCP as the default connection pool. Configure it in application.properties:

spring.datasource.hikari.maximum-pool-size=10  
spring.datasource.hikari.connection-timeout=30000  

You can also configure idle connections, validation queries, and timeouts for optimal performance.

Que 25. How can you consume external REST APIs in Spring Boot?

Answer:

• Use RestTemplate for synchronous HTTP requests.
• Use WebClient for non-blocking, reactive requests:

WebClient.create().get().uri(url).retrieve().bodyToMono(String.class);  

You can also add retry and error-handling mechanisms using libraries like Resilience4j.

Que 26. How do you handle configuration encryption in Spring Boot?

Answer:
You can integrate Spring Cloud Config with a secure vault such as HashiCorp Vault, or use Jasypt to encrypt sensitive values in properties files. Encrypted properties are decrypted at runtime, keeping secrets like passwords secure.

Que 27. What are custom events in Spring Boot and how do you use them?

Answer:
You can publish custom events using the ApplicationEventPublisher:

applicationEventPublisher.publishEvent(new UserCreatedEvent(user));  

Listeners annotated with @EventListener can consume these events. Events can also be handled asynchronously if needed.

Que 28. How do you handle file uploads in Spring Boot?

Answer:

• Configure maximum file sizes with spring.servlet.multipart properties.
• Accept files using MultipartFile parameters in controller methods.
• Save uploaded files to the filesystem, a database, or cloud storage as per requirements.

Que 29. How do you implement custom validation in Spring Boot?

Answer:

• Use JSR-380 annotations like @NotNull, @Size, etc.
• Create custom annotations and implement ConstraintValidator for custom rules.
• Apply validation using @Valid in controller methods and handle errors with BindingResult.

Que 30. How do you configure and use message queues in Spring Boot?

Answer:

• Integrate RabbitMQ with spring-boot-starter-amqp or Kafka with spring-kafka.
• Create listeners using @RabbitListener or @KafkaListener.
• Configure connection details and topic or queue names in application.properties.

Que 31. How do you create a custom HealthIndicator in Spring Boot Actuator?

Answer:
Implement the HealthIndicator interface:

@Component  
public class CustomHealthIndicator implements HealthIndicator {  
    public Health health() {  
        return Health.up().withDetail("service", "running").build();  
    }  
}  

This integrates with the /actuator/health endpoint.

Que 32. How does Spring Boot integrate with GraphQL?

Answer:
You can use spring-boot-starter-graphql and define your GraphQL schema files under classpath:graphql. Use @QueryMapping and @MutationMapping annotations in controllers to resolve queries and mutations. Spring Boot automatically configures GraphQL runtime and tools.

Que 33. How do you handle large file downloads efficiently in Spring Boot?

Answer:
Use streaming responses to avoid loading the entire file in memory:

@GetMapping("/download")  
public ResponseEntity<Resource> download() {  
    return ResponseEntity.ok()  
                         .contentType(MediaType.APPLICATION_OCTET_STREAM)  
                         .body(new FileSystemResource(file));  
}  

Que 34. How do you secure sensitive endpoints in Spring Boot Actuator?

Answer:

• Expose only required endpoints using management.endpoints.web.exposure.include.
• Secure endpoints using Spring Security roles and authentication.
• Use a separate management port with management.server.port and firewall restrictions.

Que 35. How do you implement rate limiting in Spring Boot?

Answer:

• Use Resilience4j RateLimiter to restrict API calls per second.
• Implement rate limiting at the filter level for REST endpoints.
• Use API gateways like Spring Cloud Gateway or Nginx for centralized rate-limiting policies.

Que 36. How do you debug circular dependencies in Spring Boot?

Answer:

• Set spring.main.allow-circular-references=false to detect circular dependencies at startup.
• Use @Lazy injection to break the cycle temporarily.
• Refactor beans and separate responsibilities to eliminate the circular dependency.

Que 37. How do you use Spring Boot DevTools for productivity?

Answer:
Spring Boot DevTools provides features like automatic restarts, live reload, and disabled caching during development. Adding the spring-boot-devtools dependency allows the application to restart automatically whenever classpath files change.

Que 38. How can you implement internationalization (i18n) in Spring Boot?

Answer:

• Create message properties files such as messages_en.properties and messages_fr.properties.
• Define a LocaleResolver bean to manage locale changes.
• Use @RequestHeader(“Accept-Language”) or query parameters to switch languages dynamically.
• Retrieve localized messages using MessageSource.

Que 39. How do you configure a Spring Boot application as a Docker container?

Answer:

• Create a Dockerfile:

FROM openjdk:17  
COPY target/app.jar app.jar  
ENTRYPOINT ["java","-jar","/app.jar"]  

• Build and run:

docker build -t app .  
docker run -p 8080:8080 app  

Spring Boot’s self-contained JARs make Dockerization straightforward.

Que 40. How do you handle graceful shutdown in Spring Boot?

Answer:
Enable server.shutdown=graceful in application.properties. Spring Boot will wait for active requests to complete before shutting down the application. You can also implement SmartLifecycle or use a shutdown hook to perform custom cleanup tasks.

Also Check: Rest API Interview Questions and Answers

Spring Boot Interview Questions and Answers for Experienced

Que 41. How do you override specific auto-configuration classes in Spring Boot?

Answer:
Experienced developers often need to replace or fine-tune auto-configured beans. You can use the following approaches:

• Exclude specific auto-configuration classes using @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
• Use spring.autoconfigure.exclude in application.properties for exclusions
• Define a custom bean of the same type in your configuration. Spring Boot will use the user-defined bean instead of the auto-configured one.

Que 42. How do you handle distributed tracing in a Spring Boot microservices architecture?

Answer:
Distributed tracing is essential for debugging across multiple services. You can:

• Integrate Spring Cloud Sleuth, which automatically adds trace IDs and span IDs to logs.
• Use Zipkin or OpenTelemetry for collecting and visualizing trace data.
• Configure propagation of tracing headers (X-B3-TraceId, X-B3-SpanId) between services.
• Ensure asynchronous processing does not break trace context by leveraging Sleuth’s async support.

Que 43. What strategies can you use for zero-downtime deployments of Spring Boot applications?

Answer:

• Implement rolling updates or blue-green deployment strategies using Kubernetes or cloud platforms.
• Use externalized sessions (e.g., Redis) so that session data is not lost when an instance restarts.
• Gracefully shut down applications using server.shutdown=graceful to avoid dropping requests.
• Apply health checks with Actuator to control load balancer traffic routing during deployment.

Que 44. How do you optimize memory usage for Spring Boot applications in containers?

Answer:

• Set JVM memory flags dynamically using container-aware settings (e.g., -XX:+UseContainerSupport).
• Remove unused starters and dependencies to reduce bean count.
• Use lazy initialization with spring.main.lazy-initialization=true.
• Reduce Tomcat thread pool size and disable unused endpoints.
• Use class data sharing and GraalVM native images where appropriate.

Que 45. How do you secure REST endpoints in a Spring Boot application using Spring Security?

Answer: Securing REST endpoints in Spring Boot is typically achieved using Spring Security. You can configure authentication and authorization using a SecurityFilterChain bean.

Example:

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated())
            .httpBasic();
        return http.build();
    }
}

This configuration requires users accessing /admin/** endpoints to have the ADMIN role while all other endpoints require authentication.

Que 46. What is the difference between @Component, @Service, and @Repository in Spring Boot, and when would you use each?

Answer: These annotations are specializations of @Component and help developers logically categorize beans.

Annotation	Purpose	Typical Use Case
@Component	Generic stereotype for any Spring-managed component	Utility or helper classes
@Service	Indicates that the class contains business logic	Business service classes handling operations
@Repository	Indicates that the class is a DAO (Data Access Object) and enables exception translation	Database interaction classes communicating with the data layer

Using these annotations improves code readability and makes Spring’s exception translation mechanisms work correctly for data access layers.

Que 47. How can you handle large-scale configuration management in Spring Boot?

Answer:

• Use Spring Cloud Config for centralized configuration management.
• Leverage Vault or AWS Secrets Manager for secure secret management.
• Dynamically refresh beans using @RefreshScope when configurations change.
• Organize configuration profiles per environment (dev, staging, prod).

Que 48. How do you build resilient Spring Boot microservices using Resilience4j?

Answer:
Resilience4j provides fault-tolerance patterns like Circuit Breaker, Bulkhead, Retry, and Rate Limiter:

• Add resilience4j-spring-boot2 dependency.
• Annotate methods with @CircuitBreaker, @Retry, etc.
• Configure thresholds in application.yml:

resilience4j.circuitbreaker:  
  instances:  
    serviceA:  
      failureRateThreshold: 50  
      waitDurationInOpenState: 10s  

• Monitor resilience metrics via Actuator endpoints.

Que 49. How do you handle versioning of REST APIs in Spring Boot?

Answer:

• Use URI versioning (e.g., /v1/users).
• Use request header or content negotiation versioning with @RequestMapping headers.
• Maintain backward compatibility by deprecating old versions gradually.

Que 50. How do you configure Spring Boot for multi-tenancy with Hibernate?

Answer:

• Implement MultiTenantConnectionProvider and CurrentTenantIdentifierResolver.
• Configure Hibernate with the appropriate multi-tenancy strategy (DATABASE, SCHEMA, or DISCRIMINATOR).
• Use @Transactional with tenant context to isolate transactions per tenant.

Que 51. How can you improve the startup time of a large Spring Boot application?

Answer:

• Use spring-context-indexer to accelerate component scanning.
• Avoid eager initialization of beans by enabling lazy initialization.
• Disable unused auto-configuration classes.
• Profile startup using Actuator or Flight Recorder and optimize slow beans.
• Build native images with Spring Native to achieve faster startup times.

Que 52. How do you implement custom metrics in Spring Boot Actuator?

Answer:

• Inject MeterRegistry and register counters, gauges, or timers programmatically:

meterRegistry.counter("custom.requests").increment();

• Create @Component classes implementing MeterBinder for reusable metrics.
• Expose metrics to Prometheus or other monitoring systems for visualization.

Que 53. How do you secure Spring Boot applications with OAuth2 and JWT?

Answer:

• Use spring-boot-starter-oauth2-resource-server and configure it as a resource server.
• Validate JWT tokens using jwk-set-uri or public keys.
• Apply method-level security with @PreAuthorize and scopes.
• Cache tokens to minimize authorization server calls.

Que 54. How do you handle database migrations in a multi-node Spring Boot application?

Answer:

• Use Flyway or Liquibase with a lock table to ensure migrations run once.
• Run migrations during a dedicated startup job before scaling nodes.
• Avoid running schema-altering migrations in parallel instances.

Que 55. How do you troubleshoot and fix memory leaks in Spring Boot applications?

Answer:

• Analyze heap dumps with tools like Eclipse MAT or VisualVM.
• Check for unclosed resources (InputStreams, JDBC connections).
• Avoid static references to Spring beans or collections.
• Monitor thread pools for unreleased threads.

Que 56. How do you integrate Spring Boot with Kafka for event-driven systems?

Answer:

• Add spring-kafka dependency and configure brokers in application.yml.
• Use @KafkaListener for consumers and KafkaTemplate for producers.
• Implement error handling and dead-letter topics for failed messages.
• Scale consumers by configuring consumer groups and partitions.

Que 57. How do you configure connection pooling for high-traffic applications?

Answer:

• Use HikariCP (default) and tune properties like maximumPoolSize and idleTimeout.
• Configure datasource validation queries to avoid stale connections.
• Use read/write replicas with a routing DataSource for scalability.

Que 58. How do you enable asynchronous logging in Spring Boot?

Answer:

• Switch to Log4j2 and enable AsyncAppender in log4j2-spring.xml.
• Use a separate thread pool for logging to prevent blocking application threads.

Que 59. How do you build and deploy Spring Boot applications as GraalVM native images?

Answer:

• Add spring-native dependency and use the native-build-tools plugin.
• Build the native image: mvn spring-boot:build-image -Pnative.
• Ensure reflection hints are configured for runtime libraries.

Que 60. How do you use Spring Boot with Kubernetes for scaling?

Answer:

• Externalize configurations with ConfigMaps and Secrets.
• Use liveness and readiness probes based on Actuator health endpoints.
• Leverage Horizontal Pod Autoscaler based on CPU/memory/metrics.
• Use distributed caches (e.g., Redis) to handle state.

Que 61. How do you secure Spring Boot applications using mutual TLS (mTLS)?

Answer:

• Configure the embedded Tomcat or Jetty server with clientAuth=NEED in application.properties.
• Import trusted client certificates into the server’s truststore.
• Clients must present valid certificates signed by a trusted CA during the SSL handshake.
• Use Spring Security to further validate certificate details if necessary.

Que 62. How do you reduce the size of Spring Boot fat JARs for production?

Answer:

• Use the spring-boot-maven-plugin with the layered JAR option for better caching in containers.
• Exclude unused starters and dependencies.
• Use ProGuard or the Maven shade plugin for bytecode minimization.
• Switch to Spring Boot thin launcher for runtime dependency resolution if appropriate.

Que 63. How do you handle slow external service dependencies in Spring Boot?

Answer:

• Use asynchronous calls with @Async or WebClient to avoid blocking.
• Implement timeouts at HTTP client level.
• Use Resilience4j or similar libraries for retries, fallbacks, and circuit breakers.
• Cache responses for repeated requests to reduce latency.

Que 64. How do you customize error responses in Spring Boot REST APIs?

Answer:

• Implement a @ControllerAdvice with @ExceptionHandler methods for different exception types.
• Extend ResponseEntityExceptionHandler and override handleExceptionInternal.
• Customize the ErrorAttributes bean to change the structure of the default error response.

Que 65. How do you handle high-throughput data processing in Spring Boot?

Answer:

• Use reactive programming with Spring WebFlux for non-blocking IO.
• Process data asynchronously using Project Reactor or CompletableFutures.
• Use messaging systems like Kafka or RabbitMQ for backpressure handling.
• Partition workloads across multiple consumers or instances.

Que 66. How do you handle large file uploads in a Spring Boot microservices environment?

Answer:

• Use streaming APIs like Servlet 3.1’s InputStream to avoid loading entire files in memory.
• Store uploaded files in cloud storage (S3, Azure Blob) directly from the client to offload traffic.
• Tune multipart configuration (spring.servlet.multipart.max-file-size).
• Use message queues to process files asynchronously.

Que 67. How do you secure Spring Boot applications in production?

Answer:

• Use HTTPS everywhere and enforce strong cipher suites.
• Configure CSRF protection and input validation.
• Avoid exposing Actuator endpoints without authentication.
• Rotate secrets regularly and store them securely (Vault, KMS).
• Scan dependencies for vulnerabilities using tools like OWASP Dependency Check.

Que 68. How do you handle distributed transactions in Spring Boot microservices?

Answer:

• Use Saga or Choreography patterns instead of 2PC for better scalability.
• Implement outbox pattern to reliably publish events.
• Use a transactional message broker (e.g., Kafka with exactly-once semantics) when possible.

Que 69. How do you scale Spring Boot applications horizontally?

Answer:

• Design stateless services and externalize session state.
• Use load balancers like NGINX, AWS ELB, or Kubernetes services.
• Tune database connection pools and cache layers.
• Ensure idempotency for API calls when scaling.

Que 70. How do you handle logging correlation across microservices?

Answer:

• Use Spring Cloud Sleuth to inject trace IDs into logs automatically.
• Pass trace context through HTTP headers.
• Aggregate logs using ELK stack (Elasticsearch, Logstash, Kibana) or OpenSearch.

Que 71. How do you monitor the health of a Spring Boot application in production?

Answer:

• Use Actuator health endpoints and customize them with additional checks (DB, caches).
• Integrate with Prometheus and Grafana for metrics visualization.
• Configure alerting rules for critical metrics (memory usage, thread pool saturation).

Que 72. How do you optimize database performance in Spring Boot applications?

Answer:

• Use connection pooling and tune queries with indexes.
• Enable Hibernate second-level cache and query cache.
• Use projections and pagination instead of fetching large datasets.
• Profile queries using tools like p6spy or Spring Data’s query metrics.

Que 73. How do you integrate Spring Boot with gRPC?

Answer:

• Use grpc-spring-boot-starter dependency.
• Define proto files and generate gRPC stubs.
• Expose services as @GrpcService and call using generated clients.
• Configure TLS and load balancing as needed.

Que 74. How do you handle schema evolution for NoSQL databases in Spring Boot?

Answer:

• Maintain migration scripts and use tools like Mongock or Liquibase for MongoDB.
• Use versioning within documents and adapt code for backward compatibility.
• Perform rolling updates that handle both old and new document structures.

Que 75. How do you build multi-module projects with Spring Boot?

Answer:

• Structure parent-child Maven modules with a shared parent POM for dependency management.
• Place common configurations and utilities in a core module.
• Use Spring Boot’s dependency management plugin in the parent POM.

Que 76. How do you improve thread pool management in Spring Boot applications?

Answer:

• Configure TaskExecutor beans with appropriate corePoolSize and maxPoolSize.
• Use different thread pools for CPU-bound and IO-bound tasks.
• Monitor thread pool metrics using Actuator and tune based on workload.

Que 77. How do you integrate Spring Boot with ELK for centralized logging?

Answer:

• Use Logstash or Filebeat to ship logs to Elasticsearch.
• Structure logs in JSON format using Logback encoder.
• Visualize and analyze logs in Kibana.

Que 78. How do you secure REST APIs with rate limiting and throttling?

Answer:

• Use API Gateway features or Resilience4j RateLimiter.
• Implement rate-limiting filters using Redis or in-memory counters.
• Return HTTP 429 Too Many Requests when limits are exceeded.

Que 79. How do you debug classpath issues in large Spring Boot projects?

Answer:

• Run with –debug flag to view auto-configuration report.
• Use mvn dependency:tree or gradle dependencies to detect conflicts.
• Exclude duplicate or conflicting dependencies.

Que 80. How do you design Spring Boot applications for cloud-native environments?

Answer:

• Build stateless services and externalize configurations.
• Implement health checks and metrics endpoints.
• Use distributed tracing and centralized logging.
• Apply 12-factor app principles for portability and scalability.

Also Check: Spring Boot Interview Questions for Experienced Professional

Java Spring Boot Interview Questions and Answers

Que 81. How does Spring Boot simplify the creation of production-ready applications?

Answer:
Spring Boot provides opinionated defaults, auto-configuration, and embedded servers that allow developers to focus on business logic instead of configuration. Key features include:

• Auto-configuration based on classpath dependencies.
• Embedded servers (Tomcat, Jetty, Undertow) eliminating external deployment.
• Starter dependencies for common use cases like web, data access, and security.
• Actuator for production monitoring and health checks.

Que 82. What is the difference between Spring Boot starters and traditional dependency management?

Answer:

• Starters: Pre-defined dependency sets that reduce manual dependency management. For example, spring-boot-starter-web automatically includes Spring MVC, Jackson, validation libraries, and an embedded Tomcat server.
• Traditional: Developers manually select and manage compatible versions of each dependency.
  Starters reduce compatibility issues and simplify project setup.

Que 83. How do you secure REST APIs in Spring Boot using JWT?

Answer:

• Add spring-boot-starter-security and JWT dependencies.
• Implement an authentication filter that validates tokens from the Authorization header.
• Generate JWT tokens after successful login.
• Secure endpoints by configuring SecurityFilterChain with HttpSecurity. Example:

http.csrf().disable()
    .authorizeHttpRequests()
    .requestMatchers("/auth/**").permitAll()
    .anyRequest().authenticated()
    .and()
    .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);

Que 84. How do you configure multiple data sources in Spring Boot?

Answer:

• Define two DataSource beans using @Configuration and @Bean annotations.
• Mark one as @Primary if it will be the default.
• Create EntityManagerFactory and TransactionManager beans for each data source.
  This allows separate database connections for different modules or tenants.

Que 85. What is the difference between @SpringBootApplication and manually using @Configuration, @EnableAutoConfiguration, and @ComponentScan?

Answer: @SpringBootApplication is a convenience annotation that combines three core annotations:

Annotation	Purpose
@Configuration	Indicates that the class contains bean definitions for the application context
@EnableAutoConfiguration	Automatically configures Spring Boot based on the dependencies present on the classpath
@ComponentScan	Scans the specified packages for Spring-managed components (beans, controllers, etc.)

When you use @SpringBootApplication, all three annotations are implicitly applied, simplifying your configuration. However, using them separately gives you more granular control over auto-configuration and component scanning.

Que 86. How can you handle exceptions globally in Spring Boot?

Answer:

• Use @ControllerAdvice and @ExceptionHandler for centralized error handling. Example:

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntime(RuntimeException ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ex.getMessage());
    }
}

This approach keeps controllers clean and provides consistent responses.

Que 87. How do you integrate Spring Boot with Kafka?

Answer:

• Add spring-kafka dependency.
• Configure Kafka broker details in application.yml.
• Use @KafkaListener to consume messages and KafkaTemplate to produce messages.
  Example:

@KafkaListener(topics = "orders", groupId = "order-group")
public void consume(String message) {
    // process message
}

Que 88. How do you use Spring Boot Actuator in production?

Answer:
Spring Boot Actuator provides production-ready features such as health checks, metrics, and environment details.

• Add spring-boot-starter-actuator dependency.
• Enable or disable endpoints in application.properties:

management.endpoints.web.exposure.include=health,info,metrics

• Secure actuator endpoints using Spring Security.
• Integrate with monitoring tools like Prometheus and Grafana for deeper observability.

Que 89. How do you implement scheduling in Spring Boot?

Answer:

• Enable scheduling with @EnableScheduling in a configuration class.
• Annotate methods with @Scheduled to run periodically:

@Scheduled(cron = "0 0 * * * ?")
public void cleanUpTask() {
    // logic
}

You can use fixed delay, fixed rate, or cron expressions based on requirements.

Que 90. How do you use Spring Profiles for environment-specific configuration?

Answer:

• Create property files like application-dev.properties and application-prod.properties.
• Activate a profile by setting spring.profiles.active=dev in application.properties or as a command-line argument.
• Use @Profile(“dev”) on beans that should only load in specific environments.

Que 91. How do you integrate Spring Boot with external configuration servers?

Answer:

• Use Spring Cloud Config for centralized configuration.
• Add spring-cloud-starter-config dependency.
• Point your application to the Config Server using spring.cloud.config.uri.
• Use @RefreshScope on beans to dynamically reload updated configurations without restarting the application.

Que 92. How do you write integration tests in Spring Boot?

Answer:

• Use @SpringBootTest to load the full application context.
• Mock dependencies using @MockBean when necessary.
• Test REST endpoints with TestRestTemplate or WebTestClient. Example:

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class UserControllerTest {
    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void testGetUsers() {
        ResponseEntity<String> response = restTemplate.getForEntity("/users", String.class);
        assertEquals(HttpStatus.OK, response.getStatusCode());
    }
}

Que 93. How do you enable internationalization (i18n) in Spring Boot applications?

Answer:

• Create messages.properties files for different locales (e.g., messages_en.properties, messages_fr.properties).
• Define a LocaleResolver bean and optionally allow locale switching using query parameters.
• Use MessageSource or @Autowired MessageSource to fetch localized messages.

Que 94. How do you configure REST API versioning in Spring Boot?

Answer:

• Versioning can be done using URI versioning (e.g., /v1/users), request parameters, or headers.
• Use @RequestMapping annotations with different paths or headers for each version.
• Keep older versions backward compatible until deprecated.

Que 95. How do you create custom starter modules in Spring Boot?

Answer:

• Create an auto-configuration module with @Configuration classes.
• Register auto-configuration classes in META-INF/spring.factories.
• Publish your starter as a JAR so other projects can include it and get pre-configured beans.

Que 96. How do you secure Spring Boot actuator endpoints?

Answer:

• Use Spring Security to restrict access:

http.authorizeHttpRequests()
    .requestMatchers("/actuator/**").hasRole("ADMIN")
    .anyRequest().authenticated();

• Alternatively, configure basic authentication or API tokens specifically for actuator endpoints.

Que 97. How do you implement rate limiting in Spring Boot?

Answer:

• Use Resilience4j RateLimiter or Bucket4j libraries.
• Implement a filter or interceptor that tracks requests per client.
• Return HTTP 429 Too Many Requests when limits are exceeded.

Que 98. How do you configure database migrations in Spring Boot?

Answer:

• Use Flyway or Liquibase for versioned database migrations.
• Add the dependency and place migration scripts in the default folder (db/migration for Flyway).
• Spring Boot automatically runs migrations at application startup.

Que 99. How do you integrate Spring Boot with Docker?

Answer:

• Create a Dockerfile:

FROM openjdk:17
COPY target/app.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

• Build the image using docker build and run it using docker run.
• Use Spring Boot layered jars for optimized Docker caching.

Que 100. How do you handle large file uploads and downloads in Spring Boot?

Answer:

• Configure file size limits in application.properties:

spring.servlet.multipart.max-file-size=100MB
spring.servlet.multipart.max-request-size=100MB

• Use MultipartFile for uploads and stream data directly to disk or cloud storage.
• For downloads, use streaming responses instead of loading files fully into memory.

Also Check: Java interview Questions and Answers

Spring Boot Interview Questions PDF

You can also download our complete PDF guide that includes all questions, perfect for studying offline anytime and anywhere. Use this guide to practice and improve your chances of getting a Spring Boot developer job.

FAQs: Spring Boot Interview Questions