Spring Interview Questions and Answers

CTA

Spring is the foremost framework for developing enterprise-level applications due to its highly demanded nature in Java. It can be said that with more than 9,000+ job openings in India. The average salary for a Spring developer ranges from ₹10 to ₹20 Lakhs per year. Here is a list of some of the most frequently asked questions about Spring to crack your next interview.

Table of content

• Basic Spring Interview Questions
• Intermediate Spring Interview Questions
• Advanced Spring Interview Questions

Most Frequently Asked Spring Interview Questions

Q1. What is Spring?
Q2. What are Spring beans?
Q3. Define AOP in Spring.
Q4. What is the Spring Boot Actuator?
Q5. Explain Dependency Injection (DI) in Spring.
Q6. What do you mean by Bean Wiring?
Q7. What is a Spring Java-based configuration?
Q8. Describe the Spring Framework.
Q9. What is a Spring IoC container?
Q10. What is the purpose of the @Autowired annotation?

Since the release of Spring Framework, it has bloomed in this competitive market. It is consistently bringing up new features that attract users. In recent years, it has shown an immense rise in demand among companies. With this in place, the demand for trained professionals in this domain is also high.

Basic Spring Interview Questions for Freshers

1. What is Spring?

Spring is an open-source development framework for enterprise Java. The core features of the Spring Framework can be used in developing any Java application, but there are extensions for building web applications on top of the Java EE platform. Spring Framework targets to make Java EE development easier to use and promotes good programming practices by enabling a POJO-based programming model.

2. What are Spring beans?

The objects that form the backbone of the users’ application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. These beans are created with the configuration metadata that the users supply to the container.

3. Define AOP in Spring.

AOP stands for Aspect-Oriented Programming. It is a programming technique that increases modularity by allowing the separation of cross-cutting concerns, like logging and transaction management, from the application’s business logic. With AOP, aspects are configured in separate files and can add functionality to multiple classes without changing the classes themselves.

4. What is the Spring Boot Actuator?

Spring Boot Actuator is a tool that helps monitor and manage a Spring Boot application. It provides endpoints or web URLs to get information about the app like health, metrics, info, etc. It helps debug issues and understand how the app is running.

5. Explain Dependency Injection (DI) in Spring.

Dependency Injection (DI) is a design pattern used in Spring where dependencies like services or repositories are provided to a class instead of the class creating them itself. Spring has a container that creates and wires dependencies and injects them into classes that need them. This makes it easier to manage dependencies between classes.

CTA

6. What do you mean by Bean Wiring?

Bean wiring refers to how Spring connects or wires together the application’s beans and their dependencies. It involves defining the relationships between the beans in the Spring configuration file. Spring handles the process of satisfying the dependencies of each bean by injecting other required beans into it. This wiring allows the beans to work together seamlessly.

7. What is a Spring Java-based configuration?

Java-based configuration option enables users to write most of their Spring configuration without XML but with the help of a few Java-based annotations.

Example:

Annotation @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. The @Bean annotation tells Spring that a method annotated with @Bean will return an object that should be registered as a bean in the Spring application context.

8. Describe the Spring Framework.

The Spring Framework provides a comprehensive programming and configuration model for modern Java-based enterprise applications—on any kind of deployment platform. A key element of Spring is infrastructural support at the application level: Spring focuses on the ‘plumbing’ of enterprise applications so that teams can focus on the application-level business logic, without having unnecessary ties to specific deployment environments.

9. What is a Spring IoC container?

Spring IoC creates objects, wires them together, configures them, and manages their complete life cycle from creation to destruction. The Spring container uses Dependency Injection (DI) to manage the components that make up an application.

10. What is the purpose of the @Autowired annotation?

The @Autowired annotation is used in Spring to automatically inject dependencies into a class. When Spring sees the @Autowired annotation on a field, constructor, or method, it will lookup a bean of the required type from the Spring container and inject it. This removes the need to manually lookup dependencies and wire them together.

Intermediate Spring Interview Questions

11. What are the types of dependency injections that Spring supports?

Spring supports two types of dependency injections:

Setter Injection:

Setter-based DI is realized by calling setter methods on the user’s beans after invoking a no-argument constructor or no-argument static factory method to instantiate their bean.

Constructor Injection:

Constructor-based DI is realized by invoking a constructor with several arguments, each representing a collaborator.

12. What is the difference between BeanFactory and ApplicationContext?

BeanFactory is the most basic type of Spring container. It manages the basic lifecycle of beans, like creating, configuring, and destroying them. ApplicationContext includes everything that BeanFactory can do plus some extra features like globalization support, validation, and data binding. It is also capable of application-level functions like resource and event handling.

13. What is the difference between constructor injunction and setter injection?

Constructor injection involves passing dependencies through a class’s constructor, ensuring they are set when an object is created. On the other hand, setter injection involves setting dependencies using setter methods after the object is created. Constructor injection ensures that required dependencies are available from the start, while setter injection allows for flexibility in changing dependencies later on.

14. What is the difference between Spring and Spring Boot?

Spring is a framework for building Java applications. It provides features like dependency injection. Spring Boot makes creating Spring apps easy, and it handles configuration so you don’t have to. Spring Boot also helps you get started quickly and includes useful tools like checking app health and metrics right away, so your app is ready for production use.

15. What is the difference between singleton and prototype scope in Spring?

In Spring, the singleton scope creates a single bean instance for the entire application, and the prototype scope creates a new instance every time the bean is requested. Singleton is suitable for stateless beans, while the prototype is useful when you need a fresh instance for each request.

16. Mention the modules of the Spring Framework.

The basic modules of the Spring Framework are:

• Core module
• Bean module
• Context module
• Expression Language module
• JDBC module
• ORM module
• OXM module
• Java Message Service (JMS) module
• Transaction module
• Web module
• Web-Servlet module
• Web-Struts module
• Web-Portlet module

17. What bean scopes does Spring support? Explain them.

The Spring Framework supports five scopes, three of which are available only if users use a web-aware ApplicationContext.

• Singleton: This scopes the bean definition to a single instance per Spring IoC container.
• Prototype: This scopes a single bean definition to have any number of object instances.
• Request: This scopes a bean definition to an HTTP request, only valid in the context of a web-aware Spring ApplicationContext.
• Session: This scopes a bean definition to an HTTP session, only valid in the context of a web-aware Spring ApplicationContext.
• Global-session: This scopes a bean definition to a global HTTP session, only valid in the context of a web-aware Spring ApplicationContext.

18. Explain autowiring and name the different modes of it.

Autowiring in programming automates the process of connecting components in a system. It eliminates the need to manually wire dependencies. The different modes of autowiring include “no autowiring” (default), “byType” (matching data types), “byName” (matching bean names), “constructor” (constructor-based injection), and “autodetect” (combines byType and byName based on the scenario).

19. What is the purpose of the @RequestMapping annotation?

The @RequestMapping annotation in Spring is used to map web requests to specific controller methods. It defines the URL patterns that trigger these methods, allowing developers to create clean and organized mappings between incoming requests and corresponding handler methods in their Spring MVC applications.

20. Explain the purpose of the @Value annotation in Spring.

The @Value annotation in Spring is used to inject values from properties files, environment variables, or other sources into Spring Beans. It simplifies configuration by allowing developers to externalize and customize values without modifying code, which promotes flexibility in managing application properties.

Advanced Spring Interview Questions for Experienced

21. Describe the Spring MVC architecture.

The Spring MVC architecture is a design pattern for building web applications. It consists of three main components:

• Model, which represents the data and business logic
• View, responsible for displaying information to users
• Controller, which handles user requests, processes them using the Model, and updates the View

This separation of concerns promotes modularity and makes it easier to maintain and scale web applications built with Spring MVC.

22. Explain the concept of Inversion of Control (IoC).

Inversion of Control (IoC) is a design principle where objects do not create other objects they depend on. Instead, these dependencies are provided to the objects externally by a third party, called the Inversion of Control container. This container manages the lifecycle and configuration of objects. It injects dependencies when an object is initialized.

23. How does Spring support RESTful web services?

Spring makes it very easy to create RESTful web APIs. It provides annotations to develop the controller layer that handles web requests and responses. Annotations like @RestController and @RequestMapping are used to map URLs to controller methods. @RequestBody annotation allows accessing request body parameters, and @ResponseBody returns data directly in the response body. Overall, Spring handles all the plumbing work so developers can focus on business logic rather than low-level implementation details of REST.

24. What is the role of the Hibernate framework in Spring?

Hibernate is an Object-Relational Mapping (ORM) framework that allows mapping Java objects to database tables. When used with Spring, Hibernate handles all data access operations with the database. Spring provides Hibernate integration through the Hibernate Template and SessionFactory utilities. It manages Hibernate sessions and transactions behind the scenes. This allows developers to write data access code without dealing with raw JDBC or Hibernate API calls.

25. How does Spring support internationalization (i18n)?

Spring supports internationalization (i18n) by providing a mechanism to develop applications that can be easily adapted for different languages and regions. It uses a concept called MessageSource, where you store messages in various languages. Developers can then use these messages in the code by referring to keys. This helps in building more inclusive and globally accessible software.

26. What do you understand by MultipartResolver?

In Spring, a MultipartResolver is a component that helps handle file uploads in web applications. It deals with requests that include files, like images or documents. The resolver parses the incoming request, identifies the uploaded files, and provides an easy-to-use interface for developers to work with these files in their Spring application. It simplifies the handling of multiple requests, making it convenient for developers to manage file uploads seamlessly in their web applications.

27. Is thread safety guaranteed for singleton beans?

Singleton beans in Spring are not thread-safe by default. As they will be shared across the application, concurrent access from multiple threads can cause unexpected behavior if the bean’s state is not synchronized properly. The singleton bean itself is thread-safe, but any mutable state within it may not be. It is the developer’s responsibility to ensure thread safety at the class level if the singleton bean maintains any mutable state. Making the singleton class thread-safe or avoiding mutable states are some ways to achieve thread safety for singleton beans in Spring.

28. Explain the bean life cycle in Spring Framework.

The following is the sequence of a bean life cycle in Spring:

• Instantiate: First, the Spring container finds the bean’s definition from the XML file and instantiates the bean.
• Populate Properties: Using the dependency injection, Spring populates all of the properties as specified in the bean definition.
• Set Bean Name: If the bean implements the BeanNameAware interface, then Spring passes the bean’s ID to the setBeanName() method.
• Set Bean Factory: If the bean implements the BeanFactoryAware interface, then Spring passes the bean factory to the setBeanFactory() method.
• Pre-initialization: It is also called the post-process of the bean. If there are any BeanPostProcessors associated with the bean, then Spring calls the postProcesserBeforeInitialization() method.
• Initialize Beans: If the bean implements IntializingBean, its afterPropertySet() method is called. If the bean has the init method declaration, the specified initialization method is called.
• Post Initialization: If there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.
• Ready to Use: Now, the bean is ready to be used by the application.
• Destroy: If the bean implements DisposableBean, it will call the destroy() method.

29. What are the features of Spring?

The features of Spring are mentioned below:

• Lightweight: Spring is lightweight when it comes to size and transparency. The basic version of the Spring Framework is around 1 MB. Besides, the processing overhead is also very negligible.
• Inversion of Control (IoC): Loose coupling is achieved in Spring using the technique of inversion of control. The objects give their dependencies instead of creating or looking for dependent objects.
• Aspect-Oriented Programming (AOP): Spring supports aspect-oriented programming and enables cohesive development by separating the application business logic from system services.
• Container: Spring contains and manages the life cycle and configuration of application objects.
• MVC Framework: Spring comes with an MVC web application framework built on the core Spring functionality. This framework is highly configurable via strategy interfaces and accommodates multiple view technologies such as JSP, Velocity, Tiles, iText, and POI. However, other frameworks can be easily used instead of Spring MVC Framework.
• JDBC Exception Handling: The JDBC abstraction layer of Spring offers a meaningful exception hierarchy, which simplifies the error-handling strategy.
• Integration: Spring provides the best integration services with Hibernate, JDO, and iBATIS.
• Transaction Management: Spring Framework provides a generic abstraction layer for transaction management. This allows the developer to add pluggable transaction managers and makes it easy to demarcate transactions without dealing with low-level issues. Spring’s transaction support is not tied to J2EE environments, and it can also be used in container-less environments.

30. Describe some of the standard Spring events.

Spring provides the following standard events, and they are as follows:

• ContextRefreshedEvent: This event is published when the ApplicationContext is either initialized or refreshed. This can also be raised using the refresh() method on the ConfigurableApplicationContext interface.
• ContextStartedEvent: This event is published when the ApplicationContext is started using the start() method on the ConfigurableApplicationContext interface. Users can poll their database, or they can re/start any stopped application after receiving this event.
• ContextStoppedEvent: This event is published when the ApplicationContext is stopped using the stop() method on the ConfigurableApplicationContext interface. The users can do the required housekeeping work after receiving this event.
• ContextClosedEvent: This event is published when the ApplicationContext is closed using the close() method on the ConfigurableApplicationContext interface. As the closed context reaches its end of life, it cannot be refreshed or restarted.
• RequestHandledEvent: This is a web-specific event telling all beans that an HTTP request has been serviced.