Spring MVC with JSP View

Last Updated : 28 Mar, 2019

Spring MVC architecture uses the “FrontController” design pattern which is fundamental to any MVC design implementation. The DispatcherServlet is at the heart of this design whereby HTTP requests are delegated to the controller, views are resolved to the underlying view technology, in addition to providing support for uploading files. The DispatcherServlet like any regular servlet can be configured along with custom handler mappings.

Spring MVC framework enables separation of modules namely Model, View, and Control and seamlessly handles the application integration. This enables the developer to create complex applications also using plain java classes. The model object can be passed between view and controller using Maps. Additionally, validation for types mismatch and two-way data-binding support in the user interface is provided. Easy form-submission and data-binding in the user interface are possible with spring form tags, model objects, and annotations.

The article discusses the steps involved in developing a Spring web MVC application, explaining the initial project setup for an MVC application in Spring. JSP(Java Server Pages) is used as a view technology.

The following are the dependencies for Spring web MVC. While spring-web MVC jar would suffice for all container requirements to develop the MVC application, JSTL-jar is included for JSP:
Dependencies within pom.xml

<dependency> 
                <groupId>org.springframework</groupId> 
                <artifactId>spring-webmvc</artifactId> 
                <version>4.3.7</version> 
            </dependency> 
             <dependency> 
                <groupId>jstl</groupId> 
                <artifactId>jstl</artifactId> 
                <version>1.2</version> 
            </dependency>  
            <dependency> 
                <groupId>javax.servlet</groupId> 
                <artifactId>javax.servlet-api</artifactId> 
                <version>3.0.1</version> 
                <scope>provided</scope> 
            </dependency> 

The DispatcherServlet would be configured in web.xml as follows. The listener class ContextLoaderListener would load the root application context and transfer the handle to dispatcher servlet mentioned in the servlet-mapping element. All requests corresponding to the ‘/’ URL mapping would be handled by this dispatcher servlet.
web.xml

<web-app> 
  <display-name>SampleMVC</display-name> 
  <listener> 
  <listener-class>org.springframework.web.context.ContextLoaderListener 
  </listener-class> 
  </listener> 
<context-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value>/WEB-INF/mvc-dispatcher-servlet.xml</param-value> 
</context-param> 
    
<servlet> 
<servlet-name>mvc-dispatcher</servlet-name> 
<servlet-class>org.springframework.web.servlet.DispatcherServlet 
</servlet-class> 
<load-on-startup>1</load-on-startup> 
</servlet> 
  
    <servlet-mapping> 
       <servlet-name>mvc-dispatcher</servlet-name> 
        <url-pattern>/</url-pattern> 
    </servlet-mapping> 
    
  
      <welcome-file-list> 
      <welcome-file> 
      /index.html 
      </welcome-file> 
      </welcome-file-list> 

The related WebApplicationContext for a dispatcher servlet can be found in the default location ‘servletName’-servlet.xml using the context-param contextConfigLocation. The WebApplicationContext contains the MVC-specific configurations including view-resolvers, datasource, messagesource, multipart-resolver (file-upload), etc.

WEB-INF/mvc-dispatcher-servlet.xml

          
        <context:component-scan base-package="com.springsamples*"/> 
      <mvc:annotation-driven/>     
  <!--  this will render home page from index.html-->     
      <mvc:default-servlet-handler/> 
      
          
     <bean id = "viewProvider" 
class = "org.springframework.web.servlet.view.InternalResourceViewResolver"> 
        <property name = "prefix" value = "/"/> 
        <property name = "suffix" value = ".jsp"/> 
           
        </bean>    

In the above XML, the element component-scan with context namespace will scan all the component classes for annotations(@Component, @Configuration, @Service, @Repository, @Autowired) in the base packages and also initialize the beans. The element annotation-driven within the MVC namespace will scan and initialize @Controller annotated components.
The element default-servlet-handler, within MVC namespace, extends the default HTTP dispatcher servlet to also serve requests for static resources located in the web-root.

We have also initialized a bean with id ‘viewProvider’ for rendering .jsp pages. The class InternalResourceViewResolver would accept the prefix and suffix parameters to construct the path to view page. For example, if the controller class returned a view named as ‘greet’ then the view-resolver class would identify the path relative to web-root as “/greet.jsp” by appending the given suffix and prefix strings.

Finally, the .jsp file which will be the view. We are sending an attribute from controller class to the view which will be displayed upon hitting the matching URL.

greet.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1" isELIgnored="false" %> 
<!DOCTYPE html PUBLIC "-// W3C// DTD HTML 4.01  
 Transitional// EN" "http:// www.w3.org/TR/html4/loose.dtd"> 
<html> 
<head> 
<meta http-equiv="Content-Type" content="text/html;  
 charset=ISO-8859-1"> 
<title>Start Spring MVC</title> 
</head> 
<body> 
<h1>Start here</h1> 
${greeting} 
</body> 
</html> 

The controller class code as follows.

@GetMapping(value = "/") 
public ModelAndView firstView() 
{ 
    ModelAndView mav = new ModelAndView("greet");  
   // must match the jsp page name which is being requested. 
    mav.addObject("greeting", "GeeksForGeeks Welcomes you to Spring!"); 
    return mav; 
} 