Learn to Spring MVC Framework Tutorial with Simple Example

Model view controller is a software architecture design pattern.  It provides solution to layer an application by separating three concerns business, presentation and control flow.

• The Model can be some DAO layer or some Service Layers which give some information about request or requested information or Model can be a POJO which encapsulates the application data given by the controller.
• The View is responsible for rendering the model data and in general it generates HTML output that the client's browser can interpret.
• The Controller is responsible for processing user requests and building appropriate model and passes it to the view for rendering.

Popular Tutorials

• Spring Tutorial
• Spring Boot Tutorial
• Spring Security Tutorial
• Spring AOP Tutorial
• Spring JDBC Tutorial
• Spring HATEOAS
• Microservices with Spring Boot
• REST Webservice
• Core Java
• Hibernate Tutorial
• Spring Batch

Advantages of Spring MVC Framework-

• Supports RESTful URLs.
• Annotation based configuration(i.e. you may reduce the metadata file or less of configuration).
• Supports to plug with other MVC frameworks like Struts, Struts2, WebWorks etc.
• Flexible in supporting different view types like JSP, velocity, XML, PDF, Tiles etc.
  

Front Controller: Front Controller is very important component one which route the all the requests into framework control that means when ever requests land on different controllers it queues that request to the controller of framework without this MVC framework will not may be able to take control of the request at landing at the application. So front controller is not only capture the request but also the following responsibility-

• It initialize the framework to cater to the requests.
• Load the map of all URLs and the components responsible to handle the request.
• Prepare the map for the views.  

Spring 3 MVC Basic Architecture:
The Spring web MVC framework provides model-view-controller architecture and ready components that can be used to develop flexible and loosely coupled web applications. The MVC pattern results in separating the different aspects of the application (input logic, business logic, and UI logic), while providing a loose coupling between these elements.

In Spring 3 MVC framework Dispatcher Servlet access Front Controller which handles all coming requests and queses for forward to the different controller. 
1. Whenever request lands the dispatcher servlet consult with HandlerMapping 
(HandlerMapping- is a component which have the map of URL and Controller which need to be invoked for that particular request which lands with URL) 
2. then Dispatcher servlet has information about which is controller need to be invoked 
3. then that controller will be invoked 
4. and Controller can request the model for some information (about some DAO, Service layer or Data in POJO, or data in database using business logic) 
5. once process has been done then dispatcher servlet get the response then dispatcher servlet will get view resolver to build the view and view resolver look out what view has being configured it has been JSP, Velocity, XML etc. based this configuratin view has been prepared and the information from model i.e. POJO it will be put on the view and response will be send back to browser.

 Spring 3 MVC Request Flow:
1. Request lands to Front Controller i.e. DispatcherServlet
2. Capture the Request Locale i.e use for internationalization i.e Read .properties files
3. Check for multipart-file(MIME type header or not) upload data from distributed application
4. Consult with HandlerMapping for which Controller to be invoked
5. and Then responsibility is given to the Handler Chain
6. This Handler Chain is responsible to be invoked some of the interceptors that needs to be invoked before of a controller and after the controller that means interceptors are here like very to similar to the filters that help to separate the pre-process logic and post-process logic.
7. After process of pre-process interceptor return to the controller process the post-process logic.
8. Then return to the view resolver prepared the view based on your configuration decide the which configuration (JSP, Velocity, PDF etc.) to be invoked.
9. After choosing view technology prepare the view and return the response back to the client. 

 Spring 3 MVC Framework- Initialization:

MultipartResolver: Interface to handle the file uploads
LocaleResolver: Helps to resolve the locale from the request
ThemeResolver: Resolve a theme for a request(CSS)
HandlerMapping: Maps the Request to Handlers (Controllers)
HandlerAdapter: Plugs the other frameworks handlers
HandlerExceptionResolver: Mapping of the exceptions to handlers and views
ViewResolver: Maps the view names to view instances

All the above mentioned components ie. HandlerMapping, Controller and ViewResolver are parts of WebApplicationContext which is an extension of the plain ApplicationContext with some extra features necessary for web applications.

Required Spring 3.0 MVC Configuration:

You need to map requests that you want the DispatcherServlet to handle, by using a URL mapping in the web.xml file. The following is an example to show declaration and mapping for spring3 DispatcherServlet example:

<web-app id="WebApp_ID" version="2.4" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/j2ee" xsi:schemalocation="http://java.sun.com/xml/ns/j2ee 
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 
    <display-name>Spring MVC Application</display-name>

   <servlet>
      <servlet-name>spring3</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>spring3</servlet-name>
      <url-pattern>*.*</url-pattern>
   </servlet-mapping>

</web-app>

<web-app id="WebApp_ID" version="2.4" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/j2ee" xsi:schemalocation="http://java.sun.com/xml/ns/j2ee 
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 
    <display-name>Spring MVC Application</display-name>

   <servlet>
      <servlet-name>spring3</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>spring3</servlet-name>
      <url-pattern>*.*</url-pattern>
   </servlet-mapping>

   <context-param>
      <param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring3-servlet.xml</param-value></context-param>
   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
    </listener>
</web-app>

<beans xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemalocation="
   http://www.springframework.org/schema/beans     
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package="com.dineshonjava">
   </context:component-scan>
   <context:annotation-config></context:annotation-config>
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name="prefix" value="/WEB-INF/jsp/"></property>
      <property name="suffix" value=".jsp"></property>
   </bean>

</beans>

• The [servlet-name]-servlet.xml file will be used to create the beans defined, overriding the definitions of any beans defined with the same name in the global scope.
• The <context:component-scan...> tag will be use to activate Spring MVC annotation scanning capability which allows to make use of annotations like @Controller and @RequestMapping etc.
• The InternalResourceViewResolver will have rules defined to resolve the view names. As per the above defined rule, a logical view named hello is delegated to a view implementation located at /WEB-INF/jsp/hello.jsp .

•  Used at the class level
• Tells the spring framework that the marked class acts as a controller.

@Controller
public class EmployeeController{

}

• Can be used at the class level and method level in controllers.
• Arguments:-
     -URL[]
     -HTTP Methods[]-GET, POST, DELETE, TRACE, OPTIONS, HEAD, PUTS. Defaults method supported is GET
     -params[]-used to check if a request parameter matches with a value and only if the conditions passes the method or controller processes the request.
  (eg. @RequestMapping params="myName=guest" )
  -headers[]-used to check if a request header matches with a value and only if the condition passes the method or controller processes the request
  (eg. @RequestMapping headers="myheader=guestHadder")

Defining a Controller