java.interview.preparation: Understanding Spring MVC

Spring MVC is mostly used with Spring for any web application development. It is very powerful and nice layered architecture for flow and configuration. It is very flexible to integrate with other web frameworks like struts. In interviews mostly flow of Spring MVC framework and configuration files are asked. Details on Spring core modules and Spring framework interview questions.

Spring provides a Dispatcher Servlet called DispatcherServlet, which maps to an URI path pattern, in this case it is /myApp/*. You configure the servlet in web.xml.

Flow of the Spring MVC:

The DispatcherServlet configured in web.xml file receives the request.
The DispatcherServlet finds the appropriate Controller with the help of HandlerMapping and then invokes associated Controller.
Then the Controller executes the logic business logic (if written by the programmer) and then returns ModeAndView object to the DispatcherServlet.
The DispatcherServlet determines the view from the ModelAndView object.
Then the DispatcherServlet passes the model object to the View.
The View is rendered and the Dispatcher Servlet sends the output to the Servlet container. Finally Servlet Container sends the result back to the user.

Sample Web.xml

	<?xml version="1.0" encoding="UTF-8"?>
	<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
	<display-name>MVC</display-name>
	<servlet>
	<servlet-name>spring</servlet-name>
	<servlet-class>
	org.springframework.web.servlet.DispatcherServlet
	</servlet-class>
	<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
	<servlet-name>spring</servlet-name>
	<url-pattern>*.html</url-pattern>
	</servlet-mapping>
	</web-app>

view raw web.xml hosted with ❤ by GitHub

Controller
Controllers are annotated with @Controller. The Spring MVC Dispatcher Servlet scans for all the conroller classes. There is no need to define the controllers as beans in the conext xml file, Spring automatically does that for us. All we have to do is adding one line in the context file
web-application-config.xml, which is passed in as an initialization paramter to the Spring MVC Dispatcher Servlet.

Sample Controller class:

	package com.learning.controller;

	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestMethod;
	import org.springframework.web.servlet.ModelAndView;

	@Controller
	public class HelloWorldController {
	/**
	* Web context path hello
	**/
	@RequestMapping(value = "/hello", method = RequestMethod.GET)
	public String sayHello() {
	return "hello";
	}
	/**
	* Webcontext path mvc
	**/
	@RequestMapping(value = "/mvc", method = RequestMethod.GET)
	public ModelAndView helloWorld() {
	String message = "Hello World, Spring 3.0!";
	return new ModelAndView("mvc", "message", message);

	}
	}

view raw HelloWorldControler.java hosted with ❤ by GitHub

Above is an example of a controller. URI path /mvc/* is mapped to this controller. Each handler method further narrows it down by additional URI path pattern and http method. For helloWorld() method maps to /mvc GET method. Handler methods have flexible signature and return type. In this example, they return three types:

void: view is implied by RequestToViewNameTranslator
string: view name
Model object: view is implied by RequestToViewNameTranslator

Model
Model in Spring MVC is actually a map, which contains beans (map values) and bean names (map keys). Model is completely separated from view and view rendering technology.
A special type of model is Form Model. Form model is specified in the form tag as following:
In the handler method, form model object can be passed in as method parameter, or returned as return value. By convention-over-configuration, Spring figures out form model object name by its class name. You can always use @ModelAttribute if the names does not match.

Spring Servlet xml

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
	<context:annotation-config />
	<context:component-scan base-package="com.learning.controller" />
	<mvc:interceptors>
	<!-- This interceptor is to pre handle or post handle every web request through servlet container.-->
	<bean class="com.learning.interpreter.HelloWorldInterceptor" />
	</mvc:interceptors>
	<bean id="jspViewResolver"
	class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="viewClass"
	value="org.springframework.web.servlet.view.JstlView" />
	<property name="prefix" value="/WEB-INF/jsp/" />
	<property name="suffix" value=".jsp" />
	</bean>
	</beans>

view raw spring-servlet.xml hosted with ❤ by GitHub

SpringMVC project folder structure

Interview Questions:

1) Benefits of Spring MVC over Struts?
These are major benefits of Spring MVC :-

1. We have clear separation between models, views and controllers in Spring.

2. It is very versatile and flexible based on interfaces but Struts forces Actions and Form object into concrete inheritance.

3. It provides both interceptors and controllers, thus helps to factor out common behavior to the handling of many requests.

4. It can be configured with different view technologies like Freemarker, JSP, Tiles, Velocity, XLST etc. and also you can create your own custom view mechanism by implementing Spring View interface.

5. In Spring MVC Controllers can be configured using DI (IOC) that makes its testing and integration easy.

6. Web tier of Spring MVC is easy to test than Struts web tier, because of the avoidance of forced concrete inheritance and explicit dependence of controllers on the dispatcher servlet.

7. Spring web layer built on top of a business object layer, which is considered a good practice. In Struts framework you need to implement your business objects.

8. Struts force your Controllers to extend a Struts class but Spring doesn’t, there are many convenience Controller implementations that you can choose to extend.

2) Explain Servlet life cycle methods ?
Servlet life cycle is managed in these 4 steps and these methods need to be implemented for servlet to perform action.
1. Instantiation : It is done by servlet processor using Class.forName().
2. Initialization: It is done by init();
public void init(ServletConfig config) throws ServletException
3. Servicing the Request/Implementation : This is done by service() method and if you are not implementing service method then it calls doGet() and doPost() and it is depends on type of request.
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
4. Destruction
public void destroy()