SpringMVC

Spring MVC（model-view-controller）框架围绕着DispatcherServlet进行设计，DispatcherServlet就是Spring MVC的前端控制器。浏览器端用户的请求就是通过DispatcherServlet进行了分发到达一个合适Controller来生产所需要的业务数据model，model再通过DispatcherServlet进行传递，传递给view来完成最终的业务呈现。如下图：

核心步骤：
1、 DispatcherServlet在web.xml中的部署描述，从而拦截请求到Spring Web MVC。
2、 HandlerMapping的配置，从而将请求映射到处理器。
3、 HandlerAdapter的配置，把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用。
4、 ViewResolver的配置，将把逻辑视图名解析为具体的View。
5、处理器（页面控制器）的配置，用于对请求进行处理。

XML 例子：

• web.xml中添加如下配置,实现前端控制器：

    <servlet>  
        <servlet-name>chapter2</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
        <load-on-startup>1</load-on-startup>  
        <!-- <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-servlet-config.xml</param-value>
        </init-param>
        -->
    </servlet>  
    <servlet-mapping>  
        <servlet-name>chapter2</servlet-name>  
        <url-pattern>/</url-pattern>  
    </servlet-mapping>  
  

load-on-startup：表示启动容器时初始化该Servlet。
url-pattern：表示哪些请求交给Spring Web MVC处理， “/” 是用来定义默认servlet映射的。也可以如“*.do”表示拦截所有以do为扩展名的请求。

• 在Spring配置文件中配置HandlerMapping、HandlerAdapter
  具体配置在WEB-INF/chapter2-servlet.xml文件中（chapter2为web.xml中的servlet-name）：

    <!-- 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中的处理器。

• 配置ViewResolver
  具体配置在WEB-INF/ chapter2-servlet.xml文件中（chapter2为web.xml中的servlet-name）：

    <!-- 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”；

• 最后配置文件如下：

    <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:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd  ">
  
    <!-- HandlerMapping -->  
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>  
    <!-- HandlerAdapter -->  
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
  
    <!-- 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> 
  
    <!-- 处理器 -->  
    <bean name="/hello" class="cn.javass.chapter2.web.controller.HelloWorldController“>
  
    </beans>
  

• Controller：

    package cn.javass.chapter2.web.controller;  
    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 req, HttpServletResponse resp) throws Exception {  
           //1、收集参数、验证参数  
           //2、绑定参数到命令对象  
           //3、将命令对象传入业务对象进行业务处理  
           //4、选择下一个页面  
           ModelAndView mv = new ModelAndView();  
           //添加模型数据 可以是任意的POJO对象  
           mv.addObject("message", "Hello World!");  
           //设置逻辑视图名，视图解析器会根据该名字解析到具体的视图页面  
           mv.setViewName("hello");  
           return mv;  
        }  
    }  
  

配置文件中的视图解析器InternalResourceViewResolver会将其解析为WEB-INF/jsp/hello.jsp

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

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

运行步骤：
1.首先用户发送请求 http://localhost:9080/springmvc-chapter2/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返回响应给用户，到此一个流程结束。

与Sprin集成：
配置是Spring集成Web环境的通用配置；一般用于加载除Web层的Bean（如DAO、Service等），以便于与其他任何Web框架集成。
contextConfigLocation：表示用于加载Bean的配置文件；
contextClass：表示用于加载Bean的ApplicationContext实现类，默认WebApplicationContext。

    <context-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>
              classpath:applicationContext
          </param-value>
    </context-param>
    <listener>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

ContextLoaderListener初始化的上下文加载的Bean是对于整个应用程序共享的，不管是使用什么表现层技术，一般如DAO层、Service层Bean。
DispatcherServlet初始化的上下文加载的Bean是只对Spring Web MVC有效的Bean，如Controller、HandlerMapping、HandlerAdapter等等，该初始化上下文应该只加载Web相关组件。

注解 例子：

通过@Controller 和 @RequestMapping注解定义我们的处理器类。通过在一个POJO类上放置@Controller或@RequestMapping，即可把一个POJO类变身为处理器。
@RequestMapping(value = "/hello") 请求URL(/hello) 无需实现/继承任何接口/类。

• 推荐使用这种方式声明处理器，它和我们的@Service、@Repository很好的对应了我们常见的三层开发架构的组件。

    @Controller  
    public class HelloWorldController {  
    ……  
    }   
  

• 这种方式也是可以工作的，但如果在类上使用@ RequestMapping注解一般是用于窄化功能处理方法的映射的。

    @RequestMapping  
    public class HelloWorldController {  
    ……  
    }  
  

• 窄化请求映射。

    @Controller  
    @RequestMapping(value="/user")          //①处理器的通用映射前缀  
    public class HelloWorldController {
  
        @RequestMapping(value = "/hello2")  //②相对于①处的映射进行窄化  
        public ModelAndView helloWorld() {  
            ……
        }  
    ……
    } 
  

• URL路径映射：
  @RequestMapping(value={"/test1", "/user/create"})：多个URL路径可以映射到同一个处理器的功能处理方法。
  @RequestMapping(value="/users/{userId}")：{×××}占位符， 请求的URL可以是 “/users/123456”或“/users/abcd”，通过@PathVariable可以提取URI模板模式中的{×××}中的×××变量。
  @RequestMapping(value="/users/{userId}/create")：这样也是可以的，请求的URL可以是“/users/123/create”。
  @RequestMapping(value="/users/{userId}/topics/{topicId}")：这样也是可以的，请求的URL可以是“/users/123/topics/123”。
  @RequestMapping(value="/users/")：可以匹配“/users/abc/abc”，但根据最长匹配优先“/users/123”将优先映射“/users/{userId}”。
  @RequestMapping(value="/product?")：可匹配“/product1”或“/producta”，但不匹配“/product”或“/productaa”;
  @RequestMapping(value="/product")：可匹配“/productabc”或“/product”，但不匹配“/productabc/abc”;
  @RequestMapping(value="/product/")：可匹配“/product/abc”，但不匹配“/productabc”;
  @RequestMapping(value="/products/**/{productId}")：可匹配“/products/abc/abc/123”或“/products/123”

• 请求参数数据映射：
  @RequestMapping(params="create") ：表示请求中有“create”参数名，如可匹配的请求URL“http://×××/parameterTest?create”。
  @RequestMapping(params="!create")：表示请求中没有“create”参数名，如可匹配的请求URL“http://×××/parameterTest?abc”。
  @RequestMapping(params="submitFlag=create")：表示请求中有“submitFlag=create”请求参数，如请求URL为http://×××/parameterTest?submitFlag=create。
  @RequestMapping(params="submitFlag!=create")：表示请求中的参数“submitFlag!=create”，如可匹配的请求URL“http://×××/parameter1?submitFlag=abc”。

• 数据绑定：
  @RequestParam用于将请求参数区数据映射到功能处理方法的参数上，请求中包含username参数（如/requestparam1?username=zhang），则自动传入。

    public String requestparam1(@RequestParam String username)  {
        ……
    }
  
    //即通过@RequestParam("username")明确告诉Spring Web MVC使用username进行入参。
    public String requestparam2(@RequestParam("username") String username){
        ……
    }  
  
    //required：是否必须，默认是true，表示请求中一定要有相应的参数，否则将报404错误码。
    public String requestparam4(@RequestParam(value="username",required=false) String username){
        ……
    }
  
    //defaultValue：默认值，表示如果请求中没有同名参数时的默认值。
    public String requestparam4(@RequestParam(value="username",required=false, defaultValue="zhang") String username){
        ……
    }
  
    public String requestparam5(@RequestParam(value="list") List<String> list){
        ……
    }
  

@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。

    @RequestMapping(value="/users/{userId}/topics/{topicId}")
    public String test(@PathVariable(value="userId") int userId, @PathVariable(value="topicId") int topicId){
        ……
    }

@CookieValue用于将请求的Cookie数据映射到功能处理方法的参数上。@CookieValue也拥有和@RequestParam相同的value,required,defaultValue三个参数，含义一样。

    //将自动将JSESSIONID值入参到sessionId参数上，defaultValue表示Cookie中没有JSESSIONID时默认为空。
    public String test(@CookieValue(value="JSESSIONID", defaultValue="") String sessionId){
        ……
    }  
    //传入参数类型也可以是javax.servlet.http.Cookie类型。
    public String test2(@CookieValue(value="JSESSIONID", defaultValue="") Cookie sessionId){
        ……
    }

@RequestHeader用于将请求的头信息区数据映射到功能处理方法的参数上。@RequestHeader也拥有和@RequestParam相同的三个参数，含义一样。

    //如上配置将自动将请求头“User-Agent”值入参到userAgent参数上，并将“Accept”请求头值入参到accepts参数上。
    public String test(@RequestHeader("User-Agent") String userAgent, @RequestHeader(value="Accept") String[] accepts){
        ……
    }    

@ModelAttribute放在方法的注解上时，会在每一个@RequestMapping标注的方法前先执行此@ModelAttribute方法，如果有返回值，则自动将该返回值加入到ModelMap中。

暴露表单引用对象为模型(model)数据
返回void：

    //访问控制器方法helloWorld时，会首先调用populateModel方法，将页面参数abc(/helloWorld.ht?abc=text)放到model的attributeName属性中，在视图中可以直接访问。
    //在视图中可以直接访问<c:out value="${attributeName}"></c:out>  
    @Controller  
    public class HelloModelController {  
          
        @ModelAttribute   
        public void populateModel(@RequestParam String abc, Model model) {    
           model.addAttribute("attributeName", abc);    
        }    
      
        @RequestMapping(value = "/helloWorld")    
        public String helloWorld() {    
           return "helloWorld.jsp";    
        }    
      
    }

返回具体类：

    //设置这个注解之后可以直接在前端页面使用hobbise这个对象（List）集合。
    //例如：<c:forEach items="${hb}" var="hobby" varStatus="vs"> 
    @ModelAttribute("hb")  
    public List<String> hobbiesList(){  
        List<String> hobbise = new LinkedList<String>();  
        hobbise.add("basketball");  
        hobbise.add("football");  
        hobbise.add("tennis");  
        return hobbise;  //那么这个model属性的名称是hb。相当于model.addAttribute("hb", hobbise); 
    } 

    @RequestMapping(value = "/helloWorld")  
    public String helloWorld(@ModelAttribute("hb") List<String> hobbise) {  
        System.out.println("hobbise : "+hobbise.toString());
        return "helloWorld";  
    } 

在这个例子里，@ModelAttribute("hb") List<String> hobbise注释方法参数，参数hobbise的值来源于hobbiesList()方法中的model的属性hb。进行模型绑定时首先查找模型数据中是否含有同名对象，如果有直接使用，如果没有通过反射创建一个。参考

绑定请求参数到命令对象

    //如请求参数包含“?username=zhang&password=123&workInfo.city=bj”自动绑定到User类中的username属性，password属性，workInfo属性的city属性中。
    //我们在视图页面也可以直接使用user，如：${user}，${user.username}
    public String test1(@ModelAttribute("user") UserModel user) {
        ……
    } 

@SessionAttributes注解就可以使得模型中的数据存储一份到session域中。默认情况下Spring MVC将模型中的数据存储到request域中。当一个请求结束后，数据就失效了。如果要跨页面使用。那么需要使用到session。
@SessionAttributes参数：
1.names：这是一个字符串数组。里面应写需要存储到session中数据的名称。
2.types：根据指定参数的类型，将模型中对应类型的参数存储到session中。
3.value：其实和names是一样的。

    @RequestMapping("/test")
    public String test(Map<String,Object> map){
        map.put("names", Arrays.asList("caoyc","zhh","cjx"));
        map.put("age", 18);
        return "hello";
    }

    request中names:${requestScope.names}<br/>
    request中age:${requestScope.age}<br/>
    <hr/>
    session中names:${sessionScope.names }<br/>
    session中age:${sessionScope.age }<br>

    @SessionAttributes(value={"names"},types={Integer.class})
    @Controller
    public class TestController {

        @RequestMapping("/test")
        public String testController(Map<String,Object> map){
            map.put("names", Arrays.asList("caoyc","zhh","cjx"));
            map.put("age", 18);
            return "hello";
        }
    }

如果在另一个Controller重要调用其他Controller中放入session中的值，也许要在Controller上加上相同的SessionAttributes注解，例如：

    @Controller
    @SessionAttributes("names")
    public class AnotherController {
        public String lendBooks(@ModelAttribute("names")List names){
            System.out.println("names:"+names.toString);
        }
    }