Hello World App with Spring Framework 4 & Maven 3 - Part II - 2020

The Spring Web model-view-controller (MVC) framework is designed around a DispatcherServlet that handles all the HTTP requests and responses. The request processing workflow of the Spring Web MVC DispatcherServlet looks like the following diagram:

Following is the sequence of events corresponding to an incoming HTTP request to DispatcherServlet:

1. After receiving an HTTP request, DispatcherServlet consults the HandlerMapping to call the appropriate Controller.
2. The Controller takes the request and calls the appropriate service methods based on used GET or POST method. The service method will set model data based on defined business logic and returns view name to the DispatcherServlet.
3. The DispatcherServlet will take help from ViewResolver to pickup the defined view for the request.
4. Once view is finalized, The DispatcherServlet passes the model data to the view which is finally rendered on the browser.

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

We need a configuration file that holds the spring configuration information. In this tutorial we will be using the Spring's auto scan feature (annotation) to detect and initialize beans. We name this configuration file as dispatcher-servlet.xml, and put this file inside the WEB-INF folder.

dispatcher-servlet.xml:

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 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.bogotobogo.spring.controller" />
 
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
   <property name="prefix">
     <value>/WEB-INF/views/</value>
   </property>
   <property name="suffix">
     <value>.jsp</value>
   </property>
 </bean>
</beans>

We're telling Spring to look at the package com.bogotobogo.spring.controller for the beans and the framework that all views are kept under WEB-INF/views folder.

Now we want to configure the web app so that it uses Spring's DispatcherServlet as the Front Controller.

web.xml:

<!DOCTYPE web-app PUBLIC
  "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app id="WebApp_ID" version="2.4"
  xmlns="http://java.sun.com/xml/ns/j2ee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
  http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 
  <display-name>Archetype Created Web Application</display-name>
 
  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>
      org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
 
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
  </context-param>
 
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
</web-app>

The Spring framework will look for a file (servletname-servlet.xml) to load the Spring MVC configurations. In our case, it will be dispatcher-servlet.xml.

We will use annotations to mark our class as a controller in the standard MVC design. The HelloWorldController just echoes a message after it takes a parameter.