Explore topic-wise InterviewSolutions in .

The validation is generally performed during HTTP POST requests. During HTTP requests, if the state of the checkbox is unchecked, then HTTP includes the request parameter for the checkbox THEREBY not picking up the updated selection. This can be fixed by making use of a hidden form field that starts with _ in the Spring MVC.

In this article, we have seen the most commonly asked Spring INTERVIEW Questions during an interview. Spring is a very powerful framework that allows building enterprise-level web applications. Applications developed using Spring are generally quick, SCALABLE, and transparent. Due to this, Spring has been embraced by a HUGE Java Developer’s community thereby making it an inevitable part of any Java Developer’s Job Role. Knowing Spring ensures that an added advantage is with the developers to progress steadily in their careers too.

Tip: We also recommend READING guides posted here.

To use the servlet container which is CONFIGURED in the JNDI (Java Naming and Directory INTERFACE) DataSource, the DataSource bean has to be configured in the spring bean config file and then injected into the beans as dependencies. Post this, the DataSource bean can be used for performing database operations by means of the JDBCTEMPLATE. The syntax for registering a MySQL DataSource bean:

The MultipartResolver is used for handling the file upload scenarios in the Spring web application. There are 2 CONCRETE implementations of this in Spring, they are:

• CommonsMultipartResolver meant for Jakarta Commons FileUpload
• StandardServletMultipartResolver meant for for SERVLET 3.0 Part API

To implement this, we need to create a bean with id=“multipartResolver” in the application context of DispatcherServlet. Doing this ensures that all the requests handled by the DispatcherServlet have this resolver applied whenever a multipart request is detected. If a multipart request is detected by the DispatcherServlet, it resolves the request by means of the already configured MultipartResolver, and the request is passed on as a wrapped/abstract HttpServletRequest. Controllers then cast this request as the MultipartHttpServletRequest interface to get access to the Multipart files. The following DIAGRAM illustrates the FLOW clearly:

Spring MVC has LOCALERESOLVER that supports i18n and localization. for supporting both internationalization and localization. The following beans need to be configured in the application:

• SessionLocaleResolver: This bean plays a vital role to get and resolve the locales from the pre-defined attributes in the user session.

Syntax:

• LocaleChangeInterceptor: This bean is useful to resolve the parameter from the incoming request.

Syntax:

• DefaultAnnotationHandlerMapping: This REFERS to the HandlerMapping interface implementation which maps the handlers/interceptors BASED on the HTTP paths specified in the @RequestMapping at type or method level.

Syntax:

BeanFactory and the ApplicationContext are both JAVA interfaces. The difference is that the ApplicationContext extends the BeanFactory. BeanFactory provides both IoC and DI BASIC features whereas the ApplicationContext provides more advanced features. Following are the differences between these two:

This can be DONE by either implementing the spring-aware INTERFACES or by using the @Autowired ANNOTATION.

Spring MVC does the task of data validation using the validator object which implements the Validator interface. In the custom validator class that we have created, we can use the utility methods of the ValidationUtils class like rejectIfEmptyOrWhitespace() or rejectIfEmpty() to perform validation of the form FIELDS.

In the fields that are subject to validation, in case of errors, the validator methods would create field error and bind that to the field.

To activate the custom validator as spring bean, then:

• We have to add the @COMPONENT annotation on the custom validator class and initiate the component scanning of the package containing the validator declarations by ADDING the below CHANGE:

OR

The validator class can be registered in the context file directly as a bean as shown:

<context:annotation-CONFIG> is used for ACTIVATING applied ANNOTATIONS in pre-registered beans in the application context. It also registers the beans defined in the config file and it scans the annotations within the beans and activates them.

The <context:component-scan> TAG does the task of <context:annotation-config> along with scanning the packages and registering the beans in the application context.

<context:annotation-config> = Scan and activate annotations in pre-registered beans.
<context:component-scan> = Register Bean + Scan and activate annotations in package.

The SPRING-mv.jar does not belong to the spring-core. This means that the jar has to be INCLUDED in the project’s classpath if we have to use the Spring MVC framework in our project. For JAVA applications, the spring-mvc.jar is PLACED INSIDE /WEB-INF/lib folder.

Spring Interceptors are used to pre-handle and post-handle the web requests in Spring MVC which are handled by Spring Controllers. This can be achieved by the HandlerInterceptor interface. These handlers are used for manipulating the MODEL attributes that are passed to the controllers or the views.
The Spring handler interceptor can be registered for specific URL mappings so that it can intercept only those requests. The custom handler interceptor must implement the HandlerInterceptor interface that has 3 CALLBACK methods that can be implemented:

• preHandle()
• postHandle()
• afterCompletion()

The only PROBLEM with this interface is that all the methods of this interface need to be implemented irrespective of its REQUIREMENTS. This can be avoided if our handler class extends the HandlerInterceptorAdapter class that internally implements the HandlerInterceptor interface and provides default BLANK implementations.

BindingResults is an important Spring interface that is within the org.Springframework.validation package. This interface has a very simple and easy process of invocation and plays a vital role in detecting errors in the submitted forms. However, care has to be taken by the developer to USE the BindingResult parameter just after the object that NEEDS validation. For example:

The Spring will understand to FIND the corresponding VALIDATORS by checking the @Valid annotation on the parameter.

The view requires access to the model to render the output as the model contains the REQUIRED data meant for rendering. The model is associated with the controller that PROCESSES the CLIENT REQUESTS and FINALLY encapsulates the response into the Model object.

A Dispatcher Servlet knows which controller to call by means of handler mappings. These mappings have the mapping between the controller and the requests. BeanNameUrlHandlerMapping and SimpleUrlHandlerMapping are the two most commonly USED handler mappings.

• BeanNameUrlHandlerMapping: When the URL request matches the bean name, the class CORRESPONDING to the bean definition is the actual controller that is responsible for processing the request.
• SimpleUrlHandlerMapping: Here, the mapping is very explicit. The number of URLs can be specified here and each URL is associated explicitly with a controller.

If the Spring MVC is CONFIGURED using annotations, then @RequestMapping annotations are used for this purpose. The @RequestMapping ANNOTATION is configured by making use of the URI path, HTTP METHODS, query parameters, and the HTTP Headers.

The ROOT application context is loaded using the ContextLoaderListener that BELONGS to the ENTIRE application. SPRING MVC allows instantiating multiple DispatcherServlet and each of them have multiple contexts specific to them. They can have the same root context too.

The dispatcher servlet is instantiated by means of servlet containers such as Tomcat. The Dispatcher Servlet should be defined in web.xml The DispatcherServlet is instantiated by Servlet containers like Tomcat. The Dispatcher Servlet can be defined in web.xml as shown below:

Here, the load-on-startup tag is 1 which indicates that the DispatcherServlet is instantiated whenever the Spring MVC APPLICATION to the servlet container. During this PROCESS, it looks for the servlet-name-context.xml file and initializes BEANS that are defined in the file.

@Repository annotation indicates that a COMPONENT is USED as the repository that ACTS as a means to store, SEARCH or retrieve data. These can be added to the DAO classes.

The thread safety can be ACHIEVED by changing the scope of the bean to REQUEST, session or PROTOTYPE but at the COST of performance. This is purely based on the project REQUIREMENTS.

No, the singleton beans are not thread-safe because the concept of thread-SAFETY essentially deals with the EXECUTION of the program and the singleton is simply a design pattern MEANT for the creation of OBJECTS. Thread safety nature of a BEAN depends on the nature of its implementation.

The annotation is used for indicating that the property of the bean should be populated via autowiring or any explicit value during the bean definition at the CONFIGURATION time. For example, consider a code snippet below where we NEED to have the values of age and the name:

Session scopes are used to create BEAN INSTANCES for HTTP sessions. This would mean that a single bean can be used for serving multiple HTTP REQUESTS. The scope of the bean can be defined by means of using scope attribute or using @Scope or @SessionScope annotations.

• Using scope attribute:

• Using @Scope annotation:

• Using @SessionScope:

There are two types of DI (Dependency Injection):

• Construction-Based:
  • This TYPE of DI is accomplished when the Spring IoC (Inversion of Control) container invokes parameterized constructor having a dependency on other classes.
  • This cannot instantiate the values partially and ensures that the dependency injection is done fully.
  • There are two possible ways of achieving this:

Annotation Configuration: This approach USES POJO objects and annotations for configuration. For example, consider the below code snippet:

Here, the annotations are used for notifying the Spring runtime that the class specified with @Bean annotation is the provider of beans and the process of context scan needs to be performed on the package com.interviewbit.constructordi by means of @ComponentScan annotation. Next, we will be defining a Figure class component as below:

Spring encounters this Figure class while performing context scan and it initializes the instance of this class by invoking the constructor annotated with @Autowired. The Shape and Dimension instances are obtained by calling the methods annotated with @Bean in the SpringAppConfig class. Instances of Engine and Transmission will be obtained by calling @Bean annotated methods of the Config class. Finally, we need to bootstrap an ApplicationContext using our POJO configuration:

XML Configuration: This is another way of configuring Spring runtime by using the XML configuration file. For example, consider the below code snippet in the springAppConfig.xml file:

The constructor-arg tag can accept either literal value or another bean’s REFERENCE and explicit index and type. The index and type arguments are used for resolving conflicts in cases of ambiguity.
While bootstrapping this class, the Spring ApplicationContext needs to use ClassPathXmlApplicationContext as shown below:

• Setter-Based:
  • This form of DI is achieved when the Spring IoC container calls the bean’s setter method after a non-parameterized constructor is called to PERFORM bean instantiation.
  • It is possible to achieve circular dependency using setter injection.
  • For achieving this type of DI, we need to configure it through the configuration file under the <property> tag. For example, consider a class InterviewBit that sets the property articles as shown below:

In the bean configuration file, we will be setting as below: 

The ‘JsonArticle’ bean is injected into the InterviewBit class object by means of the setArticle method.
In cases where both types of dependencies are used, then the setter dependency injection has more preference by considering the specificity nature.

web.xml is also KNOWN as the Deployment Descriptor which has DEFINITIONS of the servlets and their mappings, filters, and lifecycle listeners. It is also USED for configuring the ContextLoaderListener. Whenever the application is DEPLOYED, a ContextLoaderListener instance is created by Servlet container which leads to a load of WEBAPPLICATIONCONTEXT.

The annotation plays a very important role in binding method parameters to the respective attribute that corresponds to a model. Then it REFLECTS the same on the presentation page. The role of the annotation ALSO depends on what the developer is USING that for. In case, it is used at the method level, then that method is RESPONSIBLE for adding attributes to it. When used at a parameter level, it represents that the parameter value is MEANT to be retrieved from the model layer.

@Autowired annotation is meant for the injection of a bean by MEANS of its type along with methods and FIELDS. This helps the Spring framework to resolve dependencies by injecting and COLLABORATING the BEANS into another bean. For example, consider the below code snippet:

• Model is a reference to have the data for rendering.
• It is always created and PASSED to the view in Spring MVC. If a mapped controller METHOD has Model as a parameter, then that model instance is automatically injected to that method.
• Any ATTRIBUTES set on the injected model WOULD be PRESERVED and passed to the View.

• Even though both these annotations are used to EXTRACT some DATA from URL, there is a key difference between them.
  • The @RequestParam is used to extract query parameters that is ANYTHING after “?” in the URL.
  • The @PathVariable is used to extract the data present as part of the URI itself.]
  • For example, if the given URL is http://localhost:8080/InterviewBit/Spring/SpringMVC/?format=json, then you can access the query parameter “format” using the @RequestParam annotation and /Spring/{type} using the @PathVariable, which will give you SpringMVC.

• The CONTEXTLOADERLISTENER loads and creates the ApplicationContext, so a developer need not write explicit code to do CREATE it. In short, it is a listener that aids to bootstrap Spring MVC.
  • The application context is where Spring bean resides. For a web application, there is a subclass called WebAppliationContext.
• The lifecycle of the ApplicationContext is tied to the lifecycle of the ServletContext by USING ContextLoaderListener. The ServletContext from the WebApplicationContext can be obtained using the getServletContext() METHOD.

• Yes! You can create a CONTROLLER without @Controller or @RestController annotations by annotating the SPRING MVC Controller classes USING the @COMPONENT annotation. In this case, the real job of request MAPPING to handler method is done using the @RequestMapping annotation.

• The @CONTROLLER is a STEREOTYPE Spring MVC ANNOTATION to DEFINE a Controller.

• It is a J2EE pattern that ALLOWS the APPLICATIONS to dynamically choose technology for rendering the data on the browser (View).
  • Any technology like HTML, JSP, XSLT, JSF, or any other such technology can be used as View.
• The View Resolver has the information of different views. The CONTROLLER returns the name of the View which is then passed to View Resolver by the DispatcherServlet for selecting the APPROPRIATE View technology and then the data is displayed.
• The default ViewResolver used in Spring MVC is InternalResourceViewResolver.

Spring MVC framework is built around a central servlet CALLED DispatcherServlet that handles all the HTTP requests and responses. The DispatcherServlet does a lot more than that:

• It seamlessly integrates with the IOC container and allows you to use each feature of Spring in an easier manner.
• The DispatcherServlet CONTACTS HandlerMapping to call the APPROPRIATE Controller for processing the request on receiving it. Then, the controller calls appropriate service methods to set or process the Model data. The service processes the data and returns the view name to DispatcherServlet. DispatcherServlet then takes the HELP of ViewResolver and picks up the defined view for the request. Once the view is decided, the DispatcherServlet passes the Model data to View where it is finally rendered on the browser.

• Clear separation of roles – There is a specialised dedicated object for EVERY role.
• Reusable BUSINESS code logic – With Spring MVC, there is no NEED for duplicating the code. Existing objects can be USED as commands instead of replicating them in order to extend a particular framework base class.
• Spring MVC framework provides customizable binding and validation.
• Also provides customizable locale and theme resolution.
• Spring MVC supports customizable handler mapping and view resolution too.

• Spring MVC is REQUEST driven framework and ONE of the core components of the Spring framework.
• It COMES with ready to use loosely coupled components and elements that greatly aids developers in building flexible and robust web applications.
• The MVC (Model - View - Controller) architecture separates and PROVIDES loose coupling between the DIFFERENT aspects of the application – input logic (Model), business logic (Controller), and UI logic (View).