In this section, we will learn the key elements of the Spring Web model-view-controller (Spring Web MVC) framework, and how to quickly get started with a Spring web application using the Spring Web MVC components. The following will be covered in detail in this section:
- Key building blocks of a Spring Web MVC application
- Introduction to the Dispatcher servlet
In this section, we will learn about the key building blocks of a Spring web MVC application. The following diagram represents the key building blocks:
Figure 2: Key building blocks of Spring web MVC framework
The following are the details in relation to the preceding diagram:
- Dispatcher servlet: Dispatcher servlet, also termed the front controller, is at the core of the Spring Web MVC framework. Simply speaking, the Dispatcher servlet determines which
controllerclass and method needs to be called when a page request or an API request arrives. In addition, it sends the response using the appropriate JSP page or JSON/XML objects. It dispatches the incoming requests to the appropriate handlers (custom controllers) with different handler mappings. This is integrated with the Spring IOC container, which allows it to use all the features that the Spring framework provides. - Handler Mappings: Handler mappings are used to map the request URL with the appropriate handlers such as controllers. The Dispatcher servlet uses the handler mappings to determine the controllers which will process the incoming requests. The handler mappings are specified in the XML file, or as annotations such as
@RequestMapping,@GetMapping, or@PostMapping, and so on. The following diagram represents the@RequestMappingannotation that is used for URL mapping. - Handler Interceptors: Handler interceptors are used to invoke preprocessing and post-processing logic before and after the invocation of the actual handler method respectively.
- Controllers: These are custom controllers created by the developers and used for processing the incoming requests. The controllers are tagged with annotations such as
@Controlleror@RestController. Controllers are used to access the application behavior through one or more service interfaces. Controllers are used to interpret the user input, pass them to the services for implementation of business logic, and transform the service output into a model which is presented to the user as a view. The following diagram shows the@Controllerannotation which represents theDemoApplicationclass to play the role of a controller:
Figure 3: Representing handler mappings (URL mapping) and Controller annotation
- Services: These are the components coded by the developers. These components contain the business logic. One or more methods of services are invoked from within the
Controllermethods. Spring provides annotations such as@Servicefor identifying services. The following code represents the service classUserService, which consists of a method,getUsername. Pay attention to the@Serviceannotation. Note how the instance ofUserServiceis defined in@Controller, as shown in the preceding code, and the methodgetUsernameis invoked on the instance ofUserService.
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.services.dao.UserDAO;
import com.services.domain.User;
@Service ("userService")
public class UserService {
@Autowired
private UserDAO userDAO;
public String getUsername(User user) {
return userDAO.getUsername(user);
}
}- Data Access Objects (DAO): The classes which represent DOA, are used to do data processing with the underlying data sources. These classes are annotated with annotations such as
@Repository. The preceding code ofUserServiceconsists, a DAO, namely,UserDAO. Note the@Repositoryannotation used by the class,UserDAO, in the following code:
import org.springframework.stereotype.Repository;
import com.services.domain.User;
@Repository ("userDAO")
public class UserDAO {
public String getUsername(User user) {
return "Albert Einstein";
}
}- View Resolvers: View resolvers are components which map view names to views. They help in rendering models in the browser based on different view technologies such as JSP, FreeMarker, JasperResports, Tiles, Velocity, XML, and so on. Spring comes with different view resolvers such as
InternalResourceViewResolver,ResourceBundleViewResolver,XMLViewResolver, and others. View resolvers are used by the Dispatcher servlet to invoke the appropriate view components. - Views: Views are used to render the response data on the UI. They can be represented using different technologies such as JSP, Velocity, Tiles, and so on.
In this section, we will learn about the core component of a Spring web MVC application, the Dispatcher servlet.
As introduced in the previous section, Dispatcher servlet is the front controller which processes the user requests by invoking the appropriate components such as handler mappings, interceptors, adapters, custom controllers, services, DOA, view resolver, and finally, the views. The following diagram represents the web request/response workflow of the Dispatcher servlet:
Figure 4: Web request/response flow across the Dispatcher servlet
As per the preceding diagram, the journey of a request/response through a Spring web MVC application looks like the following:
- The user requests arrive at the server, and are intercepted by the Dispatcher servlet.
- The Dispatcher servlet gets a handler object (primarily, an instance of
HandlerExecutionChain) from theHandlerMappingobject based on the URL mapping. URL mappings can be defined with theweb.xmlfile or as annotations on the Controllers' methods.
- One or more instances of the
HandlerInterceptorobjects are retrieved from the handler object, and preprocessing logic is processed on the request object. - The instance of
HandlerAdapteris retrieved from the handler object, and thehandlemethod is invoked. This results in execution of logic within thecontrollerclass. In the preceding diagram (Figure 3), the request withRequestMappingas "/" leads to the execution of code within thehomemethod as part of this step. - The post-processing logic on the
HandlerInterceptorinstances is executed. This is the final step before therenderingmethod is invoked. - The
ViewResolverinstance is used to retrieve the appropriate view component. - The
rendermethod is invoked on the instance of view.