Spring Web MVC（一）

朱雀 2021-10-01 07:58 248阅读 0赞

*  概述
    
     *  Spring Web MVC框架的特点
     *  编程步骤
 *  五大核心组件
    
     *  DispatcherServlet(前端控制器)
        
         *  WebApplicationContext中特殊的bean
         *  处理过程
     *  HandlerMapping (处理映射)
        
         *  Spring中最常用的两个处理器映射
         *  BeanNameUrlHandlerMapping
         *  SimpleUrlHandlerMapping
         *  拦截器（HandlerInterceptor）

# 概述 #

Spring的web框架围绕DispatcherServlet设计。 DispatcherServlet的作用是将请求分发到不同的处理器。 Spring的web框架包括可配置的处理器（handler）映射、视图（view）解析、本地化（local）解析、 主题（theme）解析以及对文件上传的支持。Spring的Web框架中缺省的处理器是Controller 接口，这是一个非常简单的接口，仅包含ModelAndView handleRequest(request, response) 方法。可以通过实现这个接口来创建自己的控制器（也可以称之为处理器），但是更推荐继承Spring提供的一系列控制器， 比如AbstractController、AbstractCommandController 和SimpleFormController。

## Spring Web MVC框架的特点 ##

Spring的web模块提供了大量独特的功能，包括:

*  **清晰的角色划分**：控制器（controller）、验证器（validator）、 命令对象（command object）、表单对象（form object）、模型对象（model object）、 Servlet分发器（DispatcherServlet）、 处理器映射（handler mapping）、视图解析器（view resolver）等等。 每一个角色都可以由一个专门的对象来实现。
 *  **强大而直接的配置方式**：将框架类和应用程序类都能作为JavaBean配置，支持跨多个context的引用，例如，在web控制器中对业务对象和验证器（validator）的引用。
 *  **可适配、非侵入**：可以根据不同的应用场景，选择合适的控制器子类 （simple型、command型、form型、wizard型、multi-action型或者自定义），而不是从单一控制器 （比如Action/ActionForm）继承。
 *  **可重用的业务代码**：可以使用现有的业务对象作为命令或表单对象，而不需要去扩展某个特定框架的基类。
 *  **可定制的绑定（binding） 和验证（validation）**：比如将类型不匹配作为应用级的验证错误， 这可以保存错误的值。再比如本地化的日期和数字绑定等等。在其他某些框架中，你只能使用字符串表单对象， 需要手动解析它并转换到业务对象。
 *  **可定制的handler mapping和view resolution**：Spring提供从最简单的URL映射， 到复杂的、专用的定制策略。与某些web MVC框架强制开发人员使用单一特定技术相比，Spring显得更加灵活。
 *  **灵活的model转换**：在Springweb框架中，使用基于Map的 键/值对来达到轻易地与各种视图技术的集成。
 *  **可定制的本地化和主题（theme）解析**：支持在JSP中可选择地使用Spring标签库、支持JSTL、支持Velocity（不需要额外的中间层）等等。
 *  **简单而强大的JSP标签库**（Spring Tag Library）：支持包括诸如数据绑定和主题（theme） 之类的许多功能。它提供在标记方面的最大灵活性。如欲了解详情，请参阅附录附录 D, spring.tld
 *  **Spring Bean的生命周期可以被限制在当前的HTTP Request或者HTTP Session**。 准确的说，这并非Spring MVC框架本身特性，而应归属于Sping MVC使用的WebApplicationContext容器。
    
    ## 五大核心组件 ##
 *  DispatcherServlet (前端控制器)
 *  HandlerMapping (处理映射)
 *  Controller (处理器)
 *  ModelAndView (处理结果)
 *  ViewResolver (视图解析器)

1.  请求先发送给DispatcherServlet,DispatcherServlet会 依据HandlerMapping的指示调用对应的Controller来处理。
2.  Controller将处理结果封装成ModelAndView并返回给 DispatcherServlet。
3.  DispatcherServlet会依据ViewResolver的解析，调用对应的 视图对象(比如jsp)，生成最终的页面。

**过程如下图**  
![这里写图片描述][SouthEast]

## 编程步骤 ##

1.  　　**导包**
2.  　　添加spring配置文件(空白的配置文件)
3.  　　配置DispatcherServlet(web.xml)
4.  　　写Controller(业务逻辑)
5.  　　写jsp
6.  　　在spring配置文件当中，添加HandlerMapping, ViewResolver的配置信息。

**注意：**

a. 不用实现Controller接口。

b. 可以添加多个处理方法。

c. 处理方法的名称可以自定义，方法的返回值可以是  
ModelAndView,也可以是String。

d. 在类名前，添加 @Controller注解。

e. 可以在类名前或者处理方法前面添加 @RequestMapping注解。  
该注解的作用相当于HandleMapping。  
step5. 写jsp。  
step6. 在spring配置文件当中，添加ViewResolver的配置信息。  
注意：添加组件扫描(component-scan base-package)。  
添加mvc注解扫描(annotation-driven)。  
**spring配置文件**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context" 
        xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
        xmlns:jee="http://www.springframework.org/schema/jee" 
        xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:aop="http://www.springframework.org/schema/aop" 
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:util="http://www.springframework.org/schema/util"
        xmlns:jpa="http://www.springframework.org/schema/data/jpa"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
            http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
        
        
        <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
            <property name="mappings">
                <props>
                    <prop key="/hello.do">helloController</prop>
                </props>
            </property>
        </bean>
        
        <bean id="helloController" 
        class="controller.HelloController"/>
        
         <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/"/>
            <property name="suffix" value=".jsp"/>
         </bean>
    </beans>

**web.xml文件**

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
      <servlet>
        <servlet-name>action</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:app.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>action</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
      
    </web-app>

# 五大核心组件 #

## DispatcherServlet(前端控制器) ##

Spring Web MVC DispatcherServlet处理请求的流程

![这里写图片描述][SouthEast 1]

DispatcherServlet实际上是一个Servlet （它继承了HttpServlet）。与其它Servlet一样， DispatcherServlet定义在web应用的web.xml文件中。 DispatcherServlet处理的请求必须在同一个**web.xml**文件里使用**url-mapping**定义映射。

<web-app>
    
        <servlet>
            <servlet-name>example</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <load-on-startup>1</load-on-startup>
        </servlet>
    
        <servlet-mapping>
            <servlet-name>example</servlet-name>
            <url-pattern>*.do</url-pattern>
        </servlet-mapping>
    
    </web-app>

在上面的例子里，所有以.do结尾的请求都会由名为 example的DispatcherServlet处理。这只是配置Spring Web MVC 的第一步。接下来需要配置DispatcherServlet本身和Spring Web MVC 框架用到的其他的bean。  
　　**注意：**  
　　　默认情况下，如果没有配置contextConfigLocation(即没有指定spring配置文件的位置)，在DispatcherServlet的初始化过程中，框架会在web应用的 WEB-INF文件夹下寻找名为\[servlet-name\]-servlet.xml 的配置文件，生成文件中定义的bean。这些bean会覆盖在全局范围（global cope）中定义的同名的bean。

> 　在web MVC框架中，**每个 DispatcherServlet有它自己的WebApplicationContext** ，这个context继承了根 WebApplicationContext 的所有bean定义。这些继承的bean也可以在每个serlvet自己的所属的域中被覆盖（override），覆盖后的bean 可以被设置成只有这个servlet实例自己才可以使用的属性。

> 　　Spring的DispatcherServlet有一组特殊的bean， 用来**处理请求和渲染相应的视图**。这些bean包含在Spring的框架里，可以在 **WebApplicationContext中配置**，配置方式与配置其它bean相同。

### WebApplicationContext中特殊的bean ###

<table> 
 <thead> 
  <tr> 
   <th>Bean类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>控制器（Controllers）</td> 
   <td>控制器 实现的是MVC中的C</td> 
  </tr> 
  <tr> 
   <td>处理器映射（Handler mapping）</td> 
   <td>处理器映射包含预处理器（pre-processor）， 后置处理器（post-processor）和控制器的列表，它们在符合某种条件时才被执行（例如符合控制器指定的URL）。</td> 
  </tr> 
  <tr> 
   <td>处理器映射（Handler mapping）</td> 
   <td>视图解析器 可以将视图名解析为对应的视图。</td> 
  </tr> 
  <tr> 
   <td>本地化解析器（Locale resolver）</td> 
   <td>视图解析器 可以将视图名解析为对应的视图。</td> 
  </tr> 
  <tr> 
   <td>主题解析器（Theme resolver）</td> 
   <td>主题解析器能够解析你的web应用所使用的主题，以提供个性化的布局。</td> 
  </tr> 
  <tr> 
   <td>文件上传解析器（Multipart File resolver）</td> 
   <td>文件上传解析器提供HTML表单文件上传功能</td> 
  </tr> 
  <tr> 
   <td>处理器异常解析器(Handler exception resolver(s))</td> 
   <td>处理器异常解析器可以将异常对应到视图，或者实现更加复杂的异常处理逻辑。</td> 
  </tr> 
 </tbody> 
</table>

### 处理过程 ###

DispatcherServlet配置完成后，当相应的请求到达时，处理就开始了。 下面的列表描述了**DispatcherServlet处理请求的全过程**：

*  **找到WebApplicationContext并将其绑定到请求的一个属性**上， 以便控制器和处理链上的其它处理器能使用WebApplicationContext。 默认的属性名为DispatcherServlet.WEB\_APPLICATION\_CONTEXT\_ATTRIBUTE。
 *  **将本地化解析器（localResolver）绑定到请求上**，这样使得处理链上的处理器在处理请求（准备数据、显示视图等等） 时能进行本地化处理。若不使用本地化解析器，也不会有任何副作用，因此如果不需要本地化解析，忽略它即可。
 *  **将主题解析器绑定到请求上**，这样视图可以决定使用哪个主题。如果你不需要主题，可以忽略它，不会有任何影响。
 *  如果**上传文件解析器**被指定，Spring会检查每个接收到的请求是否存在上传文件，如果存在， 这个请求将被封装成MultipartHttpServletRequest以便被处理链中的其它处理器使用
 *  找到合适的处理器，**执行和这个处理器相关的执行链**（预处理器，后置处理器，控制器），以便为视图准备模型数据（用于渲染）。
 *  如果模型数据被返回，就**使用配置在WebApplicationContext中的视图解析器显示视图**， 否则视图不会被显示。有多种原因可以导致返回的数据模型为空，比如预处理器或后处理器可能截取了请求，这可能是出于安全原因， 也可能是请求已经被处理，没有必要再处理一次。

**请求处理过程中抛出的异常**，可以被任何定义在WebApplicationContext中的**异常解析器所获取**。 使用这些异常解析器，可以在异常抛出时根据需要定义特定行为。

Spring的DispatcherServlet也支持返回Servlet API定义的**last-modification-date**。  
　　决定**某个请求的最后修改日期**很简单：

DispatcherServlet会首先寻找一个合适的handler mapping，检查从中取得指定的处理器是否实现了 LastModified接口，如果是，将调用long getLastModified(request)方法，并将结果返回给客户端。

## HandlerMapping (处理映射) ##

**通过处理器映射，可以将web请求映射到正确的处理器（handler）上。**  
　　HandlerMapping的**基本功能**是将请求传递到HandlerExecutionChain上。

*  　　首先，这个HandlerExecutionChain必须包含一个能处理该请求的处理器。
 *  　　其次，这个链也可以包含一系列可以拦截请求的拦截器。

当收到请求时，DispatcherServlet将请求交给处理器映射，让它检查请求并找到一个适当的HandlerExecutionChain。 然后，DispatcherServlet执行定义在链中的**处理器和拦截器**（interceptor）。  
　　在处理器映射中通过**配置拦截器**（包括**处理器执行前、执行后、或者执行前后运行拦截器**）将使其功能更强大。 同时也可以通过自定义HandlerMapping来支持更多的功能。

比如如下例子：一个自定义的处理器映射不仅可以根据请求的URL，而且还可以根据和请求相关的特定session状态来选择处理器。

### Spring中最常用的两个处理器映射 ###

它们都是AbstractHandlerMapping的子类，同时继承了下面这些属性：

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>interceptors</td> 
   <td>在映射中使用的拦截器列表（拦截器（HandlerInterceptor））</td> 
  </tr> 
  <tr> 
   <td>defaultHandler</td> 
   <td>缺省的处理器。 当没有合适的处理器可以匹配请求时，该处理器就会被使用。</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>根据每个映射的order属性值 (由org.springframework.core.Ordered 接口定义)，Spring 将上下文中可用的映射进行排序，然后选用第一个和请求匹配的处理器。</td> 
  </tr> 
  <tr> 
   <td>alwaysUseFullPath</td> 
   <td>如果这个属性被设成true，Spring 将会使用绝对路径在当前的servlet context中寻找合适的处理器。 这个属性的默认值是false，在这种情况下，Spring会使用当前servlet context中的相对路径。</td> 
  </tr> 
  <tr> 
   <td>urlDecode</td> 
   <td>这个属性的默认值是true。 如果想比较编码后的路径，可以把这个属性设为false。 不过，需要注意的是，HttpServletRequest总是返回解码后的servlet路径， 与编码后的格式进行比较时可能不会匹配。</td> 
  </tr> 
  <tr> 
   <td>lazyInitHandlers</td> 
   <td>这个属性允许设置是否延迟singleton处理器的初始化工作（prototype处理器的初始化都是延迟的)。 这个属性的默认值是false。</td> 
  </tr> 
 </tbody> 
</table>

**注意：**  
　　最后三个属性只有org.springframework.web.servlet.handler.AbstractUrlHandlerMapping的子类才有。

### BeanNameUrlHandlerMapping ###

BeanNameUrlHandlerMapping是一个简单但很强大的处理器映射，它将**收到的HTTP请求映射到bean的名称**（这些bean需要在web应用上下文中定义）。

当使用BeanNameUrlHandlerMapping时，我们用如下方式将包含http://samples.com/editaccount.form的访问请求映射到指定的FormController上：

所有对/editaccount.form的请求就会由上面的FormController处理。 当然我们得在web.xml中定义servlet-mapping，接受所有以.form结尾的请求。

**注意**  
　　要使用BeanNameUrlHandlerMapping，无须（如上所示）在web应用上下文中定义它。 **缺省情况下**，如果在上下文中没有找到处理器映射，DispatcherServlet会为你创建一个**BeanNameUrlHandlerMapping**！

### SimpleUrlHandlerMapping ###

它在**应用上下文中可以进行配置，并且有Ant风格的路径匹配功能。**  
　　例子：

<web-app>
        ...
        <servlet>
            <servlet-name>sample</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <load-on-startup>1</load-on-startup>
        </servlet>
    
        
        <servlet-mapping>
            <servlet-name>sample</servlet-name>
            <url-pattern>*.form</url-pattern>
        </servlet-mapping>
    
        
        <servlet-mapping>
            <servlet-name>sample</servlet-name>
            <url-pattern>*.html</url-pattern>
        </servlet-mapping>
        ...
    </web-app>

上面的web.xml设置允许所有以.html和.form结尾的请求都由这个sample DispatcherServlet处理。

<beans>
            
        
        <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
            <property name="mappings">
                <value>
                    /*/account.form=editAccountFormController
                    /*/editaccount.form=editAccountFormController
                    /ex/view*.html=helpController
                    /**/help.html=helpController
                </value>
            </property>
        </bean>
    
        <bean id="helpController"
              class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>
    
        <bean id="editAccountFormController"
              class="org.springframework.web.servlet.mvc.SimpleFormController">
            <property name="formView" value="account"/>
            <property name="successView" value="account-created"/>
            <property name="commandName" value="Account"/>
            <property name="commandClass" value="samples.Account"/>
        </bean>
    <beans>

这个处理器映射首先将对所有目录中文件名为help.html的请求传递给helpController。 helpController是一个UrlFilenameViewController。 对ex目录中所有以view开始，以.html 结尾的请求都会被传递给helpController。 同样的，我们也为editAccountFormController定义了两个映射。

### 拦截器（HandlerInterceptor） ###

Spring的**处理器映射支持拦截器**。  
　　处理器映射中的拦截器必须实现org.springframework.web.servlet包中的HandlerInterceptor接口。 这个接口定义了三个方法，

*  一个在处理器执行前被调用，
 *  一个在处理器执行后被调用，
 *  一个在整个请求处理完后调用。  
    　　这三个方法提供你足够的灵活度做任何处理前后的操作。

**preHandle(..)方法**有一个**boolean返回值**。 使用这个值，可以调整执行链的行为。  
　　当返回**true时**，处理器执行链将继续执行；  
　　当返回**false时**，DispatcherServlet认为该拦截器已经处理完了请求（比如显示正确的视图），而不继续执行执行链中的其它拦截器和处理器。

例子：  
　　下面提供了一个拦截器，它拦截所有请求，如果当前时间不是在上午9点到下午6点，它将用户重定向到某个页面。

<beans>
        <bean id="handlerMapping"
              class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
            <property name="interceptors">
                <list>
                    <ref bean="officeHoursInterceptor"/>
                </list>
            </property>
            <property name="mappings">
                <value>
                    /*.form=editAccountFormController
                    /*.view=editAccountFormController
                </value>
            </property>
        </bean>
    
        <bean id="officeHoursInterceptor"
              class="samples.TimeBasedAccessInterceptor">
            <property name="openingTime" value="9"/>
            <property name="closingTime" value="18"/>
        </bean>
    <beans>

package samples;
    
    public class TimeBasedAccessInterceptor extends HandlerInterceptorAdapter {
    
        private int openingTime;
        private int closingTime;
    
        public void setOpeningTime(int openingTime) {
            this.openingTime = openingTime;
        }
    
        public void setClosingTime(int closingTime) {
            this.closingTime = closingTime;
        }
    
        public boolean preHandle(
                HttpServletRequest request,
                HttpServletResponse response,
                Object handler) throws Exception {
    
            Calendar cal = Calendar.getInstance();
            int hour = cal.get(HOUR_OF_DAY);
            if (openingTime <= hour < closingTime) {
                return true;
            } else {
                response.sendRedirect("http://host.com/outsideOfficeHours.html");
                return false;
            }
        }
    }

所有的请求都将被TimeBasedAccessInterceptor截获， 如果当前时间不在上班时间，用户会被重定向到一个静态html页面，提供诸如只有上班时间才能访问网站之类的告示。

Spring还提供了一个adapter类HandlerInterceptorAdapter让用户更方便的扩展HandlerInterceptor接口。

**拦截器和过滤器**比较重要我对单独整理的，大家到我主页可以看下。

转载于:https://www.cnblogs.com/yangliguo/p/7399145.html

[SouthEast]: /images/20210724/7d5c64be5ad64f1f8be4048e3c362eb4.png
[SouthEast 1]: /images/20210724/207354b2a114400186c3b0adef6a8c9f.png