Chapter 2. Building the Web Layer with Spring Web MVC

Web application development is a major focus area for enterprise systems. In this age of cloud and big data, web applications are under a tremendous load of an ever-increasing number of concurrent users accessing them from multiple devices such as mobiles and tablets, as well as traditional desktop web browsers. Modern web applications have to address a newer set of nonfunctional requirements, such as scalability, performance, productivity, responsiveness, and multi-device support.

Spring MVC is a web framework from Spring, perfectly built from the ground up to address the concerns of modern web applications. A lightweight and high-performance web framework, Spring MVC is designed to be highly productive from day one, flexible, and adaptable with a wide variety of view technologies. Sitting on top of the mighty Spring Framework, it integrates well with all Java EE technologies and other open source frameworks. Just like any...

Features of Spring MVC

Spring MVC bundles a compelling set of features and advantages over rival web technologies. Knowledge of these will help you decide on choosing Spring MVC for your requirements. The following list covers most of them:

Simple configuration and native integration with Spring Framework, leveraging the powerful features of Spring and other open source libraries
Built on top of Java web technologies such as Servlets, JSP, and JSTL and can be deployed into any standard Servlet container, such as Tomcat
Implemented based on the Model-View-Controller (MVC) architecture pattern, with clear separation of concerns using simple annotations and namespace XML tags
Explicit support for convention over configuration for MVC components
Supports a big set of view technologies, such as JSP, Thymeleaf, Handlebars, Velocity, FreeMarker, PDF, Excel, and JasperReports
Declarative input validation, data binding, and exception handling
Flexible URL mapping with automatic request and response transformation...

The Model-View-Controller pattern

MVC is a well-established architectural pattern popularly used for building interactive web and desktop applications. There are numerous frameworks implementing this pattern in most software platforms. MVC divides the application into three core elements that actually represent layers, separates concerns between these three core elements, and defines how they communicate with each other.

Model represents data, View displays the Model, and Controller handles user actions. Model can be any data, including that stored in a database. It usually represents a collection of domain objects with clearly defined relationships to each other. A Model can be displayed in multiple views depending on how the application is designed.

Controller acts as an intermediary between View and Model. It often has a set of handlers for each event generated by the view as the user interacts with it. Controller delegates user actions to appropriate handlers and then finally redirects...

Your first Spring MVC application

Let's jump to creating a very simple Spring MVC web application. For the purpose of learning, we will develop the web version of Taskify, the task management system we started in Chapter 1, Getting Started with Spring Core. The samples in this chapter use Spring Tool Suite (STS) as the IDE, but you can use your favorite IDE, such as IntelliJ and NetBeans. Almost all Java IDEs support Spring development; most of them have plugins to manage Spring projects and artifacts.

To begin with, follow these steps; then, we will explore the code:

Open STS or Eclipse → create a new project → type a project name → select a template, either Spring MVC Project or Simple Spring Web Maven → specify the top-level package name → finish. Your project structure will be generated.
Make sure your pom.xml file contains Maven dependencies for the spring-context, spring-mvc, servlet-api, jsp-api, and jstl libraries. Note that jsp-api and jstl...

Setting up a Spring MVC application

Let's figure out how a Spring MVC web application is configured by analyzing the application artifacts listed in the previous section, Your first Spring MVC application. It contains all the necessary artifacts for building a Spring MVC web app.

The project structure of a Spring MVC application

The easiest way to create the project structure and the necessary artifacts is using STS to create a Spring MVC project, as described in the previous section. Alternatively, you may use one of the Maven archetypes available in various repositories online. STS uses such a bundled archetype. Here is the typical project structure of a Spring MVC application as viewed in STS:

This structure represents a single-WAR web application where all the services and data access components are collocated with the web controllers. In the case of bigger applications, many such components could be part of a different JAR library project, to be shared between multiple web apps and...

The architecture and components of Spring MVC

Having gone through your first Spring MVC application, it is now time to look at Spring MVC applications from an architectural perspective:

Spring MVC components

As the name implies, Spring MVC follows the renowned MVC architectural pattern. This pattern ensures the separation of concerns by dividing responsibilities into three major roles:

Model: This represents data and business logic
View: This represents presentation
Controller: This processes client requests and delegates them to the view for rendering back to the client

The Model we are talking about here is not necessarily persistent data (a data model) as such; rather, it represents the information passed back and forth between the client and different layers of the server application, which form the building blocks of any system.

Besides the Model, View, and Controller components, DispatcherServlet too plays a crucial role in the Spring MVC architecture. It acts as the Front Controller, a...

Features of Spring MVC

Spring MVC bundles a compelling set of features and advantages over rival web technologies. Knowledge of these will help you decide on choosing Spring MVC for your requirements. The following list covers most of them:

Simple configuration and native integration with Spring Framework, leveraging the powerful features of Spring and other open source libraries
Built on top of Java web technologies such as Servlets, JSP, and JSTL and can be deployed into any standard Servlet container, such as Tomcat
Implemented based on the Model-View-Controller (MVC) architecture pattern, with clear separation of concerns using simple annotations and namespace XML tags
Explicit support for convention over configuration for MVC components
Supports a big set of view technologies, such as JSP, Thymeleaf, Handlebars, Velocity, FreeMarker, PDF, Excel, and JasperReports
Declarative input validation, data binding, and exception handling
Flexible URL mapping with automatic request and response transformation...

The Model-View-Controller pattern

MVC is a well-established architectural pattern popularly used for building interactive web and desktop applications. There are numerous frameworks implementing this pattern in most software platforms. MVC divides the application into three core elements that actually represent layers, separates concerns between these three core elements, and defines how they communicate with each other.

Model represents data, View displays the Model, and Controller handles user actions. Model can be any data, including that stored in a database. It usually represents a collection of domain objects with clearly defined relationships to each other. A Model can be displayed in multiple views depending on how the application is designed.

Controller acts as an intermediary between View and Model. It often has a set of handlers for each event generated by the view as the user interacts with it. Controller delegates user actions to appropriate handlers and then finally redirects...

Your first Spring MVC application

Let's jump to creating a very simple Spring MVC web application. For the purpose of learning, we will develop the web version of Taskify, the task management system we started in Chapter 1, Getting Started with Spring Core. The samples in this chapter use Spring Tool Suite (STS) as the IDE, but you can use your favorite IDE, such as IntelliJ and NetBeans. Almost all Java IDEs support Spring development; most of them have plugins to manage Spring projects and artifacts.

To begin with, follow these steps; then, we will explore the code:

Open STS or Eclipse → create a new project → type a project name → select a template, either Spring MVC Project or Simple Spring Web Maven → specify the top-level package name → finish. Your project structure will be generated.
Make sure your pom.xml file contains Maven dependencies for the spring-context, spring-mvc, servlet-api, jsp-api, and jstl libraries. Note that jsp-api and jstl are required only if you are using JSP as...

Setting up a Spring MVC application

Let's figure out how a Spring MVC web application is configured by analyzing the application artifacts listed in the previous section, Your first Spring MVC application. It contains all the necessary artifacts for building a Spring MVC web app.

The project structure of a Spring MVC application

The easiest way to create the project structure and the necessary artifacts is using STS to create a Spring MVC project, as described in the previous section. Alternatively, you may use one of the Maven archetypes available in various repositories online. STS uses such a bundled archetype. Here is the typical project structure of a Spring MVC application as viewed in STS:

This structure represents a single-WAR web application where all the services and data access components are collocated with the web controllers. In the case of bigger applications, many such components could be part of a different JAR library project, to be shared between multiple web apps and then...

The architecture and components of Spring MVC

Having gone through your first Spring MVC application, it is now time to look at Spring MVC applications from an architectural perspective:

Spring MVC components

As the name implies, Spring MVC follows the renowned MVC architectural pattern. This pattern ensures the separation of concerns by dividing responsibilities into three major roles:

Model: This represents data and business logic
View: This represents presentation
Controller: This processes client requests and delegates them to the view for rendering back to the client

The Model we are talking about here is not necessarily persistent data (a data model) as such; rather, it represents the information passed back and forth between the client and different layers of the server application, which form the building blocks of any system.

Besides the Model, View, and Controller components, DispatcherServlet too plays a crucial role in the Spring MVC architecture. It acts as the Front Controller,...

DispatcherServlet explained

DispatcherServlet is the gateway to any Spring MVC application. Inherited from javax.servlet.http.HttpServlet, it is typically configured declaratively in the web.xml file. While you can have multiple definitions of DispatcherServlet with unique URL patterns, most Spring MVC applications only have single DispatcherServlet with the context-root URL(/), that is, all requests coming to that domain will be handled by DispatcherServlet.

Starting from Servlet 3.0, in addition to declarative configuration in the web.xml file, DispatcherServlet can be configured programmatically by implementing or extending either of these three support classes provided by Spring:

The WebAppInitializer interface
The AbstractDispatcherServletInitializer abstract class
The AbstractAnnotationConfigDispatcherServletInitializer abstract class

The following code listing demonstrates how to implement a WebAppInitializer directly in your application:

public class ApplicationInitializer implements...

Controllers in detail

Controllers, with their methods annotated with @RequestMapping, handle web requests. They accept input data in multiple forms and transform them into Model attributes to be consumed by views that are displayed back to the client. They connect the user to service-layer beans, where your application behavior is defined.

A Controller in Spring MVC has the following signature:

public interface Controller {

   ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

A Controller is designed as an interface, allowing you to create any kind of implementation. Starting from Spring version 2.5, you can turn any class into a Controller just by annotating it with @Controller. It relieves you from implementing any specific interface or extending a framework-specific class:

@Controller
public class HomeController {

   @RequestMapping(value = "/", method = RequestMethod.GET)
   public String home(Model model) {
      logger.info("Welcome...

Asynchronous request processing in Spring MVC

In an age of APIs, AJAX clients, and devices, web servers are under exponentially growing traffic. Figuring out ways to make servers more scalable is an ongoing challenge for server vendors. The traditional one thread per HTTP connection strategy does not scale well for a bigger number of concurrent user access. In this model, every request blocks a thread from the thread pool allocated by the Servlet container until the request is completely processed (the examples shown so far follow this model). When AJAX clients—where a single screen frequently fires multiple concurrent connection requests—join the traditional, blocking I/O model of web servers with long-running processes, servers easily get exhausted due to the thread starvation problem, since no free thread is available in the pool. This makes the application unavailable on increased load.

Asynchronous HTTP request processing is a technique that utilizes the non-blocking I/O capability of...

Working with views

Spring MVC provides a very flexible view resolution mechanism that is fully decoupled from the other elements of the MVC framework. It does not force you to use a particular view technology; rather, it makes it easier to use your own favorite technology. It even allows you to mix and match multiple technologies at the view tier. Spring MVC provides out-of-the-box support for JPS, XSLT, and Velocity views.

Resolving views

In a typical Spring MVC application, the developer chooses a view technology of his choice and accordingly uses a ViewResolver that resolves views built using that technology.

The component responsible for resolving views in a Spring MVC application is org.springframework.web.servlet.ViewResolver. It maps logical view names with physical view resources and the chosen view technology.

All request-handling methods of controllers must resolve a logical view name by either returning a view name, a view object, or a ModelAndView object. The org.springframework...

Spring and Spring form tag libraries

Spring bundles a set of tags for the easier authoring of plain JSP pages and JSP forms, defined in spring.tld and spring-form.tld respectively. spring.tld describes general-purpose JSP tags commonly used in JSP pages, listed in the following table:

Spring tag	Description
`<spring:bind/>`	This allows the data binding of an attribute given in the bind path of a locally declared bean or a `Model` attribute and provides a `BindStatus` object to the enclosed body content.
`<spring:escapeBody/>`	This applies HTML escaping and JavaScript escaping for the body.
`<spring:hasBindErrors/>`	This provides an error instance if there are bind errors.
`<spring:htmlEscape/>`	This sets an HTML escape value for the current JSP page.
`<spring:message/>`	This displays a message for a given code, usually resolved from a resource bundle.
`<spring:nestedPath/>`	This sets a nested path of `ModelAttribute` to the `<spring:bind/>`...

Composing a form in JSP

Spring forms can be composed in JSP pages using the <spring> and <form> tags. For the purpose of illustration, let's take a look at a JSP form that uses both the Spring and form tag libraries along with JSTL. The following is a stripped-down version of views/task/new.jsp:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
...
<form:form action="new" method="post" commandName="task">
  <spring:bind path="name">
    <div class="form-group${status.error ? ' has-error' : ''}">
      <label for="txtTaskName">Task-name</label>
      <form:input path="name" class="form-control" id="txtTaskName" placeholder="Task Name" />
      <form:errors path="name" cssClass="control-label" />
    </div>
  </spring:bind>
  <div class="form-group...