Commonly questions and answers for a spring interview.

This post aims to assist you in navigating Spring interview Questions by providing comprehensive explanations of the core concepts.

The Spring Framework is highly favored among developers for creating web applications using Java EE. At the core of the Spring framework lies Dependency Injection and Aspect-Oriented Programming. If you possess strong skills in the Spring Framework, your chances of excelling in Java interviews significantly increase.

If you are getting ready for interviews, it’s important to study Core Java Interview Questions and Java Interview Questions articles as Core Java serves as the foundation for any Java-based framework.

Commonly asked questions and corresponding answers during spring interviews.

I have compiled nearly 50 interview questions about spring along with their answers. This list is up to date with Spring 5 and includes the newest functionalities like Spring WebFlux for reactive programming.

Can you provide a description of the Spring Framework?

Spring framework is highly popular within the Java EE community and is renowned for its core principles of “Dependency Injection” and “Aspect-Oriented Programming“.

The Spring framework is applicable in regular Java applications as well, enabling the attainment of loose coupling between various components through the implementation of dependency injection. Through Spring’s aspect-oriented programming support, we can also carry out cross-cutting operations like logging and authentication.

I enjoy spring for its vast range of functionalities and distinct modules designed for specific tasks like Spring MVC and Spring JDBC. Being an open-source framework supported by a thriving community and abundant online resources, collaborating with the Spring framework is both enjoyable and effortless.

Suggested reading: Spring Framework

What are some crucial characteristics of the Spring Framework?

The Spring Framework is founded on two fundamental design principles, namely Dependency Injection and Aspect-Oriented Programming.

Spring framework has several characteristics such as:

  • Lightweight and very little overhead of using a framework for our development.
  • Dependency Injection or Inversion of Control to write components that are independent of each other, spring container takes care of wiring them together to achieve our work.
  • Spring IoC container manages Spring Bean life cycle and project-specific configurations such as JNDI lookup.
  • Spring MVC framework can be used to create web applications as well as restful web services capable of returning XML as well as JSON response.
  • Support for transaction management, JDBC operations, File uploading, Exception Handling, etc with very few configurations, either by using annotations or by spring bean configuration file.

What are the benefits of utilizing Spring Framework?

There are several benefits to utilizing the Spring Framework:

  • Reducing direct dependencies between different components of the application. Spring IoC container is responsible for initializing resources or beans and inject them as dependencies.
  • Writing unit test cases are easy in the Spring framework because our business logic doesn’t have direct dependencies with actual resource implementation classes. We can easily write a test configuration and inject our mock beans for testing purposes.
  • Reduces the amount of boiler-plate code, such as initializing objects, open/close resources. I like JdbcTemplate class a lot because it helps us in removing all the boiler-plate code that comes with JDBC programming.
  • Spring framework is divided into several modules, it helps us in keeping our application lightweight. For example, if we don’t need Spring transaction management features, we don’t need to add that dependency to our project.
  • Spring framework supports most of the Java EE features and even much more. It’s always on top of the new technologies, for example, there is a Spring project for Android to help us write better code for native Android applications. This makes the spring framework a complete package and we don’t need to look after the different frameworks for different requirements.

What are the key characteristics of Spring 5?

Spring 5 is a significant revamp compared to Spring 4, incorporating several crucial functionalities.

  • Support for Java 8 and higher versions, so we can use lambda expressions.
  • Support for Java EE7 and Servlet 4.0 specs.
  • File operations are performed via NIO 2 streams now, a huge improvement if your app does a lot of file handling.
  • Introduction of spring-jcl to streamline logging, earlier it was a mess due to no single point for logging purposes.
  • Support for Kotlin, Lombok, Reactor 3.1 Flux, and Mono as well as RxJava.
  • Spring WebFlux that brings reactive programming to Spring.
  • Support for JUnit 5
  • Support for providing spring components information through index file “META-INF/spring.components” rather than classpath scanning.

To gain a comprehensive understanding of this release, take a thorough look at the features offered by Spring 5.

What does Spring WebFlux mean?

Spring WebFlux, the new addition to Spring 5, serves as an initial step towards incorporating the reactive programming paradigm in the spring framework.

Spring WebFlux is a substitute for Spring MVC and enables the development of fully asynchronous and non-blocking applications based on the event-loop execution model.

For further information, you can check out the Spring WebFlux Tutorial.

Can you explain your understanding of Dependency Injection?

The design pattern of Dependency Injection enables us to eliminate fixed dependencies and create a flexible, scalable, and manageable application. By implementing this pattern, we can shift the resolution of dependencies from compile-time to runtime.

One advantage of Dependency Injection is that it allows for the separation of concerns, reduces boilerplate code, enables the configuration of components, and facilitates effortless unit testing.

To learn more about Dependency Injection, you can refer to the Dependency Injection Tutorial. Additionally, we have the option of utilizing Google Guice to automatically handle dependency injection. However, in most situations, we require more than just dependency injection, and this is where Spring takes the lead.

How can we incorporate dependency injection in the Spring Framework?

We have the option of using Spring XML or Annotation-based configuration to implement DI in spring applications. To gain a better understanding, you can refer to the Spring Dependency Injection example which illustrates both approaches along with a JUnit test case. The post also includes a sample project zip file for you to download and explore further.

What advantages does Spring Tool Suite offer?

One option for paraphrasing the given statement could be:

By incorporating plugins into Eclipse, we can acquire all the functionalities offered by Spring Tool Suite. Nevertheless, STS includes Eclipse along with additional significant components like Maven support, Templates for generating diverse Spring projects, and tc server for enhanced Spring application performance.

I prefer using STS for Spring-based application development as it effectively showcases the Spring components and clearly indicates which methods will be affected by specific pointcuts when using AOP advice and pointcuts. This helps us avoid the need to manually set up everything ourselves.

Can you list some of the significant Spring Modules?

There are several significant modules in the Spring Framework.

  • Spring Context – for dependency injection.
  • Spring AOP – for aspect-oriented programming.
  • Spring DAO – for database operations using DAO pattern
  • Spring JDBC – for JDBC and DataSource support.
  • Spring ORM – for ORM tools support such as Hibernate
  • Spring Web Module – for creating web applications.
  • Spring MVC – Model-View-Controller implementation for creating web applications, web services, etc.

What is your understanding of Aspect-Oriented Programming?

In different types of Objects and application modules, there are certain common concerns known as cross-cutting concerns, which include logging, transaction management, data validation, authentication, and more. Classes in Object-oriented programming enable the modularity of the application, while in AOP, this modularity is attained through Aspects that are configured to cut through various class methods.

AOP eliminates the need for classes in regular object-oriented programming to directly depend on cross-cutting tasks. In classic OOP, if we wanted separate logging functionality, other classes would have to manually call logging methods. However, with AOP, we can configure aspects and the execution of methods occurs automatically. To learn more about Spring AOP support, refer to the Spring AOP Example.

What exactly are Aspect, Advice, Pointcut, JointPoint, and Advice Arguments in AOP?

An Aspect is a type of class that incorporates cross-cutting concerns, like transaction management. Aspects can be a regular class that is configured within the Spring Bean configuration file, or we can utilize the Spring AspectJ support and declare a class as an Aspect by using the @Aspect annotation.

Advice refers to the action carried out at a specific point in code execution, typically in programming. In programming, advice refers to methods that are executed when a particular point in code execution matches a predefined condition. To give a better understanding, advice can be seen as similar to interceptors in Spring or filters in Servlets.

Pointcut: Regular expressions in pointcuts are used to match with join points in order to decide whether advice should be executed or not. Various types of expressions are used in pointcuts to match with the join points. When applying advice methods, the Spring framework utilizes the AspectJ pointcut expression language to identify the join points.

A join point in the application refers to a specific point, such as the execution of a method, exception handling, or modification of object variable values. This execution of a method is always considered as a join point in Spring AOP.

In advice methods, it is possible to pass arguments. We can utilize the args() expression in the pointcut to select methods that adhere to the argument pattern. When employing this approach, it is essential to ensure that the advice method utilizes the same name as the one used to determine the argument type.

At first, these notions may appear perplexing, but once you delve into the Spring Aspect and analyze an example of advice, you will quickly establish a connection with them.

What sets Spring AOP apart from AspectJ AOP?

AspectJ is the widely-accepted and commonly used implementation for Aspect-Oriented Programming, while Spring employs AOP for certain situations. The key distinctions between Spring AOP and AspectJ include:

  • Spring AOP is simpler to use than AspectJ because we don’t need to worry about the weaving process.
  • Spring AOP supports AspectJ annotations, so if you are familiar with AspectJ then working with Spring AOP is easier.
  • Spring AOP supports only proxy-based AOP, so it can be applied only to method execution join points. AspectJ support all kinds of pointcuts.
  • One of the shortcomings of Spring AOP is that it can be applied only to the beans created through Spring Context.

What does the Spring IoC Container refer to?

IoC, also known as Inversion of Control, is a way to achieve loose connectivity between object dependencies. It enables objects to determine their own dependencies, which are then injected by other assembler objects for dynamic binding at runtime. The Spring IoC container is the tool responsible for injecting these dependencies into an object and preparing it for our utilization.

The Spring Framework IoC container classes are found in the org.springframework.beans and org.springframework.context packages. They offer various methods for separating object dependencies.

We utilize several ApplicationContext implementations that are beneficial in our work.

  • AnnotationConfigApplicationContext: For standalone java applications using annotations-based configuration.
  • ClassPathXmlApplicationContext: For standalone java applications using XML-based configuration.
  • FileSystemXmlApplicationContext: Similar to ClassPathXmlApplicationContext except that the XML configuration file can be loaded from anywhere in the file system.
  • AnnotationConfigWebApplicationContext and XmlWebApplicationContext for web applications.

What exactly is a Spring Bean?

A Spring Bean is referred to as any regular Java class that is initialized by the Spring IoC container. To obtain the instance of a Spring Bean, we utilize the Spring ApplicationContext.

The Spring IoC container is responsible for handling the life cycle of Spring Beans, managing bean scopes, and fulfilling any necessary dependencies within the beans.

What is the significance of the configuration file for the Spring bean?

We utilize the Spring Bean configuration file to specify the beans that will be initialized by the Spring Context. When we instantiate the Spring ApplicationContext, it reads the XML file containing the spring beans and initializes them all. After the context is initialized, we can obtain various instances of beans from it.

Besides the Spring Bean configuration, this file includes Spring MVC interceptors, view resolvers, and other components necessary for annotations-based setups.

What are various methods to set up a class as a Spring Bean?

Spring Bean can be configured in three distinct manners.

The XML Configuration is widely used and allows us to configure a Spring Bean using the bean element in the context file. For instance:

<bean name="myBean" class="com.scdev.spring.beans.MyBean"></bean>

If you solely rely on annotations, you have the option to configure a Spring bean using the @Bean annotation in Java. This annotation should be used with @Configuration classes to configure a spring bean. Here is an example of a sample configuration:

public class MyConfiguration {

	public MyService getService(){
		return new MyService();

In order to obtain this bean from the spring context, the following code snippet must be utilized.

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
MyService service = ctx.getBean(MyService.class);

We can configure classes to be recognized as spring beans using annotations such as @Component, @Service, @Repository, and @Controller. In order to do this, we need to specify the base package location where these classes can be scanned. For instance:

<context:component-scan base-package="com.scdev.spring" />

What are the various Spring Bean scopes available?

Spring Beans are divided into five defined scopes.

    1. singleton: Only one instance of the bean will exist in the container, and this is the default scope for the spring beans. When using this scope, it is important to ensure that the spring bean does not have shared instance variables, as it may cause data inconsistency issues due to lack of thread safety.

prototype: Each time the bean is requested, a new instance will be created.

request: Similar to the prototype scope, but specifically designed for web applications. A new instance of the bean will be created for each HTTP request.

session: The container will create a new instance of the bean for each HTTP session.

global-session: This scope is used to create global session beans for Portlet applications.

The Spring Framework allows for extension and the creation of custom scopes, although the pre-existing scopes in the framework usually suffice. To define Spring bean scopes, we can utilize the “scope” attribute in the bean element or the @Scope annotation in annotation-based configurations.

What is the life cycle of a Spring Bean?

The Spring Container initializes Spring Beans and injects all their dependencies. When the context is destroyed, the initialized beans are also destroyed. Although this approach typically functions effectively, there are instances where we may need to initialize additional resources or perform validation before the beans become operational. Spring framework offers post-initialization and pre-destroy methods to support these requirements.

There are two options to achieve this – either by implementing the InitializingBean and DisposableBean interfaces, or by using the init-method and destroy-method attribute in the spring bean configurations. For more information, please refer to the Spring Bean Life Cycle Methods.

How can a Spring Bean obtain the ServletContext and ServletConfig object?

In the Spring bean, there are two methods to obtain objects specific to the Container.

  • Implementing Spring *Aware interfaces, for these ServletContextAware and ServletConfigAware interfaces, for a complete example of these aware interfaces, please read Spring Aware Interfaces.
  • Using @Autowired annotation with bean variable of type ServletContext and ServletConfig. They will work only in servlet container-specific environments only.
ServletContext servletContext;

What does Bean wiring mean and what is the purpose of the @Autowired annotation?

Spring Bean Wiring is the term used to describe the process of injecting spring bean dependencies during initialization.

Generally, it is advisable to manually wire all the dependencies of a bean, but the spring framework also provides the option of auto-wiring. By using the @Autowired annotation with fields or methods, we can automatically wire dependencies based on their types. However, in order for this annotation to function correctly, we must also enable annotation-based configuration in the spring bean configuration file. This can be achieved by including the context:annotation-config element.

To gain a deeper understanding of the @Autowired annotation, it is recommended to refer to the Spring Autowire Example for further information.

What are the various forms of autowiring available for Spring Beans?

The Spring framework includes four different types of autowiring.

    1. autowiring using the byName method


    1. autowiring using the byType method


    1. autowiring using the constructor method


    autowiring using the @Autowired and @Qualifier annotations

Before Spring 3.1, autowire by autodetect was supported, resembling autowire by constructor or byType. For further information on these choices, please refer to Spring Bean Autowiring.

Do Spring Beans offer thread safety?

By default, Spring beans are singletons, thus only one instance exists per context. Consequently, allowing a class level variable that any thread can modify will result in inconsistent data. Therefore, in their default state, Spring beans are not thread-safe.

We have the option to modify the spring bean scope to request, prototype, or session in order to ensure thread-safety, although this may impact performance. This decision depends on the specific project requirements.

What does a Controller do in Spring MVC?

Similar to the MVC architectural pattern, the Controller class handles client requests and directs them to the designated resources for processing. In the Spring MVC framework, the front controller class is DispatcherServlet, which initializes the context based on the configuration of Spring beans.

The Controller class manages various client requests by using request mappings. To create a controller class, the @Controller annotation is employed. Typically, it is paired with the @RequestMapping annotation to designate handler methods for particular URI mappings.

What distinguishes the annotations @Component, @Controller, @Repository & @Service in Spring?

@Component is employed to denote a class as a component. Such classes are utilized for automatic detection and are configured as a bean in scenarios where annotation-based configurations are implemented.

The @Controller is a distinct form of component utilized in MVC applications, often associated with the RequestMapping annotation.

The @Repository annotation is employed to indicate that a component functions as a repository and serves as a means to store, retrieve, and search data. This annotation can be utilized in classes implementing the DAO pattern.

The @Service annotation is utilized to designate a class as a Service. Typically, this annotation is applied to the business facade classes that offer various services.

We have the freedom to utilize any of the mentioned annotations to enable automatic recognition of a class. However, multiple types are available to ensure clear differentiation of the intended use for the annotated classes.

What are the roles of DispatcherServlet and ContextLoaderListener?

The front controller in the Spring MVC application is known as the DispatcherServlet. It is responsible for loading the configuration file for Spring beans and initializing all the configured beans. If annotations are enabled, it also scans the packages and configures any beans that are annotated with @Component, @Controller, @Repository, or @Service.

One possible paraphrase:

The ContextLoaderListener is responsible for initiating and closing down Spring’s main WebApplicationContext. Its key roles are ensuring that the lifecycle of the ApplicationContext is synchronized with that of the ServletContext and automating the creation of the ApplicationContext. It can be utilized to define shared beans that can be accessed across multiple spring contexts.

What does ViewResolver mean in Spring framework?

We use ViewResolver implementations to find the view pages based on their names. We set it up in the spring bean configuration file. One example is:

<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<beans:property name="prefix" value="/WEB-INF/views/" />
	<beans:property name="suffix" value=".jsp" />

InternalResourceViewResolver is a type of ViewResolver implementation in which the directory and suffix location of the view pages are specified through the bean properties. Therefore, when a controller handler method returns “home”, the view resolver will use the view page located at /WEB-INF/views/home.jsp.

What is the purpose of a MultipartResolver and when is it typically employed?

The MultipartResolver interface in the Spring framework offers two implementations, namely CommonsMultipartResolver and StandardServletMultipartResolver, for file uploading. By default, no multipart resolvers are configured. However, to enable file uploading, a bean named “multipartResolver” needs to be defined in the Spring bean configurations with the type set as MultipartResolver.

After the configuration process, the specified MultipartResolver will handle any multipart request and forward it as a wrapped HttpServletRequest. This is then utilized in the controller class to retrieve and handle the file. To see a comprehensive example, please refer to the Spring MVC File Upload Example.

How should exceptions be managed in Spring MVC Framework?

The Spring MVC Framework offers various methods to assist us in achieving strong exception handling.

In controller-based architecture, we have the ability to specify methods in our controller classes that handle exceptions. To achieve this, it is necessary to annotate these methods with the @ExceptionHandler annotation.

The Global Exception Handler is a universal method of handling exceptions in Spring. By using the @ControllerAdvice annotation, we can designate any class as our global exception handler.

To handle generic exceptions, we often display static pages. The Spring Framework offers an interface called HandlerExceptionResolver that allows us to create a global exception handler. This alternative approach exists because the Spring framework provides default implementation classes that can be defined in our spring bean configuration file to take advantage of its exception handling capabilities.

To see a comprehensive example, please refer to the Spring Exception Handling Example.

29. What is the process of creating an ApplicationContext in a Java Program?

There are various ways to generate a Spring context in a standalone Java program.

    1. AnnotationConfigApplicationContext can be used to bootstrap the Spring container and retrieve bean objects when using Spring with annotations in standalone Java applications.


    1. ClassPathXmlApplicationContext is utilized to load and access the container object when there is a separate XML file for spring bean configuration in a standalone application.


    FileSystemXmlApplicationContext behaves similarly to ClassPathXmlApplicationContext, but it enables the loading of the XML configuration file from any location within the file system.

Is it possible to use more than one Spring configuration file?

We have the option to define multiple spring context configuration files for Spring MVC applications using the contextConfigLocation. This string can include several locations separated by commas and spaces. For instance;


We have the option to define multiple spring configurations at the root level and load them through the context-param. For instance;

	<param-value>/WEB-INF/spring/root-context.xml /WEB-INF/spring/root-security.xml</param-value>

You can also choose to use the import element in the context configuration file for importing other configurations.

<beans:import resource="spring-jdbc.xml"/>

What does ContextLoaderListener refer to?

The listener class used to load the root context and specify spring bean configurations, which will be accessible to all other contexts, is ContextLoaderListener. It is set up in the web.xml file as:


What is the bare minimum required to set up a Spring MVC application?

To develop a basic Spring MVC application, we must complete the following steps.

  • Add spring-context and spring-webmvc dependencies in the project.
  • Configure DispatcherServlet in the web.xml file to handle requests through the spring container.
  • Spring bean configuration file to define beans, if using annotations then it has to be configured here. Also, we need to configure the view resolver for view pages.
  • Controller class with request mappings defined to handle the client requests.

The aforementioned steps are sufficient to develop a basic Spring MVC Hello World application.

How can you connect Spring MVC Framework with MVC architecture?

Spring MVC is constructed using the Model-View-Controller architecture, with DispatcherServlet serving as the primary agent responsible for managing incoming requests and forwarding them to various controller handler methods.

The model in the Spring Framework can be any Java Bean, similar to other MVC frameworks. Spring facilitates automatic binding of form data to Java beans. We have the option to assign model beans as attributes for utilization in the view pages.

The pages that can be viewed include JSP, static HTML, and other types. The responsibility of the view resolvers is to locate the appropriate view page. Once the view page is found, control is handed back to the DispatcherServlet controller. The DispatcherServlet is in charge of displaying the view and returning the final response to the client.

How can Spring MVC applications implement localization?

Spring offers strong support for localization or internationalization (i18n) by utilizing resource bundles. The fundamental actions required to localize our application are as follows:

  • Creating message resource bundles for different locales, such as,, etc.
  • Defining messageSource bean in the spring bean configuration file of type ResourceBundleMessageSource or ReloadableResourceBundleMessageSource.
  • For a change of locale support, define localeResolver bean of type CookieLocaleResolver and configure LocaleChangeInterceptor interceptor. An example configuration is shown as follows:
<beans:bean id="messageSource"
<beans:property name="basename" value="classpath:messages" />
<beans:property name="defaultEncoding" value="UTF-8" />
<beans:bean id="localeResolver"
    <beans:property name="defaultLocale" value="en" />
    <beans:property name="cookieName" value="myAppLocaleCookie"></beans:property>
    <beans:property name="cookieMaxAge" value="3600"></beans:property>
    <beans:bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
        <beans:property name="paramName" value="locale" />
  • Use spring:message element in the view pages with key names, DispatcherServlet picks the corresponding value and renders the page in corresponding locale and return as response.

To see a comprehensive illustration, kindly refer to the Spring Localization Example.

How can we utilize Spring to generate a Restful Web Service that provides a JSON response?

One option for paraphrasing the given statement is:

Spring Framework allows us to develop Restful web services which can return JSON data. Spring offers the integration with Jackson JSON API to facilitate sending JSON responses in a restful web service.

To enable JSON response in our Spring MVC application, we must perform the following steps.

If you are using Maven, you can include the Jackson JSON dependencies by using the following code.

<!-- Jackson -->

In the spring bean configuration file, set up the RequestMappingHandlerAdapter bean and assign the MappingJackson2HttpMessageConverter bean to the message converters property. A potential configuration example is as follows:

<!-- Configure to plugin JSON as request and response in method handler -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <beans:property name="messageConverters">
            <beans:ref bean="jsonMessageConverter"/>
<!-- Configure bean to convert JSON to POJO and vice versa -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">

3. Use the @ResponseBody annotation in the controller’s handler methods to return the Object as a response. Here is an example code snippet:

@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {"Start getEmployee. ID="+empId);
    return empData.get(empId);

If you want to utilize Spring, invoking the rest service can be done easily with the RestTemplate class. However, you have the flexibility to use any API to achieve the same.

If you want to see a complete illustration, take a look at the example of Spring Restful Webservice.

Which Spring annotations have you utilized that are significant?

In my project, I have utilized several Spring annotations.

  • @Controller – for controller classes in Spring MVC project.
  • @RequestMapping – for configuring URI mapping in controller handler methods. This is a very important annotation, so you should go through Spring MVC RequestMapping Annotation Examples
  • @ResponseBody – for sending Object as a response, usually for sending XML or JSON data as a response.
  • @PathVariable – for mapping dynamic values from the URI to handler method arguments.
  • @Autowired – for auto wiring dependencies in spring beans.
  • @Qualifier – with @Autowired annotation to avoid confusion when multiple instances of bean type are present.
  • @Service – for service classes.
  • @Scope – for configuring scope of the spring bean.
  • @Configuration, @ComponentScan, and @Bean – for java based configurations.
  • AspectJ annotations for configuring aspects and advice, @Aspect, @Before, @After, @Around, @Pointcut, etc.

Is it possible to send an Object as the response for the Controller handler method?

We are able to achieve this by employing the @ResponseBody annotation. It enables us to transmit responses in JSON or XML format within restful web services.

How can files be uploaded in a Spring MVC application?

The MultipartResolver interface implementations in Spring offer convenient functionality for file uploads. It is straightforward to use and only requires making changes to the configuration. To handle the received file and process it, we would need to write a controller handler method. For a comprehensive illustration, please refer to the Spring File Upload Example.

How can we verify form data in the Spring Web MVC Framework?

Spring provides support for JSR-303 annotation-driven validations and also offers a Validator interface that allows us to develop our own custom validator. To utilize JSR-303 validations, we must annotate the variables of the bean with the necessary validations.

To implement a custom validator, it is necessary to set it up in the controller class. To see a full example, refer to the Spring MVC Form Validation Example.

What is the purpose of Spring MVC Interceptor and how can it be implemented?

Spring MVC Interceptors function similarly to Servlet Filters and enable us to intercept and handle client requests. These interceptors offer three points of interception: preHandle, postHandle, and afterCompletion.

One option for native paraphrasing:
To develop a spring interceptor, we have the choice of either implementing the HandlerInterceptor interface or extending the abstract class HandlerInterceptorAdapter.

In the spring bean configuration file, it is necessary to set up interceptors. These interceptors can be defined to handle all client requests or can be configured for specific URI mapping as well. If you want to see a comprehensive example, please check out the Spring MVC Interceptor Example.

What is the purpose of the Spring JdbcTemplate class and how can it be utilized?

The Spring Framework offers seamless integration with the JDBC API and includes the JdbcTemplate utility class. This class allows us to eliminate repetitive code in our database operations logic, such as managing connections, result sets, and prepared statements.

Please see the Spring JDBC Example for an instance of the JdbcTemplate.

How can I utilize Tomcat’s JNDI DataSource for a Spring Web Application?

To use a JNDI DataSource with a servlet container, we must configure it in the spring bean configuration file and inject it as dependencies into spring beans. Subsequently, we can utilize it with JdbcTemplate for executing database tasks.

<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>

To obtain the full example, kindly consult the Spring Tomcat JNDI Example.

How can you implement Transaction Management in Spring?

The Spring framework offers support for transaction management, both through Declarative Transaction Management and programmatic transaction management. Declarative transaction management is the more commonly used approach, as it is user-friendly and compatible with a majority of cases.

In order to manage transactions declaratively, we apply the @Transactional annotation to a method. To properly configure the transaction manager for the DataSource, we must make the necessary adjustments in the spring bean configuration file.

<bean id="transactionManager"
    <property name="dataSource" ref="dataSource" />

What does Spring DAO refer to?

Spring offers support for data access technologies such as JDBC, Hibernate, JDO, and JPA, making it easier and more consistent to work with them. Specific examples include JdbcDaoSupport for JDBC, HibernateDaoSupport for Hibernate, JdoDaoSupport for JDO, and JpaDaoSupport for JPA.

In addition to ensuring consistency in exception hierarchy, Spring DAO eliminates the need to handle specific exceptions.

How can the Spring and Hibernate Frameworks be integrated?

If you are using Hibernate 3+, you can integrate the Spring and Hibernate frameworks using the Spring ORM module. Instead of using HibernateTemplate or HibernateDaoSupport classes, it is recommended to use the DAO pattern with dependency injection for better integration.

Instead of using Hibernate boiler-plate code for transaction management, you should leverage Spring ORM which offers support for Spring declarative transaction management.

To enhance your comprehension, it is recommended that you review the tutorials provided below.

  • Spring Hibernate Integration Example
  • Spring MVC Hibernate Integration Example

What does Spring Security entail?

The primary objective of the Spring security framework is to ensure authentication and authorization in Java applications. Additionally, it offers protection against widespread security risks like CSRF attacks.

Using Spring security in web applications is highly advantageous and straightforward, thanks to the utilization of annotations like @EnableWebSecurity. To grasp the implementation of the Spring Security framework, it is recommended to go through the subsequent articles.

  • Spring Security in Servlet Web Application
  • Spring MVC and Spring Security Integration Example

How can I inject a java.util.Properties object into a Spring Bean?

To start with, it is necessary for us to specify the propertyConfigurer bean responsible for loading properties from the designated property file. After that, we can leverage the support of Spring EL to inject those properties into other bean dependencies. As an illustration:

<bean id="propertyConfigurer" 
    <property name="location" value="/WEB-INF/" />

<bean class="com.scdev.spring.EmployeeDaoImpl">
    <property name="maxReadResults" value="${}"/>

If you are utilizing annotation for configuring the spring bean, you can inject a property in the following manner.

private int maxReadResults;

Can you list a few of the design patterns employed in Spring Framework?

The Spring Framework extensively incorporates various design patterns, among which few popular ones include:

    1. Singleton Pattern: The creation of beans with the default scope.


    1. Factory Pattern: Classes used as bean factories.


    1. Prototype Pattern: Scopes for beans.


    1. Adapter Pattern: Spring Web and Spring MVC.


    1. Proxy Pattern: Support for aspect-oriented programming in Spring.


    1. Template Method Pattern: JdbcTemplate, HibernateTemplate, among other examples.


    1. Front Controller: Spring MVC DispatcherServlet.


    1. Data Access Object: Support for Spring DAO.


    Dependency Injection and Aspect-Oriented Programming.

What are a few of the recommended approaches for the Spring Framework?

– There are several recommended approaches for utilizing Spring Framework effectively.

  • Avoid version numbers in schema reference, to make sure we have the latest configs.
  • Divide spring bean configurations based on their concerns such as spring-jdbc.xml, spring-security.xml.
  • For spring beans that are used in multiple contexts in Spring MVC, create them in the root context and initialize with the listener.
  • Configure bean dependencies as much as possible, try to avoid auto wiring as much as possible.
  • For application-level properties, the best approach is to create a property file and read it in the spring bean configuration file.
  • For smaller applications, annotations are useful but for larger applications, annotations can become a pain. If we have all the configuration in XML files, maintaining it will be easier.
  • Use correct annotations for components for understanding the purpose easily. For services use @Service and for DAO beans use @Repository.
  • Spring framework has a lot of modules, use what you need. Remove all the extra dependencies that get usually added when you create projects through Spring Tool Suite templates.
  • If you are using Aspects, make sure to keep the join pint as narrow as possible to avoid advice on unwanted methods. Consider custom annotations that are easier to use and avoid any issues.
  • Use dependency injection when there is an actual benefit, just for the sake of loose-coupling don’t use it because it’s harder to maintain.

What does Spring Boot refer to?

Spring Boot sets the spring framework apart by offering a convenient approach to develop various Java applications and connect them to the servlet container runtime environment. As a result, we obtain a compact JAR file that allows us to effortlessly run the project, ultimately saving a significant amount of time in preparing a deployable project framework. By eliminating the need to build and deploy code on a servlet container, we can dedicate more attention to the business logic. Considering the extensive nature of this topic, I recommend reviewing Spring Boot Interview Questions to further enhance your understanding.

These are all the questions I have for Spring Framework interviews. I hope they will assist you in your upcoming Java EE interview. I will continue to add more questions to the list as soon as I come across them. If you have any additional questions that should be included, please leave a comment and I will add them.


More tutorials

The Spring Framework(Opens in a new browser tab)

One example of Spring REST XML and JSON(Opens in a new browser tab)

Spring MVC Controller(Opens in a new browser tab)

Tutorial on Java Server Faces (JSF)(Opens in a new browser tab)

Dependency Injection in Spring(Opens in a new browser tab)

Leave a Reply 0

Your email address will not be published. Required fields are marked *