60+ Best Spring Interview Questions to Ace Your Upcoming Interview Round
Spring is one of the most popular tools for building web applications in Java EE. Dependency Injection and Aspect-Oriented Programming are at the core of the Spring framework. With good Spring Framework skills, the chances of getting selected for Java interviews are high.
So, to help your interview journey, we have compiled a list of some of the most-asked Spring Interview Questions for experienced and beginners.
Spring Interview Questions & Answers
1) What is Spring Framework?
The Spring Framework is a powerful enterprise-level, lightweight, open-source, loosely coupled application framework meant to reduce the complexity of enterprise-level development. Spring is also called "the framework of frameworks" because it offers support to various important frameworks, such as JSF, Hibernate, Structs, EJB, etc.
Around 20 modules are categorized into the following types:
- AOP (Aspect Oriented Programming)
- Web
- Instrumentation
- Core Container
- Test
- Messaging
- Data Access/Integration
For beginners, the best Spring tutorials are the most reliable way to understand the Spring framework in detail.
2) What are the key features of the Spring Framework?
- Layered architecture for selecting required components.
- Aspect-Oriented Programming (AOP) for modular business logic.
- Spring MVC framework for flexible web applications.
- IoC (Inversion of Control) for dependency injection.
- Lightweight and loosely coupled structure.
- Transaction management abstraction for database integration.
3) What are the advantages of using Spring Framework?
- Reduces boilerplate code (object initialization, resource management).
- Simplifies unit testing with dependency injection.
- Supports modularization with separate modules.
- Integrates with other Java EE technologies.
- Lightweight and scalable, suitable for microservices.
4) What is a Spring Configuration File?
A Spring Configuration File is an XML file that defines class properties and relationships between beans.
5) What is the IoC (Inversion of Control) Container in Spring?
The Spring IoC Container is responsible for managing object dependencies and lifecycles using Dependency Injection (DI). It can be configured using:
- XML configuration
- Java annotations
- Java code-based configuration
6) What is the difference between Constructor Injection and Setter Injection?
- Constructor Injection: Dependencies are injected via a constructor.
- Setter Injection: Dependencies are set through setter methods.
- Partial injection is allowed in setter injection but not in constructor injection.
- Constructor injection is preferred when many dependencies exist, while setter injection is better for optional dependencies.
7) What are Spring Beans?
Spring Beans are objects managed by the IoC container. These beans are defined in Spring configuration (XML or annotations). The container instantiates, configures, and manages them throughout their lifecycle.
8) How is Configuration Metadata provided to the Spring Container?
Configuration can be provided via:
- XML-Based Configuration:
<bean id="myBean" class="com.example.MyClass"> <property name="property1" value="value1" /></bean>
- Annotation-Based Configuration (@Component, @Service, @Repository, @Autowired)
- Java-Based Configuration (@Bean, @Configuration)
9) What are the different bean scopes in Spring?
- Singleton: One instance per Spring container.
- Prototype: New instance per request.
- Request: Scoped to an HTTP request.
- Session: Scoped to an HTTP session.
- Global-session: Scoped to a global HTTP session (only for web-aware applications).
10) What is Autowiring, and what are its different modes?
Autowiring enables automatic dependency injection. Modes:
- no: Default, manual bean wiring.
- byName: Matches property name with a bean.
- byType: Matches bean type.
- constructor: Uses constructor parameters for dependency injection.
- autodetect: Tries constructor first, then byType.
11) What is a Controller in Spring MVC?
A Controller handles HTTP requests and processes them to generate appropriate responses. It is defined using the @Controller annotation and mapped with @RequestMapping.
12) What is Weaving in Spring?
Weaving is the process of linking aspects (cross-cutting concerns) with the application code. It can occur at:
- Compile-time
- Load-time (LTW)
- Runtime (Spring AOP uses runtime weaving)
13) Different Types of Advice in Spring AOP
In Spring AOP, advice represents the action taken by an aspect at a particular join point. There are five types of advice:
- Before Advice: Executes before the target method.
- After Returning Advice: Executes after the target method completed.
- After Throwing Advice: Executes if the target method throws an exception.
- After (Finally) Advice: Executes after the target method finishes, regardless of its outcome (success or exception).
- Around Advice: Surrounds the target method, allowing you to control the execution before and after the method, and even modify its outcome.
14) What are the limitations of Autowiring?
- Cannot autowire primitive data types or Strings.
- Overriding is possible, leading to confusion.
15) Explain the Bean life cycle in Spring Bean Factory Container.
Following is the life cycle of a bean:
An IoC container instantiates the bean according to its definition in an XML file.
After that, Spring populates all the properties based on the dependency injection specified in the bean definition.
Bean factory containers call setBeanName(), which takes the bean ID, and the corresponding bean must implement the BeanNameAware interface.
After that, the factory calls setBeanFactory() by passing an instance of itself (if the BeanFactoryAware interface is implemented in the bean).
The preProcessBeforeInitialization() methods are invoked if BeanPostProcessors are associated with the bean.
If an init-method is specified, then it will be called.
Lastly, postProcessAfterInitialization() methods will be called if there are BeanPostProcessors associated with the bean that needs to be run after creation.
16) What do you understand by the term 'Spring Boot'?
Spring Boot is an open-source, java-based framework that provides support for Rapid Application Development and gives a platform for developing stand-alone and production-ready spring applications with the need for very few configurations.
17) What are the features of Spring Boot?
Spring Boot CLI – You can use Groovy or Maven for writing Spring Boot applications and avoid boilerplate code.
Starter Dependency – Through this feature, Spring Boot aggregates common dependencies together and eventually improves productivity and reduces workload.
Spring Initializer – This is a web application that helps a developer in creating an internal project structure. This feature allows developers to use the feature without manually setting up the project structure.
Auto-Configuration – This feature allows you to load the default configuration according to the project you are working on. By doing so, unnecessary WAR files can be avoided.
Spring Actuator – Spring Boot is accompanied by an actuator that provides "Management EndPoints" which helps the developer to view the internals and metrics of the application.
Logging and Security – It ensures that all applications built with Spring Boot are correctly secured without hassles.
18) Differentiate between Spring and Spring Boot.
While the Spring Framework provides several useful features such as dependency injection, data binding, aspect-oriented programming (AOP), data access, and more, Spring Boot simplifies the use of the Spring Framework by simplifying or managing various loosely coupled blocks of Spring that are tedious and at times can cause chaos.
Spring boot simplifies commonly used spring dependencies and allows you to run applications straight from the command line. Furthermore, it doesn't require an application container, and it helps to monitor several components and configure them externally.
19) Explain the advantages of using Spring Boot for application development.
Following are the advantages of using Spring Boot for application development:
By using Spring Boot, standalone applications can be created that can be started using java.jar (No need to configure WAR files).
Furthermore, Spring Boot offers 'started' POMs for Maven configuration.
Undertow, Tomcat, Jetty or other web servers can be embedded directly.
Auto-Configuration: Automatically configures an application based on the classpath's dependencies.
Spring Boot was developed to reduce the lines of code.
Applications developed using spring boot have an easier time launching and offer production-ready support.
20) What is Spring WebFlux?
Spring 5 introduced a new module, Spring WebFlux. Spring WebFlux is the alternative to the Spring MVC module. It is used to create a fully asynchronous and non-blocking application based on the event-loop execution model.
21) What are the benefits of using Spring Tool Suite?
In Eclipse, we can install plugins to access all of Spring Tool Suite's features. While STS is available with Eclipse, it includes other important things such as Maven support, templates for creating Spring projects, and a TC server to enhance the performance of Spring applications.
22) What do you understand by Dependency Injection?
To eliminate the hard-coded dependencies from our applications and make them extensible, maintainable, as well as extendable, we can easily use the Dependency Injection design patterns. We can make use of the dependency injection pattern to shift the dependency resolution from compile-time to run-time.
A couple of benefits of Dependency Injection are Separation of Concerns, Boilerplate Code Reduction, Configurable Components, as well as Easy Unit Testing.
23) How do we implement DI in Spring Framework?
DI (Dependency Injection) in spring applications can be implemented using Spring XML-based and Annotation-based configuration.
24. What do You Understand by @Qualifier Annotation?
It is applied in Spring to resolve ambiguity where there are beans of the same type in the Spring container. It is integrated with the @Autowired annotation to select specifically which of the beans should be injected if more than one candidate is available.
25. What Do You Understand by @Autowired Annotation?
@Autowired is used in Spring for automatic dependency injection. It tells Spring to automatically resolve and inject the appropriate bean into the field, setter method, or constructor where the annotation is placed. By default, Spring resolves dependencies by type.
26. What do You Understand by @Required Annotation?
@Required annotation ensures that a particular bean property must be set. If the required property is not set during bean configuration, Spring throws a BeanInitializationException. It is typically applied to setter methods.
27) Name some of the important Spring Modules?
The following are some of the most important Spring Framework modules:
- Spring Web Module – for creating web applications.
- Spring Context – for dependency injection.
- Spring DAO – for database operations using DAO pattern.
- Spring MVC – Model-View-Controller implementation for creating web applications, web services, etc.
- Spring ORM – for ORM tools support such as Hibernate.
- Spring AOP – for aspect-oriented programming.
- Spring JDBC – for JDBC and DataSource support.
28) What do you understand by Aspect-Oriented Programming?
There are a few crosscutting concerns shared by enterprise applications that apply to different types of Objects and application modules, such as logging, transaction management, data validation, and authentication. Object-oriented programming achieves modularity by using classes. The modularity of AOP is achieved by using Aspects, which are configured to cut across different class methods.
Using AOP, you eliminate cross-cutting tasks from classes, which would otherwise be impossible under a conventional object-oriented approach. For instance, we can have a separate class for logging but the other classes will have to call these methods. In AOP, however, aspects are configured and methods are executed automatically.
29) What are the important features of Spring 5?
Spring 5 takes a big step forward from Spring 4. The following are some of the key features:
- Support for Kotlin, Lombok, Reactor 3.1 Flux, and Mono as well as RxJava.
- Support for Java 8 and higher versions, so we can use lambda expressions.
- Spring WebFlux that brings reactive programming to Spring.
- Support for Java EE7 and Servlet 4.0 specs.
- Support for JUnit 5
- Implemented spring-JCL to streamline logging, which earlier was a mess due to the lack of a single point of logging.
- Support for providing spring components information via index file “META-INF/spring.components” instead of classpath scanning.
- File operations are now performed via NIO 2 streams, which is a huge improvement if your app handles a lot of files.
30) What is Aspect, Advice, Pointcut, JointPoint, and Advice Arguments in AOP?
Aspect: A class that implements cross-cutting concerns, such as transaction management. Aspects can be configured as normal classes and then configured in the Spring Bean configuration file or we can use AspectJ support to declare a class as an Aspect using the @ Aspect annotation.
Advice: Advice is the action taken at a certain join point. These methods are executed by the application when a specific pointcut with a matching join point is reached. It can be thought of as an interceptor for Spring or a servlet filter.
Pointcut: Pointcuts are regular expressions that are matched against join points to determine whether advice should be executed or not. There are different types of expressions that Pointcut uses to match the join points. For determining the join points where advice methods will be applied, the Spring framework uses the AspectJ pointcut expression language.
JoinPoint: A join point is a specific point in the application like method execution, exception handling, changing object variable values, etc. A join point in Spring AOP is always the execution of a method.
Advice Arguments: In the advice methods, we can pass arguments. The args() expression in the pointcut can be applied to any method matching the argument pattern. Using this method, we need to use the same name in the advice method, which determines the argument type.
31) What is the importance of the Spring bean configuration file?
To define all the beans that will be initialized by Spring Context, we use the Spring Bean configuration file. When we create a Spring ApplicationContext instance, it reads the spring bean XML file and initializes all of them. When the context is initialized, we can use it to get different bean instances.
Along with Spring Beans, this file contains Spring MVC interceptors, view resolvers, and other annotation-based configuration elements.
32) What is the difference between Spring AOP and AspectJ AOP?
Object-Oriented Programming is implemented by AspectJ, whereas Spring implements AOP for some cases. These are the main differences between Spring AOP and AspectJ:
- Spring AOP is easier to use than AspectJ since we don't need to worry about weaving.
- AspectJ annotations are supported by Spring AOP, so you can work with Spring AOP if you are familiar with AspectJ.
- Since Spring AOP only supports proxy-based AOP, it can be applied only to method execution join points. AspectJ supports all types of pointcuts.
- Spring AOP has the limitation that it can be applied only to beans created through Spring Context.
33) What is Bean wiring and @ Autowired annotation?
Spring Bean Wiring is the process of injecting spring bean dependencies during initialization. Generally, it's best practice to wire up all beans explicitly, but the spring framework also supports autowiring.
The @ Autowired annotation can be used with fields or methods for autowiring byType. For this annotation to work, we also have to enable annotation-based configuration in the spring bean configuration file. This can be done by context:annotation-config element.
34) Does Spring Bean provide thread-safety?
By default, the scope of Spring beans is singleton, so there will be only one instance per context. Thus, having a class-level variable that any thread can update will result in inconsistent data. Therefore, spring beans are not thread-safe in default mode.
You can, however, change the scope for spring beans to request, prototype, or session to achieve thread safety at the expense of performance. It is a design decision based on the project requirements.
35) What is a Controller in Spring MVC?
As with the MVC design pattern, the Controller class handles all client requests and sends them to the configured resources. DispatcherServlet is the Spring MVC front controller that initializes the context based on the bean configurations.
A Controller class is responsible for handling different types of client requests based on the request mappings. Using the @ Controller annotation, we can create a controller class. Typically, it is used with the @ RequestMapping annotation to define handler methods for specific URI mapping.
36) What is DispatcherServlet and ContextLoaderListener?
DispatcherServlet is the Spring MVC front controller that initializes the context based on the bean configurations. Furthermore, it will scan the packages and configure any bean that contains annotations such as @ Component, @ Controller, @ Repository, or @ Service.
ContextLoaderListener starts and shuts down Spring's root WebApplicationContext. Among its most important functions are tying the lifecycle of ApplicationContext with the lifecycle of ServletContext and automating the creation of ApplicationContext. It can be used to define shared beans that can be used in various spring contexts.
37. What Do You Mean by Annotation-based Container Configuration?
Annotation-based container configuration refers to using annotations to define and manage beans and dependencies, as opposed to using XML-based configuration. Annotations like @Component, @Service, @Controller, @Autowired, @Configuration, etc., allow Spring to manage the application context by scanning and processing these annotations.
38. Explain Inner Beans in Spring
Inner beans refer to beans that are declared within the scope of another bean's configuration. These beans are used only within the enclosing bean and are not available for dependency injection elsewhere in the container. Inner beans are useful when the bean is tightly coupled with another bean and doesn’t need to be shared.
39) What is ViewResolver in Spring?
Using ViewResolver implementations, view pages are resolved by name. It is configured in the spring bean configuration file. For example:
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
40) How to handle exceptions in Spring MVC Framework?
To achieve robust exception handling, Spring MVC Framework provides the following methods.
Controller-Based – In controller-based systems, we can specify exception handling methods in the controller classes. These methods only need to be annotated with @ ExceptionHandler.
Global Exception Handler – Handling exceptions is a cross-cutting concern, and Spring provides @ ControllerAdvice annotation that we can use with any class to implement our global exception handling.
HandlerExceptionResolver implementation – For generic exceptions, it serves static pages most of the time. HandlerExceptionResolver is an interface in Spring Framework that we can implement to create a global exception handler. As another way to define the global exception handler, the Spring framework provides default implementation classes that we can define in our spring bean configuration file to benefit from the spring framework exception handling.
41) What are the minimum configurations needed to create a Spring MVC application?
Following are the steps necessary for creating a simple Spring MVC application.
- Add spring-context and spring-webmvc dependencies to the project.
- Set up DispatcherServlet in the web.xml file to handle requests through the spring container.
- A spring bean configuration file is required to define the beans and if annotations are being used, then it must be configured here. We also need to configure the view resolver for view pages.
- Client requests are handled by request mappings defined in a controller class.
Using these steps, you should be able to create an easy Spring MVC Hello World application.
42) What is a View Resolver pattern and explain its significance in Spring MVC?
View Resolver pattern is a J2EE pattern that allows the applications to dynamically choose technology for rendering the data on the browser (View). HTML, JSP, XSLT, JSF, or any other such technology can be used as a View.
View Resolver contains information about different views. The controller returns the name of the View, which is passed to the View Resolver by the DispatcherServlet for selection of the appropriate View technology, and then the data is displayed. Spring MVC's default ViewResolver is InternalResourceViewResolver.
43) Can you create a controller without using @ Controller or @ RestController annotations?
Definitely! It is possible to create a controller without using the @ Controller or @ RestController annotations by annotating the Spring MVC Controller classes with the @ Component annotation. With this example, the @ RequestMapping annotation does the actual mapping of the request to the handler method.
44) Can we send an Object as the response of the Controller handler method?
We can do so by using the @ ResponseBody annotation. We use this method for sending JSON or XML-based responses in restful web services.
45) How to validate form data in Spring Web MVC Framework?
Spring supports JSR-303 annotation-based validation and provides us with a Validator interface through which we can create our validators. We need to annotate bean variables with the required validations to use JSR-303 based validation.
46) How to upload files in the Spring MVC Application?
The MultipartResolver interface implementation in Spring provides support for uploading files. It is very easy to use and requires only configuration changes to work. To handle the incoming file and process it, we would need to write a controller method.
47) What is Spring MVC Interceptor and how to use it?
Spring MVC Interceptors are like Servlet Filters and allow us to intercept and process client requests. Client requests can be intercepted in three places - preHandle, postHandle, and afterCompletion.
Spring interceptors can be created by implementing the HandlerInterceptor interface or by extending the abstract class HandlerInterceptorAdapter.
In the spring bean configuration file, interceptors must be configured. In addition, we can configure an interceptor for specific URI mappings as well or intercept all client requests.
48) What is Spring Security?
The Spring security framework provides both authentication and authorization in Java applications. Furthermore, it takes care of many common security vulnerabilities, such as CSRF attacks.
By using annotations such as @ EnableWebSecurity, it is easy and beneficial to use Spring security in web applications.
49) What is the Spring JdbcTemplate class and how to use it?
The Spring JdbcTemplate provides an easy way to connect to a database and run SQL queries. Even though it uses JDBC api internally, it eliminates a lot of issues with JDBC API. We can use the Jdbc template utility class to avoid boiler-plate code from our database operations logic such as Opening/Closing Connection, ResultSet, PreparedStatement, etc.
50) How to use Tomcat JNDI DataSource in Spring Web Application?
To use the servlet container configured JNDI DataSource, it must be configured in the spring bean configuration file and then injected into spring beans as dependencies. After that, we can use JdbcTemplate to perform database operations.
<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
</beans:bean>
51) What is Hibernate ORM Framework?
Mapping application domain model objects to relational database tables is known as object-relational mapping (ORM). Hibernate is the most popular Java-based ORM framework.
52) What is Hibernate Validator Framework?
The Hibernate Validator Framework allows you to express and validate application constraints. By default, metadata are annotations, with the ability to override and extend through XML. It is not dependent on a specific application tier or programming model and is available for both server-side and client-side applications.
53) What are some of the classes for Spring JDBC API?
Here are some of the classes for Spring JDBC API:
NamedParameterJdbcTemplate
SimpleJdbcCall
SimpleJdbcInsert
JdbcTemplate
SimpleJdbcTemplate
54. What Do You Understand by MultipartResolver?
MultipartResolver is an interface in Spring used for handling file uploads in web applications. It abstracts the handling of multi-part HTTP requests, enabling file uploads. There are two commonly used implementations:
- CommonsMultipartResolver (Apache Commons FileUpload).
- StandardServletMultipartResolver (Servlet 3.0 API).
The MultipartResolver is configured to handle file upload requests automatically.
55. Differentiate Between BeanFactory and ApplicationContext
BeanFactory and ApplicationContext are both interfaces used in Spring for managing beans, but they differ in several ways:
- BeanFactory: It is the basic container, providing simple dependency injection. It instantiates beans lazily, i.e., a bean is created only when requested.
- ApplicationContext: It is a more advanced container, built on top of BeanFactory. It provides additional features like event propagation, declarative mechanisms to create a bean, AOP integration, internationalization, and eager instantiation of singleton beans at startup.
Key Differences:
56) What is Spring AOP Proxy pattern?
The proxy pattern is a well-used design pattern in which a proxy is an object that looks like another object, but has special functionality behind the scenes. With Spring AOP, proxies are used to implement aspect contracts in runtime using the AOP framework.
The standard JDK dynamic proxies are default AOP proxies that enable any interface(s) to be proxied. The Spring AOP package can also use CGLIB proxies rather than interfaces for proxying classes. If a business object does not implement an interface, then CGLIB proxies are used by default.
57) What is Spring DAO?
The Spring DAO (Data Access Object) is an object which provides an abstract interface for JDBC implementation frameworks. With the help of a series of Support classes, Spring DAO can access JDBC, Hibernate, MyBatis, JPA, and JDO. Moreover, it supports a generalized exception hierarchy by defining a @ Repository annotation.
Using this annotation we define a Spring container that will translate SQLException into Spring's data access strategy-independent DataAccessException hierarchy.
58) What are the AOP terminology?
The following are AOP terminologies or concepts:
- Weaving
- Target Object
- JoinPoint
- Pointcut
- Advice
- Interceptor
- AOP Proxy
- Introduction
- Aspect
59) How can you fetch records by spring JdbcTemplate?
By using the query method of JdbcTemplate, you can retrieve records from the database. There are two ways to do this:
- ResultSetExtractor
- RowMapper
60) What are the types of IOC containers in spring?
In the spring framework, there are two types of IOC containers.
- BeanFactory
- ApplicationContext
Preparation Tips for Spring Interview
- Understand Core Concepts: Know the essential topics such as dependency injection, inversion of control, and Spring AOP (aspect-oriented programming).
- Focus on Annotations: Be aware of the commonly used annotations, like @Autowired, @Qualifier, @Controller, @Service, @Component.
- Know Spring Boot: Since it is highly trending these days, knowing its feature, such as auto-configuration, embedded servers, and Spring Boot starters, will give you that edge.
- Practice Real-World Scenarios: In real-world projects or mini-applications, practice using Spring MVC, Spring Data, and Spring Security.
- Know transactions and AOP: What does Spring do in terms of transaction management, and under what hood does AOP go? Explore the lifecycle of different kinds of advice.
- Familiarize with the Spring Ecosystem: Get an idea of the overall broader Spring ecosystem, like Spring Data (JPA), Spring Security, Spring Batch, etc.
- Look Out for New Spring Features: Given experience, you are expected to keep pace with the latest versions of Spring and Spring Boot. Hence, expecting a question or two from the interviewer is very likely.
People are also reading: