Top 50+ Spring Interview Questions and Answers [2025]

Spring Interview Questions for Freshers

These are some of the common Spring interview questions asked at the fresher level. These questions cover the basic concepts of the Spring framework, including dependency injection, bean management, and configuration.

1. What Is Spring Framework?

Spring is a widely used, open-source application framework for Java. It serves as a lightweight container that supports Inversion of Control (IoC) and Dependency Injection (DI), helping you build well-structured and loosely coupled applications. Spring includes modules like Spring Core, AOP, JDBC, MVC, and more, providing flexibility to pick only what you need.

2. What Are the Advantages of Using Spring?

This is one of the commonly asked Spring interview questions. Spring offers several major benefits for developers:

• Reduces boilerplate code: By managing object creation, DI and AOP eliminate repetitive setup code.
• Promotes loose coupling: DI and IoC help decouple classes, making your app more modular and flexible.
• Improves testability: You can easily inject mock objects for unit testing.
• Modular and scalable: Use only the needed components, from web to data access.
• Consistent programming model: Works across web apps, microservices, batch jobs, etc.
• Great community and documentation: Extensive tutorials, guides, and support.

3. What Is Inversion of Control (IoC)?

Inversion of Control means handing over the responsibility of object creation and dependency management to the framework instead of doing it manually in your code. This reverses traditional control; the framework, not your code, manages object lifecycles. In Spring, IoC is realized through Dependency Injection, improving modularity and making code easier to maintain.

4. What Is Dependency Injection in Spring?

Dependency Injection is a design pattern that implements IoC by supplying the required dependencies (objects or services) to a class rather than having the class create them itself. In Spring, you can inject dependencies via constructors, setters, or fields. DI enhances testability (by enabling mock injection) and decouples components.

5. What Are the Types of Dependency Injection Supported by Spring?

Here are the following types of dependency injection:

• Constructor injection: Dependencies are passed through the constructor, making them mandatory and immutable once set.
• Setter injection: Dependencies are set via setter methods, allowing for optional or changed dependencies after instantiation.

6. What Is a Spring Bean?

A Spring Bean is simply an object that is instantiated, assembled, and managed by the Spring container. Beans are defined in configurations, such as XML, Java, or via annotations. Once defined, Spring creates and manages its lifecycle, handling dependencies automatically.

7. Explain the Spring Bean Lifecycle

This is one of the frequently asked Spring interview questions. A bean goes through several phases:

• Instantiation: Spring creates the bean instance.
• Property population: Dependencies are injected.
• Lifecycle callbacks: Beans can implement InitializingBean.afterPropertiesSet() or define a custom init-method.
• Bean usage: The bean is now available for use.
• Shutdown: On container closing, methods annotated with @PreDestroy or DisposableBean.destroy() are called to clean up resources.

Note: Test Spring websites across 3,000+ browsers & devices. Try LambdaTest Now!

8. What Is the Difference Between Spring Framework and Spring Boot?

The Spring Framework provides a comprehensive infrastructure for Java application development with modular components like Spring Core, MVC, JDBC, etc. However, it often requires a lot of configuration.

Spring Boot, on the other hand, builds on top of Spring and aims to simplify setup. It offers:

• Auto-configuration
• Embedded servers (like Tomcat)
• No need for XML config

It lets you create production-ready applications with minimal effort.

9. What Is the Role of the @Component Annotation?

@Component is a generic stereotype annotation used to tell Spring that a class is a bean candidate. It is automatically detected during classpath scanning when @ComponentScan is used.

@Component
public class MyService {
    // your logic
}

This bean will be managed by the Spring container without needing to define it in XML.

10. What Is @ComponentScan Used for in Spring?

This is one of the most asked Spring interview questions.

@ComponentScan tells Spring where to search for classes annotated with stereotypes like @Component, @Service, @Repository, and @Controller, so it can register them as beans.

@ComponentScan(basePackages = "com.example.app")

11. What Is the Use of @Configuration and @Bean Annotations?

@Configuration marks a class as a source of bean definitions. @Bean is used within a @Configuration class to define beans manually in code.

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService();
    }
}

This approach is clean and type-safe compared to XML.

12. What Are @PostConstruct and @PreDestroy Annotations?

@PostConstruct and @PreDestroy are JSR-250 annotations for lifecycle callbacks:

• @PostConstruct: Runs once after the bean’s dependencies are set, ideal for initializing resources.
• @PreDestroy: Runs before the bean is destroyed, great for clean-up tasks like closing DB connections.

To enable these, you must have CommonAnnotationBeanPostProcessor registered, often managed automatically with <context:annotation-config/> in XML or via <annotation-config> in Java config.

13. What Is the Difference Between BeanFactory and ApplicationContext?

BeanFactory is Spring’s basic container. It supports lazy-loading: beans are created only on demand.

ApplicationContext extends BeanFactory. It pre-instantiates singleton beans, provides support for internationalization, event propagation, and integrates fully with AOP. In most modern Spring apps, ApplicationContext is the standard choice.

14. What Are the Different Bean Scopes?

This is one of the most asked Spring interview questions.

• singleton (default): One shared instance per Spring container.
• prototype: A new instance each time requested.
• Web-specific scopes:
  • request: One bean per HTTP request.
  • session: One bean per HTTP session.
  • application: Shared across the ServletContext.
  • websocket: One bean per WebSocket session.

Choosing the right scope helps manage state and resource usage effectively.

15. How Does Spring Support Database Access?

Spring offers JDBC abstraction and ORM integration (like Hibernate, JPA). It provides:

• Simplifies JDBC code.
• Declarative transaction management
• Exception translation into Spring’s DataAccessException hierarchy.

You can define DataSource beans and use templates to execute queries cleanly and safely.

16. What Is a Spring Configuration File?

This is one of the go-to Spring interview questions.

A Spring configuration file tells the Spring container how to create and wire beans. It can be in:

• XML format: Classic approach using <bean> tags to declare beans and their properties, suited for simple apps or legacy systems.
• Annotation-based config: Using annotations like @Component and scanning packages with @ComponentScan, great for reducing XML verbosity.
• Java-based config: Classes annotated with @Configuration and methods using @Bean define beans programmatically, clean and type-safe.

17. What Is the Spring Container, and What Does It Do?

The IoC container, often referred to as the Spring Container, is the heart of the framework. Its responsibilities include:

• Bean lifecycle management: It instantiates beans, injects dependencies, calls lifecycle methods, and eventually destroys them.
• Wiring objects: It reads configuration metadata (XML, annotations, or Java classes) to know how beans relate and ensures they’re connected correctly.
• AOP integration: It weaves in aspects such as transaction management and logging by applying proxies behind the scenes.

18. What Are the Design Patterns Used by Spring?

Spring makes extensive use of proven design patterns:

• Singleton pattern: For beans with singleton scope, ensures only one instance per container.
• Factory pattern: BeanFactory and ApplicationContext act as factories that create and configure beans dynamically.
• Proxy pattern: Behind the scenes for AOP use-cases like transaction management and security.
• Adapter pattern: Used in modules like Spring MVC (adapts controllers to requests) and JDBC templates.

19. What Is Autowiring, and What Are Its Modes?

Autowiring helps Spring automatically resolve and inject bean dependencies, avoiding manual <property> wiring. Modes include:

• no (default): No autowiring.
• byName: Injects bean matching the property name.
• byType: Injects bean by matching type.
• constructor: Uses constructor arguments for dependency resolution.
• Autodetect: Deprecated; tries the constructor, then the setter.

Annotations like @Autowired (plus @Qualifier) serve the same goal without XML config.

20. Explain @Required and @Qualifier Annotations

This is one of the most asked Spring interview questions.

• @Required: Ensures a bean property must be set in the configuration. If missing, Spring throws a BeanInitializationException.
• @Qualifier: Used alongside @Autowired when multiple beans of the same type exist. It tells Spring exactly which bean to inject.

21. What Is the @Controller Annotation Used For?

In Spring Framework, the @Controller annotation is used to mark a Java class as a web controller. It helps handle web requests in Spring MVC applications.

When a class is annotated with @Controller, Spring treats it as a component that will receive HTTP requests. This class is responsible for taking the request, passing it to the service layer (if needed), and returning a response, usually in the form of a view (like an HTML page or template).

@Controller
public class HomeController {

    @GetMapping("/home")
    public String homePage() {
        return "home"; // returns home.jsp or home.html
    }
}

Key Points:

• Part of the Spring MVC architecture.
• Handles web requests and returns views.
• Works closely with annotations like @RequestMapping or @GetMapping.

So, if you’re building a web app with Spring, @Controller is the starting point to make your class handle user interactions.

Spring Interview Questions for Intermediate

These Spring interview questions dive deeper into core concepts like bean scopes, autowiring, application context, and Spring MVC. They’re commonly asked in interviews for mid-level roles and are designed to assess your ability to apply Spring features in real-world development scenarios.

22. What Is Spring AOP, and How Does It Relate to the Proxy Pattern?

Spring AOP (Aspect-Oriented Programming) helps manage cross-cutting concerns like logging, security, or transaction handling by keeping them separate from the core business logic. It uses the proxy pattern, where Spring wraps your original class in a proxy object. When you call a method, the proxy intercepts the call and applies the aspect (advice) before or after delegating to the original method. The core AOP components include:

• Aspect: Bundles related concerns.
• Advice: Defines what and when to execute (e.g., before or after a method).
• Pointcut: Specifies where to apply it.
• JoinPoint: A point during program execution, like a method execution.

23. What Are the Different Types of Advice in Spring AOP?

This is one of the commonly asked Spring interview questions.

• @Before: Runs right before the method execution.
• @After: Executes after the method finishes, regardless of outcome.
• @AfterReturning: Executes only if the method completes successfully.
• @AfterThrowing: Runs if the method execution results in an exception.
• @Around: Wraps around the method call, giving control before and after execution, with ability to stop execution or handle exceptions.

24. Explain Spring JDBC Template and Its Benefits

The JdbcTemplate simplifies database operations by hiding complex boilerplate code. It:

• Manages resources like connections and statements automatically.
• Converts SQLException into Spring’s unchecked DataAccessException, reducing clutter.
• Supports prepared statements to prevent SQL injection.
• Offers methods like query(), update(), and call() for calling stored procedures.

This makes data access easier and more secure.

25. What Is Exception Handling in Spring MVC?

Spring MVC provides flexible ways to manage exceptions:

• @ExceptionHandler: Annotate a method in a controller to handle specific exceptions locally.
• HandlerExceptionResolver: Implement this interface for global exception handling logic.
• @ControllerAdvice: Used with @ExceptionHandler to handle exceptions globally across controllers.

This lets you centralize error handling and return meaningful responses without cluttering your controllers.

26. How Is Validation Handled in Spring MVC?

Validation can be implemented in three ways:

• Annotation-based, using JSR-303 annotations like @NotNull, @Size, or @Email, combined with @Valid in the controller to trigger validation.
• Custom Validator, by implementing Spring’s Validator interface for bespoke checks.
• Manual validation, when you need custom handling or complex logic. The validation results are captured in BindingResult, letting the controller decide whether to proceed or return errors to the view.

27. How Many Modules Are There in the Spring Framework, and What Are They?

Spring is structured into several modules that can be grouped into five main categories:

• Core & Beans: The base modules, like IoC containers and bean management.
• Data Access/Integration: Includes JDBC, ORM, OXM, JMS, and Transaction modules.
• Web: Covers Web, Web-MVC, Web-Socket, and Web-Portlet modules.
• AOP & Instrumentation: For aspect-oriented programming and class instrumentation.
• Test: Supports Spring testing with JUnit and TestNG.

Pro-tip: It’s often best to test Spring websites and web applications using a Spring testing cloud like LambdaTest to ensure cross-browser compatibility across all platforms.

Plus miscellaneous modules such as Spring Expression Language (SpEL).

28. What Major Features Have Been Introduced in Recent Versions of Spring?

This is one of the most asked Spring interview questions.

• Spring 2.5 (2007): Added annotation support (@Autowired, @Component, etc.).
• Spring 3.0 (2009): Took full advantage of Java 5 features and added support for JEE 6.
• Later versions: Enhancements in Spring Boot integration, improved Auto-Configuration, Reactive programming (Spring WebFlux), WebSocket support, and native image support via GraalVM.

29. What Are Spring Boot Auto-Configuration and Starter POMs?

Auto-Configuration: Spring Boot inspects the classpath and beans, then auto-configures components based on what's available (e.g., DataSource, JPA). It reduces the need for manual XML/Java config.

Starter POMs: Convenient project dependencies like spring-boot-starter-web and spring-boot-starter-data-jpa bundle common libraries so you don’t have to manage individual dependencies manually.

30. What Is the Spring DispatcherServlet, and How Does It Work?

DispatcherServlet is the core of Spring MVC; it acts as the front controller:

• Receives all HTTP requests.
• Dispatches them to handler mappings.
• Calls the matched controller method.
• Resolves views using ViewResolver.
• Renders the response.

Essentially, it centralizes request handling in a clean pipeline.

31. Explain Spring MVC Architecture

Spring MVC follows the Model-View-Controller pattern:

• Model: Represents data and business logic.
• View: Renders the user interface (e.g., JSP or Thymeleaf).
• Controller: Handles HTTP requests and binds Model data to Views.

This architecture promotes clear separation of concerns and enhances maintainability.

32. What Is Spring Security, and Why Is It Used?

Spring Security is a powerful framework designed to secure Java applications. It supports:

• Authentication: Verifying user identities.
• Authorization: Granting access to system resources.
• Protection: Defends against CSRF, session fixation, XSS, etc.

It integrates seamlessly with Spring apps and enables a declarative approach using annotations or configs.

33. How Does Spring Handle Validation in @Controller Classes?

Spring MVC supports input validation through:

• JSR-303 annotations like @NotNull, @Size, and @Email on model fields.
• Use @Valid on controller method parameters.
• BindingResult after the model parameter to handle validation feedback.

This approach keeps validation clean and separates it from business logic.

34. What Are Spring Profiles, and Why Are They Useful?

@Profile allows conditional bean registration based on the active environment (e.g., dev, test, prod). You can use:

@Profile("dev")
@Bean
public DataSource devDataSource() { ... }

Profiles are activated with spring.profiles.active or command-line flags, helping you maintain environment-specific configurations.

35. Explain Spring’s Event Handling Mechanism

Spring uses an event-driven approach:

• Define a custom event extending ApplicationEvent.
• Create listeners with @EventListener or ApplicationListener.
• Publish events via ApplicationEventPublisher.

This lets components communicate decoupled, supporting features like async notifications or domain events.

36. Describe the Spring Environment Abstraction

The environment abstraction allows:

• Accessing properties from .properties or .yml files.
• Managing active/default profiles.
• Reading system and environment variables.

It supports property injection using @Value or programmatically via Environment#getProperty().

37. Explain Hibernate ORM and Ways to Access It in Spring

This is one of the frequently posed Spring interview questions. Hibernate ORM helps you map Java objects to relational database tables. Key components:

Key components:

• Persistence context: Manages entity objects during a session.
• Mappings: Define how Java classes relate to database tables (annotations or XML).
• SessionFactory: Creates Session objects.
• Session: Single-threaded object for performing CRUD operations.

Ways to Access Hibernate in Spring:

• Spring Data JPA: Uses JPA on top of Hibernate; define interfaces, Spring generates queries; annotations like @Entity, @Repository, @Query are used.
• HibernateTemplate: Simplifies some boilerplate code; older approach, not recommended for new projects.
• JdbcTemplate: Manual SQL queries; not Hibernate-based but useful for fine-grained control.

38. How to Create a Spring Container?

In Spring, the container manages the lifecycle and dependencies of beans. You can create it in several ways:

Using BeanFactory (Legacy):

BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

Loads beans from an XML file in the classpath.

Using ApplicationContext (Recommended):

ClassPathXmlApplicationContext:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

FileSystemXmlApplicationContext:

ApplicationContext context = new FileSystemXmlApplicationContext("C:/config/applicationContext.xml");

AnnotationConfigApplicationContext:

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

Point to note:

• Modern projects should use AnnotationConfigApplicationContext.
• Older or XML-based projects can use ClassPathXmlApplicationContext or FileSystemXmlApplicationContext.
• For web apps, WebApplicationContext integrates with the servlet container.

Spring Interview Questions for Advanced

This section covers complex Spring interview questions that test not only your technical knowledge but also your ability to architect scalable and maintainable applications using Spring.

39. Explain the Hibernate Validator Framework and the HibernateTemplate Class

This is one of the frequently posed Spring interview questions. Hibernate Validator Framework ensures data validity before it is processed or saved. Common annotations:

• @NotNull: Field must not be null.
• @Size(min=2, max=30): Ensures string or collection size within a range.
• @Email: Validates proper email format.
• HibernateTemplate: Simplifies repetitive Hibernate operations (older Spring approach).

40. What Are the Key New Features in Spring Security 6?

Spring Security 6 introduces several modern enhancements:

• Improved OAuth2 & OIDC Support: Supports dynamic client registration at runtime and enhanced token introspection for validating access tokens securely.
• AuthorizationManager API: A unified and flexible way to define authorization rules, replacing the older AccessDecisionManager. Permissions can be set directly via annotations or configuration.
• Declarative Security Enhancements: Easily define access restrictions using annotations like @PreAuthorize("hasRole('ADMIN')").
• Jakarta EE Namespace Migration: Updated to the latest Jakarta EE standards, ensuring compatibility with modern frameworks.

These updates make Spring Security more expressive, secure, and aligned with current Java ecosystems.

41. What Are Spring Boot Starters, and How Do They Simplify Development?

Spring Boot Starters are pre-defined dependency bundles that simplify project setup. Instead of manually listing dozens of libraries, you can include a starter and get everything you need.

Example: spring-boot-starter-web includes Spring MVC, embedded Tomcat, Jackson, validation API, and more.

Benefits:

• Cleaner pom.xml or build.gradle.
• Reduces guesswork on what libraries are required.
• Provides logical groupings, like starter-data-jpa, starter-security, etc.
• They speed up development and prevent version mismatch issues.

42. What Is Spring Boot Actuator, and Why Is It Useful?

Spring Boot Actuator adds production-ready endpoints to your app for monitoring and management:

• /actuator/health
• /actuator/metrics
• /actuator/env

Use cases:

• Track the app’s health and performance.
• Integrate with monitoring tools like Prometheus, Micrometer, and Grafana.
• Provides real-time insights and control in production environments.

43. How Does Spring Boot Auto-Configuration Work, and How Can You Customize It?

This is one of the frequently posed Spring interview questions. Auto-configuration in Spring Boot is powered by:

• @EnableAutoConfiguration
• Spring’s factory loading mechanism (spring.factories or AutoConfiguration.imports)
• Conditional annotations like @ConditionalOnClass, @ConditionalOnMissingBean, and @ConditionalOnProperty

Example: If DataSource is on the classpath, Spring Boot automatically configures a DataSource bean.

Customization tips:

• Use exclude = DataSourceAutoConfiguration.class in your @SpringBootApplication to disable specific auto-configurations.
• Write custom auto-configurations using conditional checks and include them via starter JARs for self-contained libraries.

This allows minimal configuration while maintaining full control when necessary.

44. How Can Advanced Profile Management Be Achieved in Spring Boot?

Spring Boot’s profile system supports multiple active profiles to combine environment and functional configurations (e.g., prod.analytics).

Steps:

• Define separate config files like application-prod.properties and application-analytics.yml.
• Activate profiles using: spring.profiles.active=prod,analytics
• Use @ConfigurationProperties or @Profile in your config classes to load only relevant beans or settings.

Benefits:

• Cleaner separation of concerns.
• Flexibility to mix and match configurations.
• Easier maintenance for complex deployments.

45. Explain the Role of DispatcherServlet and ContextLoaderListener in a Spring MVC Application

In Spring MVC, these components work together:

• DispatcherServlet: Acts as the front controller. Loads Spring beans configured for web operations (@Controller, view resolvers, handler mappings). Accepts HTTP requests, routes them to controller methods, and resolves the response view.
• ContextLoaderListener: Initializes the root application context (shared services, infrastructure beans) and ties it to the ServletContext lifecycle, making root-level beans available to all servlets, including DispatcherServlet.

46. What Are InternalResourceViewResolver and MultipartResolver in Spring?

This is one of the frequently asked Spring interview questions. These are specialized helper beans in Spring MVC:

• InternalResourceViewResolver: Translates view names (like "home") into actual JSP or HTML pages using configured prefixes and suffixes.
• MultipartResolver: Enables file upload handling. Main implementations: CommonsMultipartResolver and StandardServletMultipartResolver.

47. What Are Spring MVC Interceptors?

Interceptors let you run logic before and after a controller executes. They’re useful for:

• Logging requests and responses.
• Implementing security checks.
• Managing caching or metrics.
• Modifying the ModelAndView before rendering.

Unlike filters, interceptors operate within Spring's handler mapping context and can precisely alter execution flow.

48. How Does Spring Achieve Loose Coupling Using Dependency Injection?

Spring achieves loose coupling by allowing objects to be defined externally and injected rather than hardcoded.

Here are the methods:

Constructor Injection:

@Component
public class VehicleService {
    private final Engine engine;

    @Autowired
    public VehicleService(Engine engine) {
        this.engine = engine;
    }
}

Setter Injection:

@Component
public class VehicleService {
    private Engine engine;

    @Autowired
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
}
}

Spring’s IoC container manages bean lifecycle and configurations, injecting dependencies automatically.

Benefits:

• Improved testability (using mocks).
• Better separation of concerns.
• Easier maintenance and code reuse.

49. Differentiate Spring AOP and AspectJ AOP

This is one of the commonly posed Spring interview questions. Spring AOP handles common concerns like logging or transactions via dynamic proxies, while AspectJ provides full AOP power but is more complex.

Feature comparison:

• Weaving: Spring AOP is proxy-based at runtime; AspectJ supports compile, load-time, or runtime weaving.
• Complexity: Spring AOP handles simple use cases; AspectJ supports full aspect capabilities.
• Tooling: Spring is pure framework; AspectJ requires AspectJ compiler/tools.

50. How Does the @Transactional Annotation Work Behind the Scenes?

@Transactional uses AOP to wrap the target method inside a transaction context:

• Starts a transaction.
• Executes the method.
• Commits if successful.
• Rolls back on runtime exceptions.

Note: Only works on public methods and does not apply to self-invocation within the same class.

51. What Are BeanPostProcessor and BeanFactoryPostProcessor in Spring?

BeanPostProcessor: Custom logic before and after bean initialization. Works on bean instances.

Object postProcessBeforeInitialization(Object bean, String beanName);
Object postProcessAfterInitialization(Object bean, String beanName);

BeanFactoryPostProcessor: Modifies bean definitions (configuration metadata) before bean instances are created.

Use BeanPostProcessor to modify actual objects, BeanFactoryPostProcessor to modify configuration.

52. How Does Spring Handle Exceptions in a Layered Application Architecture?

In Spring MVC, exception handling is typically centralized:

• @ExceptionHandler: Handles exceptions within a controller.
• @ControllerAdvice: Global exception handling across controllers.
• HandlerExceptionResolver: Resolves exceptions to views or responses at a lower level.

Example:

This separates error handling from business logic and avoids cluttering the code.

Conclusion

Preparing for Spring interviews doesn’t have to feel overwhelming. Whether you're just starting out or brushing up on advanced topics, understanding core concepts like Dependency Injection, bean scopes, and Spring MVC can make a big difference.

These Spring interview questions are designed to help you think clearly and explain confidently, exactly what interviewers look for. Keep practicing, and you’ll be well on your way to cracking your next Spring-based interview.