Spring Boot Interview Questions

It combines @Configuration, @EnableAutoConfiguration, and @ComponentScan

@SpringBootApplication is a convenience annotation that combines @Configuration (marks class as a source of bean definitions), @EnableAutoConfiguration (enables Spring Boot's auto-configuration), and @ComponentScan (scans for components in the current package and below).

They are all specializations of @Component with semantic meaning for different layers

All four are stereotype annotations. @Component is the generic one. @Service, @Repository, and @Controller are specializations that indicate the role of the class (business logic, data access, web controller). @Repository also adds automatic exception translation for persistence.

Profiles allow you to define environment-specific configurations (dev, test, prod) activated via spring.profiles.active

Spring Boot profiles let you segregate configurations for different environments. Use application-dev.yml, application-prod.yml etc. Activate with spring.profiles.active property, environment variable, or JVM argument. You can also use @Profile annotation on beans.

A design pattern where the framework provides object dependencies instead of the object creating them itself

Dependency Injection (DI) is a design pattern where an object's dependencies are provided (injected) by the Spring container rather than the object creating them. This promotes loose coupling, testability, and separation of concerns.

Constructor injection is preferred because it supports immutability, makes dependencies explicit, and enables easier testing

Constructor injection is the recommended approach in Spring. It makes dependencies explicit, supports immutable objects (final fields), prevents circular dependencies at startup, and makes unit testing easier (you can pass mocks directly). Field injection hides dependencies and makes testing harder.

Use @Scope annotation to define lifecycle: singleton (default), prototype, request, session, or application

Spring supports several bean scopes. Singleton (default) creates one instance per Spring container. Prototype creates a new instance each time the bean is requested. Request, Session, and Application scopes are for web applications. Use @Scope annotation to specify.

201 Created

201 Created is the correct status code for successful resource creation. 200 OK is for general success, 204 No Content for successful operations with no response body, and 202 Accepted for async processing.

@PathVariable extracts values from the URL path template; @RequestParam reads query string parameters

@PathVariable extracts values from the URI template (e.g., /users/{id}). @RequestParam reads query string parameters (e.g., /users?name=John). @PathVariable is typically used for resource identification, while @RequestParam is for filtering, sorting, and optional parameters.

To define global exception handlers, model attributes, and data binders across all controllers

@ControllerAdvice is used to define global exception handling (@ExceptionHandler), model attributes (@ModelAttribute), and data binding (@InitBinder) that apply across multiple controllers. Combined with @ResponseStatus or ResponseEntity, it creates a centralized error handling strategy.

It defines a chain of servlet filters that intercept requests to apply authentication and authorization rules

SecurityFilterChain is a bean that defines a chain of security filters applied to incoming HTTP requests. Each filter handles a specific security concern (CSRF, authentication, authorization, etc.). You configure it in a @Configuration class to define which endpoints require authentication.

@Entity marks a class as a JPA entity; @Table customizes the mapped database table name and properties

@Entity (javax.persistence) marks a class as a JPA entity to be managed by the persistence context. @Table is optional and allows you to customize the table name, schema, and constraints. Without @Table, the table name defaults to the class name.

When fetching a parent entity triggers N additional queries for lazy-loaded children; solved with JOIN FETCH or @EntityGraph

The N+1 problem occurs when fetching a list of N entities triggers N additional SQL queries to load their lazy-loaded relationships. Solutions include using JOIN FETCH in JPQL, @EntityGraph annotations, or batch fetching with @BatchSize.

It wraps the annotated method in a database transaction, handling commit and rollback automatically

@Transactional creates a proxy that wraps the method in a database transaction. If the method completes normally, the transaction is committed. If a runtime exception is thrown, it is rolled back. You can customize rollback rules, propagation, and isolation levels.

update modifies the schema to match entities; validate only checks that the schema matches entities without changes

update will alter existing tables and create new ones to match your entities (but never drops columns/tables). validate only checks if the current schema matches your entities and throws an exception if it doesn't. For production, use validate or none with a migration tool like Flyway.

To provide production-ready features like health checks, metrics, and monitoring endpoints

Spring Boot Actuator provides production-ready features for monitoring and managing your application. It exposes endpoints like /actuator/health, /actuator/metrics, /actuator/info, and /actuator/env. These are essential for production monitoring and Kubernetes readiness/liveness probes.

Use @SpringBootTest with MockMvc or TestRestTemplate to test the full request/response cycle

@SpringBootTest loads the full application context. Combined with MockMvc (for testing without a real server) or TestRestTemplate (for testing with a real embedded server), you can test the entire request/response cycle including serialization, validation, and exception handling.

@MockBean replaces a bean in the Spring context; @Mock creates a standalone mock not managed by Spring

@MockBean (from Spring Boot Test) creates a mock and adds it to the Spring ApplicationContext, replacing any existing bean of the same type. @Mock (from Mockito) creates a standalone mock not managed by Spring. Use @MockBean for integration tests and @Mock for unit tests.

To act as a single entry point that routes requests to appropriate microservices, handling cross-cutting concerns

An API Gateway (e.g., Spring Cloud Gateway) serves as a single entry point for all client requests. It handles routing, load balancing, authentication, rate limiting, and other cross-cutting concerns. This simplifies client-side code and centralizes common functionality.

A resilience pattern that stops cascading failures by failing fast when a downstream service is unresponsive

The Circuit Breaker pattern (implemented by Resilience4j or Hystrix) monitors calls to a service. When failures exceed a threshold, the circuit 'opens' and subsequent calls fail immediately without attempting the network call. After a timeout, it 'half-opens' to test if the service has recovered.

WebFlux is a reactive, non-blocking web framework ideal for high-concurrency scenarios with many I/O-bound operations

Spring WebFlux is a reactive web framework that uses non-blocking I/O and the Reactor library (Mono/Flux). It excels in high-concurrency scenarios with many I/O-bound operations (microservices, streaming). Use Spring MVC for traditional request-per-thread applications; WebFlux when you need reactive streams and backpressure.