SpringMVC从入门到放弃之第二章SpringMVC入门

额(⊙o⊙)…
继续记笔记。。。看看

Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将Web进行职责解耦，基于请求驱动指的就是使用请求—响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。
Spring Web MVC也是服务到工作者模式的体现，但进行可优化。前端控制器是DispatcherServlet；应用控制器其实拆为处理器映射器（Handler Mapping）进行处理器管理和视图解析器（View Resolver）进行视图管理；页面控制器/动作/处理器为Controller接口（仅包含ModelAndView handleRequest（request，response）方法）的实现（也可以是任何POJO类）；支持本地化（Locale）解析、主题（Theme）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。

1、让我们能非常简单的设计出干净的Web层和薄薄的Web层；
2、进行更简洁的Web层开发；
3、天生与Spring框架集成（如IOC容器、AOP等）；
4、提供强大的约定大于配置的契约式编程支持；
5、能简单的进行Web层的单元测试；
6、支持灵活的URL到页面控制器的映射；
7、非常容易与其他视图技术集成；
8、非常灵活的数据验证、格式化和数据绑定机制，能使用任何对象进行数据绑定，不必实现特定框架的API；
9、提供一套强大的JSP标签库，简化JSP开发；
10、支持灵活的本地化、主题等解析；
11、更加简单的异常处理；
12、对静态资源的支持；
13、支持Restful风格；

Spring Web MVC框架也是一个基于请求驱动的Web框架，并且也是用了前端控制器模式来进行设计，再根据请求映射规则分发给相应的页面控制器（动作/处理器）进行处理。首先让我们来整体看一下Spring Web MVC请求的处理流程。

2.3.1、Spring Web MVC处理请求过程

具体执行步骤如下：
1、首先客户发送请求——>前端控制器，前端控制器根据请求信息（如URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前控制器的控制逻辑部分；如图中的1、2步骤；
2、页面控制器接收到请求后，进行功能处理，首先需要收集和绑定请求参数到一个对象，这个对象在Spring Web MVC中叫命令对象，并进行验证，然后将命令对象委托给业务对象进行处理；处理完毕后返回一个ModelAndView（模型数据和逻辑视图名）；如图中的3、4、5步骤；
3、前端控制器收回控制权，然后根据返回的逻辑视图名，选择相应的视图进行渲染，并把数据模型传入以便视图渲染；如图中的6、7步骤；
4、前端控制器再次收回控制权，将响应返回给用户；如图中的8步骤；至此整个响应到此结束。
问题：
1、请求如何给前端控制器？
2、前端控制器如何根据请求信息选择页面控制器进行功能处理？
3、如何支持多种页面控制器呢？
4、页面控制器如何使用业务对象？
5、页面控制器如何返回模型数据？
6、前端控制器如何根据页面控制器返回的逻辑视图名选择具体的视图进行渲染？
7、不同的视图技术如何使用相应的模型数据？
首先我们知道有如上问题，那么这些问题我们如何进行解决呢？在后面依次进行回答。

2.3.2、Spring Web MVC架构

1、Spring Web MVC核心架构图

架构图对应的DispatcherServlet核心代码如下：

//前端控制器分派方法
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception
{
      HttpServletRequest processedRequest = request;
      HandlerExecutionChain mappedHandler = null;
      int interceptorIndex = -1;
      try {
            ModelAndView mv;
            boolean errorView = false;
            try {
            //检查是否是请求是否是multipart（如文件上传），如果是将通过MultipartResolver解析
            processedRequest = checkMultipart(request);
            //步骤2、请求到处理器（页面控制器）的映射，通过HandlerMapping进行映射
            mappedHandler = getHandler(processedRequest, false);
            if (mappedHandler == null  mappedHandler.getHandler() == null) {
                  noHandlerFound(processedRequest, response);
                  return;
            }
            //步骤3、处理器适配，即将我们的处理器包装成相应的适配器（从而支持多种类型的处理器）
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
            // 304 Not Modified缓存支持
            //此处省略具体代码
            // 执行处理器相关的拦截器的预处理（HandlerInterceptor.preHandle）
            //此处省略具体代码
            // 步骤4、由适配器执行处理器（调用处理器相应功能处理方法）
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); 
            // Do we need view name translation?
            if (mv != null && !mv.hasView()) {
                mv.setViewName(getDefaultViewName(request));
            }
            // 执行处理器相关的拦截器的后处理（HandlerInterceptor.postHandle）
            //此处省略具体代码
     }
     catch (ModelAndViewDefiningException ex) {
            logger.debug("ModelAndViewDefiningException encountered", ex);
            mv = ex.getModelAndView();
     }  
     catch (Exception ex) {
            Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
            mv = processHandlerException(processedRequest, response, handler, ex);
            errorView = (mv != null);
     }
            //步骤5 步骤6、解析视图并进行视图的渲染
            //步骤5 由ViewResolver解析View（viewResolver.resolveViewName(viewName,         locale)）
            //步骤6 视图在渲染时会把Model传入（view.render(mv.getModelInternal(), request, response);）
            if (mv != null && !mv.wasCleared()) {
            render(mv, processedRequest, response);
                if (errorView) {
                     WebUtils.clearErrorRequestAttributes(request);
                }
        } else {
            if (logger.isDebugEnabled()) {
               logger.debug("Null ModelAndView returned to DispatcherServlet with name '" +getServletName() +"': assuming HandlerAdapter completed request handling");
            }
        }
        // 执行处理器相关的拦截器的完成后处理（HandlerInterceptor.afterCompletion）
        //此处省略具体代码
        catch (Exception ex) {
        // Trigger after-completion for thrown exception.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
throw ex;
        }
        catch (Error err) {
        ServletException ex = new NestedServletException("Handler processing failed", err);
        // Trigger after-completion for thrown exception.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
        throw ex;
        }
        finally {
        // Clean up any resources used by a multipart request.
            if (processedRequest != request) {
                  cleanupMultipart(processedRequest);
            }
       }
}

核心架构的具体步骤流程如下：
1、首先用户发送请求———>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一的访问点，进行全局的流程控制；
2、DispatcherServlet———>HandlerMapping，HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
3、DispatcherServlet———>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
4、HandlerAdapter———>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
5、ModelAndView的逻辑视图名———>ViewRsolver，ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
6、View———>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
7、返回控制权给Dispatcher，由DispatcherServlet返回响应给用户，到此一个流程结束。
到此，再来看我们前边提出的问题：
1、请求如何给前端控制器？这个应该在web.xml中进行部署描述，在HelloWorld中详细讲解。
2、前端控制器如何根据请求控制信息选择页面控制器进行功能处理？我们需要配置HandlerMapping进行映射
3、如何支持多种页面控制器呢？配置HandlerAdapter从而支持多种类型的页面控制器
4、页面控制器如何使用业务对象？可以预料到，肯定利用SpringIoc容器的依赖注入功能
5、页面控制器如何返回模型数据？使用ModelAndView返回
6、前端控制器如何根据页面控制器返回的逻辑视图名选择具体的视图进行渲染？使用ViewResolver进行解析
7、不同的视图技术如何使用相应的模型数据？因为Model是一个Map数据结构，很容易支持其他视图技术
在此我们看出具体的核心开发步骤：
1、DispatcherServlet在web.xml中的部署描述，从而拦截请求到Spring Web MVC
2、HandlerMapping的配置，从而将请求映射到处理器
3、HandlerAdapter的配置，从而支持多种类型的处理器
4、ViewResolver的配置，从而将逻辑视图名解析为具体视图技术
5、处理器（页面控制器）的配置，从而进行功能处理

1、清晰的角色划分：前端控制器（DispatcherServlet）、 请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（Validator）、命令对象（Command请求参数绑定到的对象就叫命令对象）、表单对象（From Object提供给表单展示和提交到的对象就叫表单对象）；
2、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要；
3、由于命令对象就是一个POJO，无需继承框架特定API，可以使用命令对象直接作为业务对象；
4、和Spring其他框架无缝集成，是其他Web框架所不具备的；
5、可适配，通过HandlerAdapter可以支持任意类作为处理器；
6、可定制性，HandlerMapping、ViewResolver等能够非常简单的定制；
7、功能强大的数据验证、格式化、绑定机制；
8、利用Spring提供的Mock对象能够非常简单的进行Web层单元测试；
9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换；
10、强大的JSP标签库，是JSP编写更加容易。

2.5.1、准备开发环境和运行环境

开发工具：eclipse
运行环境：tomcat7
工程：动态Web工程
spring所有框架下载：
spring-framework-4.3.1.RELEASE-dist.zip
依赖jar包：
1、Spring依赖的jar包：
为了简单，将spring-framework-4.3.1.RELEASE-dist.zip/dist/下所有的jar包拷贝到项目的WEB-INF/lib目录下；
2、Spring框架依赖的jar包：
需要添加Apache commons logging日志，此处用的commons-logging-1.2.jar
需要添加jstl标签库支持，此处使用的是jstl-1.1.2.jar和standard-1.1.2.jar
3、项目目录

4、效果

2.5.2、前端控制器的配置

我们在web.xml中添加如下配置

  <servlet>
    <servlet-name>helloworld</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>helloworld</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

load-on-startup：表示启动容器时初始化该Servlet；
url-pattern：表示哪些请求交给Spring Web MVC处理，“/”是用来定义默认Servlet映射的。也可以如“*.html”表示拦截所有以html为扩展名的请求。
自此请求已交给Spring Web MVC框架处理，因此我们需要配置Spring的配置文件，默认的DispatcherServlet会加载WEB-INF/[DispatcherServlet的Servlet名字]-servlet.xml配置文件。本例为WEB-INF/helloworld-servlet.xml。

2.5.3、在Spring配置文件中配置HandlerMapping、HandlerAdapter

具体配置在WEB-INF/helloworld.xml文件中：

    <!-- HandlerMapping -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

    <!-- HandlerAdapter -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

BeanNameUrlHandlerMapping：表示将在请求的URL和Bean名字映射，如URL为“上下文/hello”，则Spring配置文件必须有一个名字为“/hello”的bean，上下文默认忽略。
SimpleControllerHandlerAdapter：表示所有实现了org.springframework.web.servlet.mvc.Controller接口的Bean可以作为Spring Web MVC中的处理器。如果需要其他类型的处理器可以通过实现HandlerAdapter来解决。

2.5.4、在Spring配置文件中配置ViewResolver

具体配置在WEB-INF/ helloworld-servlet.xml文件中：

    <!-- ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

InternalResourceViewResolver：用于支持Servlet、JSP视图解析；
viewClass：JstlView表示JSP模板页面需要使用JSTL标签库，classpath中必须啊包含jstl的相关jar包；
prefix和suffix：查找视图页面的前缀和后缀（前缀[逻辑视图名]后缀），比如传过来的逻辑视图名为hello，则该jsp视图页面应该存放在“/WEB-INF/jsp/hello.jsp”；

2.5.5、开发处理器/页面控制器

package com.helloworld;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class HelloWorldController implements Controller{

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //1、收集参数
        //2、绑定参数到命令对象
        //3、将命令对象传如业务对象进行业务处理
        //4、选择下一个页面
        ModelAndView mv = new ModelAndView();
        mv.addObject("message", "HelloWorld");
        mv.setViewName("hello");
        return mv;
    }
}

org.springframework.web.servlet.mvc.Controller：页面控制器/处理器必须是实现Controller接口，注意别选错了；后边我们会学习其他的处理器实现方式；
public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp)：功能处理方法，实现相应的功能处理，比如收集参数、验证参数、绑定参数到命令对象、将命令对象传入到业务对象进行业务处理，最后返回ModelAndView对象；
ModelAndView：包含了视图要实现的模型数据和逻辑视图名；“mv.addObject("message", "Hello World!");”表示添加模型数据，此处可以是任意的POJO对象；“mv.setViewName("hello");”表示设置逻辑视图名为“hello”，视图解析器会将其解析为具体的视图，如前边的视图解析器InternalResourceVi。wResolver 会将其解析为“WEB-INF/jsp/hello.jsp”。
我们需要将其添加到Spring配置文件(WEB-INF/helloworld-servlet.xml)，让其接受Spring IoC容器管理:

    <!-- 处理器 -->
    <bean name="/hello" class="com.helloworld.HelloWorldController"/>

name="/hello"：前边配置的BeanNameUrlHandlerMapping，表示如果请求的URL为“上下文/hello”，则将会交给该Bean处理。

2.5.6、开发视图界面

创建 /WEB-INF/jsp/hello.jsp视图页面：

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!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>Hello World</title>
</head>
<body>
    ${message }
</body>
</html>

${message}：表示显示由HelloWorldController处理器传过来的模型数据。

2.5.7、启动服务器运行测试

通过请求：http://localhost:8080/HelloWorld/hello如果页面输出“Hello World! ”就表明我们成功了！
localhost：服务器地址；
8080：端口；
HelloWorld：web应用上下文；
/hello：映射到控制器部分

2.5.8、运行流程分析

运行步骤：
1、首先用户发送请求http://localhost:8080/HelloWorld/hello——>web容器，web容器根据“/hello”路径映射到DispatcherServlet（url-pattern为/）进行处理；
2、DispatcherServlet——>BeanNameUrlHandlerMapping进行请求到处理的映射，BeanNameUrlHandlerMapping将“/hello”路径直接映射到名字为“/hello”的Bean进行处理，即HelloWorldController，BeanNameUrlHandlerMapping
将其包装为HandlerExecutionChain（只包括HelloWorldController 处理器，没有拦截器）；
3、DispatcherServlet——>SimpleControllerHandlerAdapter，SimpleControllerHandlerAdapter 将HandlerExecutionChain中的处理器（HelloWorldController）适配为SimpleControllerHandlerAdapter；
4、SimpleControllerHandlerAdapter——> HelloWorldController 处理器功能处理方法的调用，
SimpleControllerHandlerAdapter 将会调用处理器的handleRequest 方法进行功能处理，该处理方法返回一个ModelAndView给DispatcherServlet；
5、hello（ModelAndView 的逻辑视图名）——>InternalResourceViewResolver， InternalResourceViewResolver 使用JstlView，具体视图页面在/WEB-INF/jsp/hello.jsp；
6、JstlView（/WEB-INF/jsp/hello.jsp）——>渲染，将在处理器传入的模型数据(message=HelloWorld！)在视图中展示出来；
7、返回控制权给DispatcherServlet，由DispatcherServlet 返回响应给用户，到此一个流程结束。
到此HelloWorld就完成了，步骤是不是有点多？而且回忆下我们主要进行了如下配置：
1、前端控制器DispatcherServlet；
2、HandlerMapping;
3、HandlerAdapter；
4、ViewResolver；
5、处理器/页面控制器；
6、视图
因此，接下来几章让我们详细看看这些配置，先从DispatcherServlet开始吧。

Spring Web MVC框架提供了org.springframework.web.filter.CharacterEncodingFilter用于解决POST方式造成的中文乱码问题，具体配置如下：

<filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
  </filter>
  <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
  </filter-mapping>

以后我们项目及所有页面的编码均为UTF-8。

一、Spring2.5 之前，我们都是通过实现Controller 接口或其实现来定义我们的处理器类。
二、Spring2.5 引入注解式处理器支持，通过@Controller 和@RequestMapping注解定义我们的处理器类。并且提供了一组强大的注解：
需要通过处理器映射DefaultAnnotationHandlerMapping和处理器适配器AnnotationMethodHandlerAdapter来开启支持@Controller 和 @RequestMapping 注解的处理器。

注解作用
----:----:
@Controller用于标识是处理器类
@RequestMapping请求到处理器功能方法的映射规则
@RequestParam请求参数到处理器功能处理方法的方法参数上的绑定
@ModelAttribute请求参数到命令对象的绑定
@InitBinder自定义数据绑定注册支持，用于将请求参数转换到命令对象属性的对应类型
@SessionAttributes用于声明session 级别存储的属性，放置在处理器类上，通常列出模型属性（如@ModelAttribute）对应的名称，则这些属性会透明的保存到session 中
三、Spring3.0 引入RESTful 架构风格支持(通过@PathVariable注解和一些其他特性支持),且又引入了
更多的注解支持：

注解作用
----:----:
@CookieValuecookie 数据到处理器功能处理方法的方法参数上的绑定
@RequestHeader请求头（header）数据到处理器功能处理方法的方法参数上的绑定
@RequestBody请求的body体的绑定（通过HttpMessageConverter 进行类型转换）
@ResponseBody处理器功能处理方法的返回值作为响应体（通过HttpMessageConverter进行类型转换）
@ResponseStatus定义处理器功能处理方法/异常处理器返回的状态码和原因
@ExceptionHandler注解式声明异常处理器
@PathVariable请求URI 中的模板变量部分到处理器功能处理方法的方法参数上的绑定，从而支持RESTful 架构风格的URI
四、Spring3.1 新特性：
对 Servlet 3.0 的全面支持。

简书地址
原文地址