SpringMVC学习笔记

---

一、SpringMVC概述

• SpringMVC 也叫 Spring web mvc。是 Spring 框架的一部分，是在Spring3.0 后发布的
• 基于 MVC 架构，功能分工明确。解耦合
• SpringMVC 也是轻量级的，jar 很小。不依赖的特定的接口和类
• 作为 Spring 框架一部分，能够使用 Spring 的 IoC 和 Aop。方便整合
  Strtus,MyBatis,Hiberate,JPA 等其他框架
• SpringMVC 强化注解的使用，在控制器，Service，Dao 都可以使用注
  解。方便灵活

二、创建一个SpringMVC项目

2.1 导入maven依赖

	<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--springmvc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.8</version>
    </dependency>
    <dependency>
      <groupId>org.apache.tomcat</groupId>
      <artifactId>servlet-api</artifactId>
      <version>6.0.29</version>
    </dependency>

2.2 注册中央调度器

• 在web.xml中注册中央调度器,并自定义配置文件的位置

2.2.1 全限定类名

 该中央调度器为一个 Servlet，名称为 DispatcherServlet。中央调度器的
全限定性类名在导入的 Jar 文件 spring-webmvc-5.2.5.RELEASE.jar 的第一个
包 org.springframework.web.servlet 下可找到

2.2.2 <load-on-startup/>

• 在<servlet/>中添加<load-on-startup/>的作用是，标记是否在 Web 服务器（这里是 Tomcat）启动时会创建这个 Servlet 实例
• 即是否在 Web 服务器启动时调用执行该 Servlet 的 init()方法，而不是在真正访问时才创建
• 当值大于等于 0 时，表示容器在启动时就加载并初始化这个servlet，数值越小，该 Servlet 的优先级就越高，其被创建的也就越早
• 当值小于 0 或者没有指定时，则表示该 Servlet 在真正被使用时才会去创建
• 当值相同时，容器会自己选择创建顺序

2.2.3 配置文件位置与名称(重点)

• 注册完毕后，可直接在服务器上发布运行。此时，访问浏览器页面，控制台均会抛出 FileNotFoundException 异常
• 即默认要从项目根下的 WEB-INF目录下找名称为 Servlet 名称-servlet.xml 的配置文件
• 这里的“Servlet 名称”指的是注册中央调度器<servlet-name/>标签中指定的 Servlet 的 name值。本例配置文件名为 springmvc-servlet.xml
  
• 而一般情况下，配置文件是放在类路径下，即resources目录下。所以，在注册中央调度器时，还需要为中央调度器设置查找 SpringMVC 配置文件路径，及文件名

<web-app>
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!--自定义配置文件的位置-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!--
      表示服务器tomcat创建对象的顺序,该值为正数值,大于等于0
      数值越小,创建对象的时间越早
    -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--
               url-pattern 作用: 把一些请求交给指定的servlet处理
               使用中央调度器（DispatcherServlet）
               1. 使用扩展名方式， 格式 *.xxx ,  xxx是自定义的扩展名。
                  例如  *.do , *.action, *.mvc 等等. 不能使用*.jsp
                  http://localhost:8080/myweb/some.do
                  http://localhost:8080/myweb/user/list/queryUser.do
                  http://localhost:8080/myweb/user/list/list.do

               2. 使用斜杠 "/"
            -->
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

 打开 DispatcherServlet 的源码，其继承FrameworkServlet，而该类中有一个属性 contextConfigLocation，用于设置 SpringMVC 配置文件的路径及文件名。该初始化参数的属性就来自于这里

2.3 创建SpringMVC配置文件

在工程的类路径即 src 目录下创建 SpringMVC 的配置文件
springmvc.xml。该文件名可以任意命名

2.4 创建处理器

• 在类上与方法上添加相应注解即可
• @Controller：表示当前类为处理器
• @RequestMapping:表示当前方法为处理器方法。该方法要对 value 属
  性所指定的 URI 进行处理与响应。被注解的方法的方法名可以随意
• 若有多个请求路径均可匹配该处理器方法的执行，则@RequestMapping的 value 属性中可以写上一个数组
• ModelAndView 类中的 addObject()方法用于向其 Model 中添加数据。Model 的底层为一个 HashMap
• Model 中的数据存储在 request 作用域中，SringMVC 默认采用转发的方式跳转到视图，本次请求结束，模型中的数据被销毁

/**
 * @Controller： 创建控制器（处理器）对象
 *    控制器：叫做后端控制器（back controller）,自定义的类处理请求的。
 *    位置： 在类的上面， 表示创建此类的对象， 对象放在springmvc的容器中。
 */
@Controller
public class MyController {
    /**
     * springmvc框架，使用控制器类中的方法，处理请求。
     * 方法的特点：
     *  1. 方法的形参，表示请求中的参数
     *  2. 方法的返回值，表示本次请求的处理请求
     */

    /**
     * @RequestMapping: 请求映射
     *          属性： value  请求中的uri地址， 唯一值， 以"/"开头。
     *          位置： 1.在方法的上面（必须的） 2.在类定义的上面（可选）
     *          作用：把指定的请求，交给指定的方法处理 ，等同于url-pattern
     *
     * 返回值ModelAndView:表示本次请求的处理结果（数据和视图）
     *      Model：表示数据
     *      View：表示视图
     */
    @RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){
        System.out.println("执行了MyController的doSome方法");
        //使用这个方法处理请求。 能处理请求的方法叫做控制器方法
        //调用service对象，处理请求，返回数据
        ModelAndView mv = new ModelAndView();
        //添加数据
        mv.addObject("msg","处理了some.do的请求");
        mv.addObject("fun","处理了doSome的方法");

        //指定视图,setViewName("视图的完整路径")
//        mv.setViewName("/WEB-INF/view/show.jsp");
        mv.setViewName("show");

        return mv;

    }
    /**
     * 当框架调用完doSome()方法后，得到返回中ModelAndView.
     * 框架会在后续的处理逻辑值， 处理mv对象里面的数据和视图
     * 对数据执行 request.setAttribute("msg", "处理了some.do请求"); 把数据放入到request作用域。
     * 对视图执行forward转发操作。等同于 request.getRequestDispatcher("/show.jsp").forward(..)
     */

}

2.5 声明组件扫描器

在 springmvc.xml 中注册组件扫描器

<context:component-scan base-package="com.jjh.controller"/>

2.6 定义目标页面

在 webapp 目录下新建一个子目录 jsp，在其中新建一个 jsp 页面
show.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@page isELIgnored="false" %>
<html>
<head>
    <title>show</title>
</head>
<body>
/show.jsp
显示request作用域中的数据<br>

<h2>msg的数据: ${msg}</h2>

</body>
</html>

2.7 修改视图解析器的注册

• SpringMVC 框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器 InternalResouceViewResolver 中引入了请求的前辍与后辍
• 而ModelAndView 中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，视图解析器会自动完成拼接

• 把 show.jsp 文件放到 /WEB-INF/jsp/路径中

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.jjh.controller"/>

    <!--声明视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：指定视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/" />
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp" />
    </bean>

三、SpringMVC执行图解

3.1 使用 SpringMVC 框架 web 请求处理顺序

3.2 SpringMVC 的 MVC 组件

3.3 SpringMVC 执行流程

3.4 执行流程简单分析

1.浏览器提交请求到中央调度器
----------------------------------------------------------------------------------------------------------
2.中央调度器直接将请求转给处理器映射器
----------------------------------------------------------------------------------------------------------
3.处理映射器会根据请求,找到处理该请求的处理器,并将其封装为处理器执行链后返回给中央调度器
----------------------------------------------------------------------------------------------------------
4.中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器
----------------------------------------------------------------------------------------------------------
5.处理器适配器调用执行处理器
----------------------------------------------------------------------------------------------------------
6.处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView中，并将其返回给处理器适配器
----------------------------------------------------------------------------------------------------------
7.处理器适配器直接将结果返回给中央调度器
----------------------------------------------------------------------------------------------------------
8.中央调度器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象
----------------------------------------------------------------------------------------------------------
9.视图解析器将封装了的视图对象返回给中央调度器
----------------------------------------------------------------------------------------------------------
10.中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象
----------------------------------------------------------------------------------------------------------
11.中央调度器响应浏览器

四、SpringMVC 注解式开发

4.1 @RequestMapping 定义请求规则

• 通过@RequestMapping 注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上，也可以注解在类上，但意义是不同的。value 属性值常以“/”开始
• @RequestMapping 的 value 属性用于定义所匹配请求的 URI。但对于注解在方法上与类上，其 value 属性所指定的 URI，意义是不同的
• 一个@Controller 所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的 URI 是不同的
• 这些不同的 URI 被指定在注解于方法之上的@RequestMapping 的 value 属性中。但若这些请求具有相同的 URI 部分，则这些相同的 URI，可以被抽取到注解在类之上@RequestMapping 的value 属性中

• 修改处理器类MyController
  

• 添加视图界面

在/WEB-INF/jsp 目录下添加some.jsp与other.jsp页面

4.2 对请求方式的定义

• 对于@RequestMapping，其有一个属性method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该 method 属性指定的提交方式的请求，才会执行该被注解方法
• Method 属性的取值为 RequestMethod 枚举常量。常用的为
  RequestMethod.GET 与 RequestMethod.POST，分别表示提交方式的匹配规则为 GET 与 POST提交
• 当然，若不指定 method 属性，则无论是 GET 还是 POST 提交方式，均可匹配。即对于请求的提交方式无要求

4.3 处理器方法的参数

 处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序员可在方法内直接使用

• HttpServletRequest
• HttpServletResponse
• HttpSession
• 请求中所携带的请求参数

4.3.1 逐个参数接收

只要保证请求参数名与该请求处理方法的参数名相同即可

• index界面

<p>逐个接收请求参数</p>
    <form action="receive-property.do" method="post">
        姓名：<input type="text" name="name"> <br/>
        年龄：<input type="text" name="age"> <br/>
        <input type="submit" value="提交参数">
    </form>

• 处理器类 MyController

	@RequestMapping(value ="/receive-property.do")
    public ModelAndView doPropertyParam(String name, Integer age) {

        System.out.println("执行了MyController的doPropertyParam方法name=" + name+",age="+age);
        ModelAndView mv  = new ModelAndView();
        //添加数据
        mv.addObject("myname", name);
        mv.addObject("myage", age);

        mv.setViewName("show");

        //返回结果
        return mv;
    }

• show.jsp页面

<body>
    /WEB-INF/view/show.jsp ,显示requset作用域中的数据 <br/>
    <h3>myname数据： ${myname}</h3>
    <h3>myage数据： ${myage}</h3>
</body>

4.3.2 请求参数中文乱码问题

 对于前面所接收的请求参数，若含有中文，则会出现中文乱码问题。
Spring 对于请求参数中的中文乱码问题，给出了专门的字符集过滤器：
spring-web-5.2.5.RELEASE.jar 的 org.springframework.web.filter 包下的CharacterEncodingFilter 类

• 解决方案

 在 web.xml 中注册字符集过滤器，即可解决 Spring 的请求参数的中文码问题。不过，最好将该过滤器注册在其它过滤器之前。因为过滤器的执行按照其注册顺序进行的

<!--声明过滤器，框架提供的，解决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>
    <init-param>
      <!--强制请求（request）对象使用encoding的编码方式-->
      <param-name>forceRequestEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <!--强制应答（response）对象使用encoding的编码方式-->
      <param-name>forceResponseEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <!--强制所有请求，先经过过滤器处理-->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

• 源码分析
  

4.3.3 校正请求参数名@RequestParam

• 所谓校正请求参数名，是指若请求 URL 所携带的参数名称与处理方法中指定的参数名不相同时，则需在处理方法参数前，添加一个注解@RequestParam(“请求参数名”)
• 指定请求 URL 所携带参数的名称。该注解是对处理器方法参数进行修饰的。value 属性指定请求参数的名称

• MyController

/**
     * 逐个接收请求参数， 请求中参数名和形参名不一样
     * @RequestParam : 解决名称不一样的问题
     *       属性： value 请求中的参数名称
     *              required : boolean类型的，默认是true
     *                    true：请求中必须有此参数，没有报错。
     *                    false：请求中可以没有此参数。
     *       位置： 在形参定义的前面
     */
	@RequestMapping(value ="/receive-param.do")
    public ModelAndView doReceiveParam(@RequestParam(value = "rname",required = false) String name,
                                       @RequestParam(value = "rage",required = false) Integer age) {

        System.out.println("执行了MyController的doReceiveParam方法name=" + name+",age="+age);
        ModelAndView mv  = new ModelAndView();
        //添加数据
        mv.addObject("myname", name);
        mv.addObject("myage", age);

        mv.setViewName("show");

        //返回结果
        return mv;

    }

• index界面

将表单中的参数名称修改的与原来不一样

    <p>逐个接收请求参数: 请求中参数名和形参名不一样</p>
    <form action="receive-param.do" method="post">
        姓名：<input type="text" name="rname"> <br/>
        年龄：<input type="text" name="rage"> <br/>
        <input type="submit" value="提交参数">
    </form>

4.3.4 对象参数接受

将处理器方法的参数定义为一个对象，只要保证请求参数名与这个对象的属性同名即可

• POJO

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private String name;
    private Integer age;
}

• index.jsp

<form action="receive-Object.do">
    姓名:<input type="text" name="name">
    年龄:<input type="text" name="age">
    <button type="submit">提交</button>
</form>

• MyController

/**
     * 使用对象接收请求中的参数
     * 要求： 参数名和java对象的属性名一样。
     *       java类需要有一个无参数构造方法， 属性有set方法
     *
     * 框架的处理：
     *  1. 调用Student的无参数构造方法，创建对象
     *  2. 调用对象set方法， 同名的参数，调用对应的set方法。
     *     参数是name ，调用setName(参数值)
     */
    @RequestMapping(value = {"receive-Object.do"})
    public ModelAndView receiveObject(Student student){
        ModelAndView mv = new ModelAndView();
        mv.addObject("name",student.getName());
        mv.addObject("age",student.getAge());
        mv.setViewName("show");
        return mv;
    }

• 视图层show.jsp

<h2>${student}</h2>

4.4 处理器方法的返回值

使用@Controller 注解的处理器的处理器方法，其返回值常用的有四种类
型:

• ModelAndView
• String
• void
• 返回自定义对象

4.4.1 ModelAndView

请求的结果中有数据与视图,则采用ModelAndView作为返回值
数据:存放request作用域
视图:执行forward操作

@RequestMapping(value = {"receive-Object.do"})
    public ModelAndView receiveObject(Student student){
        ModelAndView mv = new ModelAndView();
        mv.addObject("name",student.getName());
        mv.addObject("age",student.getAge());
        mv.setViewName("show");
        return mv;
    }

4.4.2 String

• 框架对返回值是String,执行的是forward转发操作
• 视图可以作为完整的视图路径,或者视图的逻辑名称

@RequestMapping(value = "/return-string-view.do")
    public String doReturnStringView01(HttpServletRequest request, String account, String password){
        System.out.println("执行了doReturnStringView01的方法!!!");
        //不使用ModelAndView,手动存放数据
        request.setAttribute("name",account);
        request.setAttribute("password",password);
        //forward返回结果,转发到show.jsp(已配置视图解析器)
        return "show";
    }

4.4.3 void(了解)

• 对于处理器方法返回 void 的应用场景，AJAX 响应
• 若处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回 void

• maven加入Jackson依赖

由于本项目中服务端向浏览器传回的是 JSON 数据，需要使用一个工具类将字符串包装为 JSON 格式，所以需要导入 JSON 的依赖

<!--jackson依赖-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>

由于本项目要使用 jQuery 的 ajax()方法提交 AJAX 请求，所以项目中需要引入 jQuery 的库

• 定义index页面

index 页面由两部分内容构成：一个是<button/>，用于提交 AJAX 请
求；一个是<script/>，用于处理 AJAX 请求

<script type="text/javascript" src="js/jquery-3.4.1.js"></script>
    <script type="text/javascript">
        $(function (){
            //绑定事件
            $("#btnAjax").on("click",function (){
                $.ajax({
                    url:"return-void-ajax.do",
                    data:{
                        name:"Jack",
                        age:22
                    },
                    dataType:"text",
                    success:function (resp){
                        alert("resp = " + resp);
                    }
                })
            })
        })
    </script>

<%--发起ajax请求--%>
<button id="btnAjax">发起Ajax请求</button>

• Student

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private String name;
    private Integer age;
}

• Controller

处理器对于 AJAX 请求中所提交的参数，可以使用逐个接收的方式，也可以以对象的方式整体接收。只要保证 AJAX 请求参数与接收的对象类型属性同名

    /*控制器方法返回void，响应ajax请求，使用HttpServletResponse输出数据*/
    @RequestMapping(value = "/return-void-ajax.do")
    public void doReturnVoid01(HttpServletResponse rep, String name, Integer age) throws IOException {
        //模拟调用service得到结果对象
        Student student = new Student();
        student.setAge(21);
        student.setName("杨莎莎");

        //把对象转换为json
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(student);
        System.out.println("服务器对象转换为json:" + json);

        //输出json,相应ajax
        rep.setContentType("application/jason;charset=utf-8");
        PrintWriter pw = rep.getWriter();
        pw.println(json);
        pw.flush();
        pw.close();
    }

4.4.4 Object(重点)

• 处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer， String，自定义对象，Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的
• 返回对象，需要使用@ResponseBody 注解，将转换后的 JSON 数据放入到响应体中

4.4.4.1 HttpMessageConverter

HttpMessageConverter<T>是Spring3.0 新添加的一个接口，负责将请求信息转换为一个对象（类型为T），将对象（类型为 T）输出为响应信息

HttpMessageConverter接口的作用:

• 实现请求的数据转换为Java对象
• 把控制器方法返回的对象转换为json xml text二进制等不同格式的数据
• 常用HttpMessageConverter接口的实现类
  • StringHttpMessageConveter与MappingJackson2HttpMessageConveter

重点:!!!HttpMessageConverter<T>接口定义的方法：

1. boolean canRead(Class<?> clazz,MediaType mediaType):指定转换器可以读取的对象类型，即转换器是否可将请求信息转换为 clazz 类型的对象，同时指定支持 MIME 类型(text/html,applaiction/json 等)
2. boolean canWrite(Class<?> clazz,MediaType mediaType):指定转换器是否可将 clazz 类型的对象写到响应流中，响应流支持的媒体类型在 MediaType 中定义
3. LIst<MediaType> getSupportMediaTypes()：该转换器支持的媒体类型
4. T read(Class<? extends T> clazz,HttpInputMessage inputMessage)：将请求信息流转换为 T 类型的对象
5. void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage)::将 T 类型的对象写到响应流中，同时指定相应的媒体类型为contentType

 框架会根据控制器的返回类型自动查找使用的实现类,默认情况下,springmvc实现了HttpMessageConveter接口的四个实现类,包括StringHttpMessageConveter,所以需要在springmvc配置文件中加入注解驱动<mvc:annotation-driven>加入这个标签后,springmvc项目启动后,会创建HttpMessageConveter接口的7个实现类对象,包括MappingJackson2HttpMessageConveter与StringHttpMessageConveter

4.4.4.2 @ResponseBody

@ReponseBody注解就是把student转换后的json通过HttpServletResponse对象输出给浏览器

		//该注解实现了一下功能!!!
		rep.setContentType("application/jason;charset=utf-8");
        PrintWriter pw = rep.getWriter();
        pw.println(json);
        pw.flush();
        pw.close(); 

4.4.4.3 控制器方法返回对象转为json的步骤

1.pom.xml加入Jackson依赖,springmvc框架默认处理json就是使用Jackson
2.在springmvc的配置文件中,加入注解驱动标签<mvc:annotation-driven>
3.在控制方法的上面加入@ResponseBody注解,表示返回值数据,输出到浏览器

• 声明注解驱动

创建HttpMessageConverter接口的7个实现类对象

<mvc:annotation-driven />

• ajax请求

<script type="text/javascript" src="js/jquery-3.4.1.js"></script>
    <script type="text/javascript">
        $(function (){
            //绑定事件
            $("#btnAjax").on("click",function (){
                $.ajax({
                    url:"doStudentJson.do",
                    data:{
                        name:"Jack",
                        age:22
                    },
                    dataType:"text",
                    success:function (resp){
                        alert("resp = " + resp);
                    }
                })
            })
        })
    </script>

<%--发起ajax请求--%>
<button id="btnAjax">发起Ajax请求</button>

• 控制器方法

//控制器方法返回student=>jason
    @RequestMapping("/doStudentJson.do")
    @ResponseBody
    public Student doAjaxJason(String name,Integer age){
        Student stu = new Student();
        stu.setName("Dick");
        stu.setAge(99);
        return stu;
    }

框架执行过程解析:

• 框架根据控制器方法的返回值类型， 找到HttpMessageConverter接口的实现类,最后找到的是MappingJackson2HttpMessageConverter
• 使用实现类MappingJackson2HttpMessageConverter执行他的write()方法，把student对象转为了json格式的数据
• 框架使用@ResponseBody注解，把上一步中的json输出给浏览器

4.4.4.4 实例之_返回List<T>

//控制器返回List集合
    @RequestMapping("doReturnList.do")
    @ResponseBody
    public List<Student> doReturnList(){
        Student stu1 = new Student();
        List<Student> studentList = new ArrayList<>();
        stu1.setName("Lucy");
        stu1.setAge(25);

        Student stu2 = new Student();
        stu2.setAge(18);
        stu2.setName("Tom");

        studentList.add(stu1);
        studentList.add(stu2);
        return studentList;
    }

4.4.4.5 实例之_返回String数据

1.区分返回值String是数据还是视图:

• 方法上面有@ReponseBody注解就是数据
• 方法上面没有@ResponseBody注解就是视图

2.解决中文，需要使用@RequestMapping的produces属性

• produces属性： 指定content-type的值

3.框架处理String返回值

• 框架使用的StringHttpMessageConverter
• StringHttpMessageConverter使用的是text/plain;charset=ISO-8859-1

content-type: 告诉浏览器， 怎么显示服务器返回的数据

    @RequestMapping(value = "/doReturnString.do",produces = "text/plain;charset=utf-8")
    @ResponseBody
    public String doReturnString(){
        System.out.println("控制器返回String类型!!!");
        String str = "Hello World";
        return str;
    }

4.5 关于<url-pattern/>

4.5.1 *.xxx

在没有特殊要求的情况下，SpringMVC 的中央调度器 DispatcherServlet的<url-pattern/>常使用后辍匹配方式,如写为*.do或者 *.action, *.mvc等

4.5.2 /

• 使用斜杠"/" . 导致中央调度器称为了默认的default servlet
• 因为 DispatcherServlet 会将向静态资源的获取请求，例如.css、.js、.jpg、.png 等资源的获取请求，当作是一个普通的 Controller 请求。中央调度器会调用处理器映射器为其查找相应的处理器
• 默认中央调度器没有处理静态资源的控制器对象， 所以静态资源都是 404

4.5.2.1 解决方案

1. 使用<mvc:resources/>

在 Spring3.0 版本后，Spring 定义了专门用于处理静态资源访问请求的处理器 ResourceHttpRequestHandler。并且添加了<mvc:resources/>标签，专门用于解决静态资源无法访问问题。需要在 springmvc 配置文件中添加如下形式的配置

    <!--声明静态资源的第二种处理方式
        mapping: 访问静态资源的uri地址， 可以使用通配符（**）。
                  ** : 表示任意的目录和目录和资源名称
        location: 静态资源在项目中的位置， 不要使用/WEB-INF目录

    -->
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/html/**" location="/html/" />
    <mvc:resources mapping="/js/**" location="/js/" />

	<!--全部放在一个文件下面设置静态资源-->
    <mvc:resources mapping="/static/**" location="/static/" />

• location: 表示静态资源所在目录。当然，目录不要使用/WEB-INF/及其子目录
• mapping 表示对该资源的请求

2. resources和@RequestMapping使用有冲突

<!--声明注解驱动-->
<mvc:annotation-driven />

五、整合SSM

5.1 整合步骤

1.创建数据库表
2.创建maven web项目
3.在pom.xml文件中导入依赖
4.在web.xml中声明容器对象:

• 声明spring监听器ContextLoaderListener,创建spring容器对象,创建service,dao对象
• 声明springmvc中央调度器DispatcherServlet:创建springmvc容器对象,创建controller对象
• 声明字符集的过滤器 CharacterEncodingFilter,解决Post乱码问题

5.创建程序中的包,dao,service,controller,entity等
6.创建spring,springmvc,mybatis配置文件
7.书写Java代码,实体类,dao接口与mapper文件,service类,controller类
8.创建视图文件