Spring Interview Questions

Spring Interview Questions

Read other articles of this series :


This post is the part of our Interview Questions series and in this post, we will discuss some of the commonly asked Spring Interview Questions during a job interview.


1. Spring Beans And Dependency Injection

Spring Beans are the core of Spring Framework. Some questions related to Spring Beans are:


Q1. What is the Spring Framework?

Spring is known as one of the most popular frameworks for Java Enterprise applications. Spring framework Dependency injection feature can be used on any Java based application (web or non-web).

The core of the Spring framework based on the dependency injection design pattern which allows us to easily build decoupled systems.


Q2. What are the benefits of Spring?

Spring Framework makes it easier to build enterprise Java applications, below are some of the advantages of using it

  • IoC Container: Spring manage the life-cycle of the Spring Beans and configurations using it’s Ioc container, this makes project management and maintenance easier.
  • Versatile: Spring provides flexibility to integrate it with any Java based technologies.
  • Inversion of Control: Spring will take care of injecting the required dependencies for our application, we are no longer required to manually search and inject the required dependencies for our application.
  • Lightweight: Spring is divided into different modules with a minimal dependency on each other which make it really lightweight and have the flexibility to only use required modules for your application.
  • End to End Development: Spring Framework provides modules for all aspects of application development ranging from Dependency Injection, Persistence, Caching, Business, Web, REST, it’s an ecosystem for developing all type of Java based Enterprise applications.
  • Non-invasive: Spring does not force us to use any Spring based interface or to extend any Spring based class to use its features which give our code flexibility to be used in any other technology. e.g. We can inject dependency using @Inject annotation which is not Spring based annotation, there will be no change if we want to use Guice as our dependency injection API.
  • Exception Handling: Spring Framework provides multiple options to handle exceptions in a better and more flexible way.


Q3. What is Dependency Injection?

Dependency Injection is a technique with which we can make our program loosely coupled and inject required dependencies by defining them as Beans using several annotations like @Service, @Component, @Repository, @Controller or a @Bean annotation.


Q4. What are types of Dependency Injection techniques supported in Spring?

Spring supports three types of Dependency Injection

  • Setter-based Dependency Injection.
  • Constructor based Dependency Injection.
  • Field Injection


Q5. What does bean scopes Spring supports?

Spring support below 7 scopes. We can also define a custom scope if required.

  1. singleton
  2. prototype
  3. request
  4. session
  5. application
  6. websocket
  7. globalSession

For more details, read our article Spring Bean Scopes


Q6. Explain bean scopes in Spring?

Bean scopes define the lifecycle of a Bean.

  1. singleton(default*)
    Scopes a single bean definition for a single object instance per Spring IoC container.
  2. prototype
    Scopes a single bean definition for any number of object instances.
  3. request
    Scopes a single bean definition to the lifecycle of a single HTTP request; that is each and every HTTP request will have its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
  4. session
    Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
  5. global session
    Scopes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a portlet context. Only valid in the context of a web-aware Spring ApplicationContext.

For more information read Spring Bean Scopes


Q7. How to create custom scope in Spring?

As of Spring 2.0, the bean scoping mechanism in Spring is extensible. This means that you are not limited to just the bean scopes that Spring provides out of the box; you can define your own scopes. Read Custom Scope in Spring to learn how to create and use a custom scope in your application.


Q8. What is the recommended way to inject beans in Spring?

The recommended way to inject dependencies into Spring components is by using constructor injection. This should be followed by any compulsory dependencies needed. For optional dependencies, setter injection should be used.


Q9. What are the different modules/subprojects of the Spring?

  1. Spring Core.
  2. Spring JDBC
  3. ORM Module
  4. Spring AOP
  5. Spring MVC


Q10. What Design patterns are used in Spring framework?

  1. Singleton pattern in Singleton scoped beans
  2. Model View Controller in Spring MVC
  3. Data Access Object in Spring DAO support
  4. Front Controller in Spring Dispatcher Servlet
  5. Template Method Pattern in Spring JDBC support
  6. Adapter Pattern in Spring MVC and Spring Web
  7. Proxy Pattern in Spring AOP support
  8. Factory Pattern in Bean Factory classes


Q11. What are Spring profiles?

Spring profiles allow us to configure Spring Beans based on the profile of dev, QA, staging, production etc. The use of profiles is that we can make same Spring app which points to different databases or message broker instances with a difference of just a flag. Please read our article on Spring Profiles for more detail.


Q12. What does @Required annotation do?

@Required annotation marks a bean as a required bean which means it needs to be configured at configuration time. Otherwise, the Spring container will throw a BeanInitializationException exception.


Q13. What does @Autowired annotation do?

The @Autowired annotation is used with fields or methods for injecting a bean by type. This annotation allows Spring to resolve and inject collaborating beans into the required bean.


Q14. In how many ways we can handle Exceptions in a Spring project?

  1. By using @ExceptionHandler annotation at the Controller level. This helps in managing an exception in a particular controller without affecting complete app flow.
  2. Using HandlerExceptionResolver, we can handle exceptions at the complete application level.
  3. By using @ControllerAdvice annotation, we can configure Exception handlers for application-level control and still keep the code very clean and modular.


Q15. What is the difference between annotations like @Component, @Controller, @Service, and @Repository?

Out of all, @Component annotation is a generic annotation. So anything which is a Controller, Service or a Repository, it’s a Component as well. For specifics, let’s look at each of one of these:

  • @Controller: This annotation enables the detection of @RequestMapping annotation in the class. It also indicates that this class is a Controller.
  • @Service: It indicates that this class handles the business logic of the application and ought to call the @Repository classes for DB interaction.
  • @Repository: This indicates that the class defines a DB interface. It makes sure that the platform-specific exceptions caught again and thrown again as Spring specific unchecked exceptions.


Q16. What is the difference between the Singleton Design Pattern and Spring Singleton scope?

There is a minimal similarity between Singleton Design Pattern and Spring Singleton Scope. Singleton Design Pattern as defined in the Gang of Four(GoF) books refer to the scope of the object of only one instance per ClassLoader. The scope of Spring Singleton bean referred to as “a single instance per bean and per container”. To understand it more clearly, let’s take a look at the below example

<!-- Singlton is the default scope, you can skip scope attribute in below declaration--!>
<bean id="bean1" class="com.javadevjournal.SingletonBean" scope="singleton"/>
<bean id="bean2" class="com.javadevjournal.SingletonBean" scope="singleton"/>

In the above example, Spring Container will create 2 instances of our SingletonBean class, to put it, in other words, Spring container will create 2 instances of our class and bind them with the “id” and store them in singleton cache. Any call for the system with id=”bean1″ will return bean instance from singleton cache bind with Id “bean1” and call for id=”bean2″ will return instance bind with id “bean2”.

Read Spring Singleton vs Singleton Pattern for more detail.


Q17. What is a Spring Bean?

The objects that form the backbone of your application and that managed by the Spring IoC container is known as beans. The Spring Beans are Java Objects that are initialized by the Spring IoC container. Any normal Java POJO class can be a Spring Bean if it’s configured to be initialized via container by providing configuration metadata information.


Q18. What is the difference between BeanFactory and ApplicationContext?

Both BeanFactory and ApplicationContext are IOC container provided by Spring.BeanFacotory is also known as basic IOC while ApplicationContext is known as advance IOC.ApplicationContext includes all functionality of the BeanFactory and provided extra features. Below are few differences between BeanFactory and ApplicationContext.

Bean instantiation/wiringYesYes
Automatic BeanPostProcessor registrationYesNo
Automatic BeanFactoryPostProcessor registrationYesNo
Convenient MessageSource access (for i18n)YesNo
ApplicationEvent publicationYesNo

BeanFactory uses lazy initialization approach while ApplicationContext is based on eager initialization.

Because the ApplicationContext includes all functionality of the BeanFactory, it is generally recommended over the BeanFactory.


Q19. Explain the Spring bean lifecycle?

Spring bean managed by Spring IOC based on the XML or Java configuration. The Spring beans creation, management, and disposal handled by the Spring IoC. At a high-level Spring Bean pass through a different life cycle.

  • Required to perform some initialization to get it into a usable state.
  • Populate properties: Spring IoC container injects the bean’s properties.
  • Post Initialize : Spring container calls their postProcessAfterinitalization() method.
  • If a bean is no longer required, it will be removed from the IoC container.

Here is a complete lifecycle of Spring Bean (Source: dineshonjava)



Q20. Can we use multiple Spring configuration files in one project?

Yes, there are a number of different ways to achieve this. We can load multiple beans configurations while creating the application context

ApplicationContext context = 
    	new ClassPathXmlApplicationContext(new String[] {"file1.xml",

Above approach is not flexible and error-prone. The recommended way is to create use <import> tag to combine multiple files into the single XML file.

<beans xmlns="http://www.springframework.org/schema/beans"

   <!-- Load additional configuration -->
   <import resource="spring-filter-config.xml"/>
   <import resource="spring-security-config.xml"/>
   <import resource="spring-mvc-config.xml"/>

We can also use Java-based configurations for multiple files.

public class ApplicationConfig { ....}


Q21. Does Spring Bean provide thread safety?

The short answer is “No. Spring works with different bean scopes but they work and define bean lifecycle when the bean is created. Spring bean scope should not be seen with thread safety as they have very little relation to thread safety. Thread safety of the Spring bean is based on the design of the application and how a given bean is used. Spring introduced a new SimpleThreadScope which is a thread-based Scope.

We can make a careful choice while using Spring scoped bean in a multi-thread environment. For example in the HTTP request, we can use the “request” scope to make sure a new bean is created for each HTTP request. (remember even this approach is not thread safe).


Q21. What are the limitations of autowiring?

Spring autowiring is a powerful technique with a number of advantages, however, this technique carries certain limitations

  • Dependencies specified using constructor and property based setting will always override autowiring. We can’t autowire simple properties such as primitives, Strings, and Classes.
  • This can be confusing if we have a number of dependencies defined in our program.
  • Autowiring is less exact than explicit wiring since Spring container use certain assumption while trying to match the bean during autowiring.


Q22. What is the Spring Java-Based Configuration?

There are multiple ways to configure Spring based application. Spring Java-based configuration provides a type-safe configuration, also known as an alternative to traditional XML based configuration.

Please read for Spring WebApplicationInitializer more detail.


Q23. What are Spring events? describe some of the standard Spring events?

Spring Events are part of the Spring Framework. Events are useful to communicate application status change among different systems. There are numbers of events available with Spring Framework.

  • ContextRefreshedEvent – This event published when the ApplicationContext is either initialized or refreshed. This is also available when on using refresh() method on the ConfigurableApplicationContext interface.
  • ContextStartedEvent – Event published when the ApplicationContext started using the start() method.
  • ContextStoppedEvent – Event published when the ApplicationContext stopped using the stop() method on the ConfigurableApplicationContext interface.
  • ContextClosedEvent –  Event raised when an ApplicationContext gets closed.


Q24. What is Spring Security?

Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based applications. Spring Security is a framework that focuses on providing both authentication and authorization to Java applications. Here is the list of some of the most common features of Spring security.

  • Support for Authentication and Authorization.
  • Out of the box support for CSRF, session fixation etc.
  • OOTB integration with Spring MVC.
  • Support to integrate external authentication systems.


Spring MVC

In this section of Spring Interview Questions, we are compiling some of the most commonly asked questions during Spring MVC interview.

Q25. What is the @Autowired annotation?

The @Autowired annotation used to inject Spring dependencies. Spring Framework provided the following type of bean autowiring.

  • Setter-based autowiring.
  • Constructor based bean wiring.
  • Field or property based autowiring.

For more detail, read Spring Bean @Autowired


Q26. What is a Controller in Spring MVC?

Controllers are responsible for controlling the flow of the application execution. In Spring MVC architecture the DispatcherServlet works as Front Controller.DispatcherServlet process the request and pass request to the controller class annotated with @Controller.Each controller class is responsible to handle one or more requests of a certain type.

For more detail, read Introduction to Spring Controllers



In this article, we discussed some of the commonly asked Spring Interview Questions during a job interview. We will be covering Interview questions of the other modules of the Spring framework in a different post.

Leave a Reply

1 Comment threads
1 Thread replies
Most reacted comment
Hottest comment thread
2 Comment authors
Umesh AwasthiRobert Recent comment authors

This site uses Akismet to reduce spam. Learn how your comment data is processed.

newest oldest most voted
Notify of

Thanks for compiling these questions, really helpful

Umesh Awasthi
Umesh Awasthi

Thanks, Robert !!