Question 1

What is the Spring Framework?

Accepted Answer

Spring is a comprehensive Java framework providing infrastructure support for enterprise applications. It was created to simplify Java EE development by offering dependency injection, aspect-oriented programming, and modular architecture. Spring reduces boilerplate code, promotes loose coupling through IoC, and provides integration with databases, security, web services, and messaging systems.

Question 2

What is Inversion of Control (IoC) and Dependency Injection?

Accepted Answer

IoC is a design principle where object creation and lifecycle management is delegated to a container instead of the application code. Dependency Injection is the implementation mechanism—the container 'injects' dependencies into objects. Types: constructor injection (preferred, immutable), setter injection, and field injection (@Autowired). This enables loose coupling, easier testing, and better maintainability.

Question 3

What is the difference between @Component, @Service, @Repository, and @Controller?

Accepted Answer

@Component is a generic stereotype for any Spring-managed bean. @Service indicates business logic layer (no additional behavior, semantic only). @Repository marks data access layer and enables exception translation to Spring's DataAccessException. @Controller handles web requests in MVC. All are specializations of @Component—use the appropriate one for clarity and potential framework features.

Question 4

What are bean scopes in Spring?

Accepted Answer

Bean scopes define lifecycle and visibility. Singleton (default): one instance per container, shared across the application. Prototype: new instance each time requested. Request: one per HTTP request (web only). Session: one per HTTP session. Application: one per ServletContext. Use singleton for stateless services, prototype for stateful objects, request/session for web-specific state.

Question 5

What is Spring Boot and how does it simplify development?

Accepted Answer

Spring Boot is an opinionated framework that simplifies Spring application setup through auto-configuration, embedded servers (Tomcat, Jetty), starter dependencies, and sensible defaults. It eliminates XML configuration, provides production-ready features (health checks, metrics via Actuator), and enables rapid development. @SpringBootApplication combines @Configuration, @EnableAutoConfiguration, and @ComponentScan.

Question 6

What are Spring Boot Starters?

Accepted Answer

Starters are curated dependency descriptors that bundle related dependencies for specific functionality. spring-boot-starter-web includes Spring MVC, embedded Tomcat, Jackson. spring-boot-starter-data-jpa includes Hibernate, Spring Data JPA. They simplify dependency management, ensure compatible versions, and enable auto-configuration. Just add the starter—Spring Boot configures everything automatically.

Question 7

What is the difference between @Controller and @RestController?

Accepted Answer

@Controller is for traditional MVC returning views (HTML templates). @RestController combines @Controller and @ResponseBody—every method returns data directly serialized to JSON/XML, not view names. Use @Controller with Thymeleaf/JSP for server-rendered pages; use @RestController for REST APIs. @RestController is shorthand that eliminates @ResponseBody on every method.

Question 8

How does @RequestMapping work?

Accepted Answer

@RequestMapping maps HTTP requests to handler methods, specifying URL paths, HTTP methods, headers, and content types. Shortcuts: @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping. Use @PathVariable for URL parameters (/users/{id}), @RequestParam for query parameters, @RequestBody for JSON body. Supports pattern matching and multiple URLs per mapping.

Question 9

What is Spring Data JPA?

Accepted Answer

Spring Data JPA simplifies data access by reducing boilerplate. Define interfaces extending JpaRepository—Spring generates implementations automatically. Features: CRUD operations without code, query methods derived from method names (findByEmailAndStatus), @Query for custom JPQL/SQL, pagination/sorting support, and auditing. It wraps JPA/Hibernate while dramatically reducing repository code.

Question 10

How does the @Transactional annotation work?

Accepted Answer

@Transactional manages database transactions declaratively using AOP proxies. It starts a transaction before method execution and commits on success or rolls back on RuntimeException. Key attributes: propagation (REQUIRED, REQUIRES_NEW), isolation level, readOnly optimization, timeout, and rollbackFor/noRollbackFor. Place on service layer methods. Requires proxy-based invocation—self-invocation bypasses transaction management.

Question 11

What are transaction propagation types?

Accepted Answer

Propagation defines behavior when a transactional method calls another. REQUIRED (default): join existing or create new. REQUIRES_NEW: always create new, suspend existing. SUPPORTS: use existing or run non-transactionally. MANDATORY: require existing, throw exception if none. NEVER: throw exception if transaction exists. NESTED: nested transaction with savepoints. Choose based on atomicity requirements.

Question 12

What is Spring Security?

Accepted Answer

Spring Security is a comprehensive authentication and authorization framework. It provides: authentication (username/password, OAuth2, JWT, LDAP), authorization (URL-based, method-level with @PreAuthorize), CSRF protection, session management, and security headers. Configuration via SecurityFilterChain bean. It integrates seamlessly with Spring Boot and supports custom authentication providers and filters.

Question 13

How do you implement JWT authentication with Spring Security?

Accepted Answer

Configure stateless session management, add a JWT filter before UsernamePasswordAuthenticationFilter. The filter extracts tokens from Authorization header, validates signature and expiration, and sets SecurityContext. Use jjwt or spring-security-oauth2-jose libraries. Disable CSRF for stateless APIs. Implement token refresh mechanism. Store secrets securely using environment variables or vault.

Question 14

What is Spring Boot Actuator?

Accepted Answer

Actuator provides production-ready monitoring and management endpoints: /health (application health), /metrics (JVM, HTTP stats), /info (build info), /env (configuration), /loggers (runtime log level changes), /threaddump. Enable with spring-boot-starter-actuator. Secure sensitive endpoints in production. Integrates with Prometheus, Grafana, and other monitoring tools for observability.

Question 15

How do you test Spring Boot applications?

Accepted Answer

@SpringBootTest loads full application context for integration tests. @WebMvcTest loads only MVC components for controller testing with MockMvc. @DataJpaTest configures embedded database for repository testing. @MockBean creates Mockito mocks in Spring context. Use TestRestTemplate or WebTestClient for HTTP testing. @TestConfiguration provides test-specific beans. TestContainers enables realistic database testing.

Spring Framework Fundamentals(6 questions)

What is the Spring Framework and what were the primary motivations behind its creation?

What are the key components of Spring Core and what purposes do they serve?

Explain the concept of Inversion of Control (IoC) and its implementation in Spring.

What is the difference between Dependency Injection (DI) and IoC?

What are the different approaches for defining beans in Spring (XML, annotations, JavaConfig)?

Compare and contrast the @Component, @Repository, @Service, and @Controller annotations.

Spring Beans and Configuration(5 questions)

What is a Spring bean and how is it managed by the container lifecycle?

How do you manage bean lifecycle (initialization and destruction methods)?

Explain bean scopes (singleton, prototype, session, request) and their use cases.

How does Spring's autowiring mechanism work and what are its different modes?

How do you configure and utilize Spring profiles, and when should you use them?

Spring Boot(6 questions)

What is Spring Boot and how does it simplify development compared to traditional Spring?

Explain the role and differences between application.properties and application.yml configuration files.

What are Spring Boot starters and how do they work under the hood?

How does Spring Boot integrate with embedded application servers (Tomcat, Jetty, Undertow)?

Explain key Spring Boot annotations like @SpringBootApplication and @EnableAutoConfiguration.

How do you implement application monitoring using Spring Boot Actuator and health checks?

Spring MVC and Web Layer(6 questions)

Explain the MVC architecture pattern implementation in Spring.

Describe the HTTP request flow in Spring MVC, focusing on DispatcherServlet's role.

What is the difference between @Controller and @RestController annotations?

How does request mapping work using @RequestMapping and its variants (@GetMapping, @PostMapping, etc.)?

How do you implement input validation in Spring MVC controllers?

How do you integrate template engines like Thymeleaf with Spring MVC?

Spring Data(6 questions)

What is Spring Data and what are its main modules (Spring Data JPA, MongoDB, etc.)?

Explain the CrudRepository and JpaRepository interfaces and their capabilities.

How do you define custom queries using Query Methods and JPQL?

Explain lazy vs. eager loading strategies in JPA and their performance implications.

How do you manage transactions in Spring Data applications?

How do you effectively use JPA annotations (@Entity, @Table, @Id, @OneToMany) in Spring?

Transactions and Spring AOP(5 questions)

What is Aspect-Oriented Programming (AOP) and how is it implemented in Spring?

How does the @Transactional annotation work internally and what are its key attributes?

Explain different transaction propagation types and their use cases.

What are transaction isolation levels and how do they impact application behavior?

How do you implement method-level security using AOP (@Secured, @PreAuthorize)?

Spring Security(6 questions)

What is Spring Security and what are its core security features?

How do you configure authentication and authorization in Spring Security?

Explain the most commonly used Spring Security filters (e.g., UsernamePasswordAuthenticationFilter).

How do you implement OAuth2 and JWT integration with Spring Security?

Explain the Security Filter Chain configuration approach.

How do you create custom authorization rules using @PreAuthorize, @PostAuthorize, and SpEL expressions?

Spring Cloud and Microservices Interview Questions(5 questions)

What is Spring Cloud and in which scenarios should you consider using it?

How does Service Discovery work (e.g., Eureka) and how do you configure it?

What is Spring Cloud Config and how do you implement centralized configuration management?

Explain key design patterns in Spring Cloud (Circuit Breaker, Config Server, API Gateway).

How do you integrate Spring Boot with Spring Cloud for microservices architecture?

Testing in Spring(5 questions)

How do you set up unit and integration tests in Spring applications?

What are the essential Spring testing annotations (@SpringBootTest, @MockBean, @TestConfiguration)?

How do you test controllers using MockMvc and TestRestTemplate?

How do you test the data layer using embedded databases (H2, TestContainers)?

What are the key considerations when testing microservices-based applications?

Advanced Spring Concepts(6 questions)

What is the difference between stateful and stateless Spring beans, and when does it matter?

How do you scale Spring applications using containerization, Kubernetes, and cloud platforms?

How do you implement asynchronous communication using Spring JMS, RabbitMQ, and Kafka with Spring Cloud Stream?

How do Spring events work and how do you use ApplicationEvent and ApplicationListener for modular design?

How do you handle security in distributed environments (Spring Cloud Security, SSO)?

How do you implement distributed system patterns like SAGA, CQRS, and Event Sourcing with Spring Cloud?

Performance and Production Readiness(5 questions)

What are the best practices for Spring application performance optimization?

How do you implement caching strategies in Spring applications?

How do you handle connection pooling and database optimization in Spring Data?

What are the key metrics to monitor in production Spring applications?

How do you implement graceful shutdown and health checks for containerized Spring applications?

Modern Spring Development(5 questions)

How do you implement reactive programming with Spring WebFlux?

What are the benefits and trade-offs of using Spring Native and GraalVM?

How do you implement API documentation using OpenAPI/Swagger with Spring?

How do you handle cross-cutting concerns like logging, monitoring, and distributed tracing?

What are the best practices for Spring application security in cloud-native environments?

Compare and contrast the `@Component`, `@Repository`, `@Service`, and `@Controller` annotations.

Explain the role and differences between `application.properties` and `application.yml` configuration files.

Explain key Spring Boot annotations like `@SpringBootApplication` and `@EnableAutoConfiguration`.

What is the difference between `@Controller` and `@RestController` annotations?

How does request mapping work using `@RequestMapping` and its variants (`@GetMapping`, `@PostMapping`, etc.)?

Explain the `CrudRepository` and `JpaRepository` interfaces and their capabilities.

How do you effectively use JPA annotations (`@Entity`, `@Table`, `@Id`, `@OneToMany`) in Spring?

How does the `@Transactional` annotation work internally and what are its key attributes?

How do you implement method-level security using AOP (`@Secured`, `@PreAuthorize`)?

How do you create custom authorization rules using `@PreAuthorize`, `@PostAuthorize`, and SpEL expressions?

What are the essential Spring testing annotations (`@SpringBootTest`, `@MockBean`, `@TestConfiguration`)?