本文来自动力节点springmvc,方便复习使用

文章目录

SpringMVC 概述
第2章 SpringMVC 注解式开发
SSM 整合开发
- 搭建 SSM 开发环境
SpringMVC 核心技术

SpringMVC 概述

SpringMVC 简介

SpringMVC：是基于spring的一个框架， 实际上就是spring的一个模块，专门是做web开发的。理解为servlet的一个升级

web开发底层是servlet ，框架是在servlet基础上面加入一些功能，让你做web开发方便。SpringMVC就是一个Spring。 Spring是容器，ioc能够管理对象。SpringMVC能够创建对象，放入到容器中（SpringMVC容器）， springmvc容器中放的是控制器对象，我们要做的是使用@Contorller创建控制器对象，把对象放入到springmvc容器中，把创建的对象作为控制器使用
这个控制器对象能接收用户的请求，显示处理结果，就当做是一个servlet使用。使用@Controller注解创建的是一个普通类的对象，不是Servlet。 springmvc赋予了控制器对象一些额外的功能。

web开发底层是servlet， springmvc中有一个对象是Servlet ： DispatherServlet(中央调度器)，它负责接收用户的所有请求，用户把请求给了DispatherServlet，之后DispatherServlet把请求转发给我们的Controller对象，最后是Controller对象处理请求。

第一个注解的 SpringMVC 程序

新建web项目，骨架 webapp,web.xml文件的版本记得要改！

pom.xml

在创建好 web 项目后，加入 Servlet 依赖，SpringMVC 依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>

web.xml(较为固定的写法)

 <!--声明，注册springmvc的核心对象DispatcherServlet
        需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
        为什么要创建DispatcherServlet对象的实例呢？
        因为DispatcherServlet在他的创建过程中， 会同时创建springmvc容器对象，
        读取springmvc的配置文件，把这个配置文件中的对象都创建好， 当用户发起
        请求时就可以直接使用对象了。

        servlet的初始化会执行init（）方法。 DispatcherServlet在init（）中{
           //创建容器，读取配置文件
           WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
           //把容器对象放入到ServletContext中
           getServletContext().setAttribute(key, ctx);
        }



        启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml（/WEB-INF/myweb-servlet.xml）
        springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml .
    -->
    <servlet>
        <servlet-name>myweb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--自定义springmvc读取的配置文件的位置-->
        <init-param>
            <!--springmvc的配置文件的位置的属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--在tomcat启动后，创建Servlet对象
            load-on-startup:表示tomcat启动后创建对象的顺序。它的值是整数，数值越小，
                            tomcat创建对象的时间越早。 大于等于0的整数。
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--
            使用框架的时候， url-pattern可以使用两种值
            1. 使用扩展名方式， 语法 *.xxxx , xxxx是自定义的扩展名。 常用的方式 *.do, *.action, *.mvc等等
               不能使用 *.jsp
               http://localhost:8080/myweb/some.do
               http://localhost:8080/myweb/other.do

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

index.jsp show.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
     <p>第一个springmvc项目</p>
     <p><a href="some.do">发起some.do的请求</a> </p>
     <p><a href="other.do">发起other.do的请求</a> </p>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>/WEB-INF/view/show.jsp从request作用域获取数据</h3><br/>
    <h3>msg数据：${msg}</h3><br/>
    <h3>fun数据：${fun}</h3>
</body>
</html>

controller

package ysk.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**
 *  @Controller:创建处理器对象，对象放在springmvc容器中。
 *  位置：在类的上面
 *  和Spring中讲的@Service ,@Component
 *
 *  能处理请求的都是控制器（处理器）： MyController能处理请求，
 *                         叫做后端控制器（back controller）
 *
 *  没有注解之前，需要实现各种不同的接口才能做控制器使用
 */
@Controller
public class MyController {
    /*
       处理用户提交的请求，springmvc中是使用方法来处理的。
       方法是自定义的， 可以有多种返回值， 多种参数，方法名称自定义
     */

    /**
     * 准备使用doSome方法处理some.do请求。
     * @RequestMapping: 请求映射，作用是把一个请求地址和一个方法绑定在一起。
     *                  一个请求指定一个方法处理。
     *       属性： 1. value 是一个String，表示请求的uri地址的（some.do）。
     *                value的值必须是唯一的， 不能重复。 在使用时，推荐地址以“/”
     *       位置：1.在方法的上面，常用的。
     *            2.在类的上面
     *  说明： 使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
     *  使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet, doPost
     *
     *  返回值：ModelAndView 表示本次请求的处理结果
     *   Model: 数据，请求处理完成后，要显示给用户的数据
     *   View: 视图， 比如jsp等等。
     */
    @RequestMapping(value = "/some.do")
     //@RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        mv.setViewName("/show.jsp");
        return mv;
    }
}

修改视图解析器的注册

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

<!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径-->
<bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀：视图文件的路径-->
    <property name="prefix" value="/WEB-INF/view/" />
    <!--后缀：视图文件的扩展名-->
    <property name="suffix" value=".jsp" />
</bean>

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

修改处理器

//指定视图, 指定视图的完整路径
//框架对视图执行的forward操作， request.getRequestDispather("/show.jsp).forward(...)
//mv.setViewName("/show.jsp");
//mv.setViewName("/WEB-INF/view/show.jsp");
//mv.setViewName("/WEB-INF/view/other.jsp");


//当配置了视图解析器后，可以使用逻辑名称（文件名），指定视图
//框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完成路径， 这里就是字符连接操作
///WEB-INF/view/ + show + .jsp
mv.setViewName("show");

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

在这里插入图片描述

SpringMVC 的 MVC 组件

在这里插入图片描述

SpringMVC 执行流程（理解）

流程图:

在这里插入图片描述

执行流程简单分析

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

处理映射器的作用：根据请求，从springmvc容器对象中获取处理器对象

处理器适配器作用：执行处理器方法（调用MyController.dosome（）得到返回值ModelAndview）

视图解析器作用：组成视图完整路径，使用前缀，后缀。并创建view对象。View是一个接口，表示视图的，在框架中jsp，html不是string表示，而是使用View和它的实现类表示视图。

第2章 SpringMVC 注解式开发

@RequestMapping 定义请求规则

指定模块名称

通过@RequestMapping 注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上，也可以注解在类上，但意义是不同的。value 属性值常以“/”开始。

@RequestMapping 的 value 属性用于定义所匹配请求的 URI。但对于注解在方法上与类上，其 value 属性所指定的 URI，意义是不同的。

一个@Controller 所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的 URI 是不同的。这些不同的 URI 被指定在注解于方法之上的@RequestMapping 的 value 属性中。但若这些请求具有相同的 URI 部分，则这些相同的 URI，可以被抽取到注解在类之上的@RequestMapping 的 value 属性中。此时的这个 URI 表示模块的名称。URI 的请求是相对于 Web 的根目录。

想象成提取公因式！

@Controller
@RequestMapping("/test")
public class MyController {

index.jsp:

 <p><a href="test/some.do">发起some.do的请求</a> </p>

对请求提交方式的定义

对于@RequestMapping，其有一个属性 method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该 method 属性指定的提交方式的请求，才会执行该被注解方法。

Method 属性的取值为 RequestMethod 枚举常量。常用的为 RequestMethod.GET 与 RequestMethod.POST，分别表示提交方式的匹配规则为 GET 与 POST 提交。

public class MyController {
    /**
     * @RequestMapping : 请求映射
     *             属性： method， 表示请求的方式。 它的值RequestMethod类枚举值。
     *                    例如表示get请求方式， RequestMethod.GET
     *                    post方式， RequestMethod.POST
     *
     *  你不用get方式，错误是：
     *  HTTP Status 405 - Request method 'GET' not supported
     */
    //指定some.do使用get请求方式
    @RequestMapping(value = "/first.do",method = RequestMethod.GET)

客户端浏览器常用的请求方式，及其提交方式有以下几种：

在这里插入图片描述

处理器方法的参数

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

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

public ModelAndView doFirst(HttpServletRequest request,
                                HttpServletResponse response,
                                HttpSession session){
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","====欢迎使用springmvc做web开发====" + request.getParameter("name"));

逐个参数接收

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

@Controller
public class MyController {


    /**
     * 逐个接收请求参数：
     *   要求： 处理器（控制器）方法的形参名和请求中参数名必须一致。
     *          同名的请求参数赋值给同名的形参
     * 框架接收请求参数
     *   1. 使用request对象接收请求参数
     *      String strName = request.getParameter("name");
     *      String strAge = request.getParameter("age");
     *   2. springmvc框架通过 DispatcherServlet 调用 MyController的doSome()方法
     *      调用方法时，按名称对应，把接收的参数赋值给形参
     *      doSome（strName，Integer.valueOf(strAge)）
     *      框架会提供类型转换的功能，能把String转为 int ，long ， float， double等类型。
     *
     *  400状态码是客户端错误， 表示提交请求参数过程中，发生了问题。
     */
    @RequestMapping(value = "/receiveproperty.do")
    public ModelAndView doSome(String name, Integer age){
        System.out.println("doSome, name="+name+"   age="+age);
        //可以在方法中直接使用 name ， age
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",Integer.valueOf(age));
        //show是视图文件的逻辑名称（文件名称）
        mv.setViewName("show");
        return mv;
    }
}

请求参数中文乱码问题

对于前面所接收的请求参数，若含有中文，则会出现中文乱码问题(get不会，post会)。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>
    <!--强制请求对象（HttpServletRequest）使用encoding编码的值-->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    <!--强制应答对象（HttpServletResponse）使用encoding编码的值-->
    <init-param>
        <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>

校正请求参数名@RequestParam

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

index.jsp:

<br/>
<p>请求参数名和处理器方法的形参名不一样</p>
<form action="receiveparam.do" method="post">
    姓名：<input type="text" name="rname"> <br/>
    年龄：<input type="text" name="rage"> <br/>
    <input type="submit" value="提交参数">
</form>
<br/>

 /**
     * 请求中参数名和处理器方法的形参名不一样
     * @RequestParam: 用在逐个接收请求参数中（对象没有意义）， 解决请求中参数名形参名不一样的问题
     *      属性： 1. value 请求中的参数名称
     *            2. required 是一个boolean，默认是true
     *                true：表示请求中必须包含此参数(rname,rage)。
     *      位置： 在处理器方法的形参定义的前面
     */
    @RequestMapping(value = "/receiveparam.do")
    public ModelAndView receiveParam(@RequestParam(value = "rname",required = false) String name,
                                     @RequestParam(value = "rage",required = false) Integer age){
        System.out.println("doSome, name="+name+"   age="+age);
        //可以在方法中直接使用 name ， age
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        //show是视图文件的逻辑名称（文件名称）
        mv.setViewName("show");
        return mv;
    }

对象参数接收

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

定义类 Student：

public class Student {
    private String name;
    private Integer age;
}

index.jsp:

<p>使用java对象接收请求参数</p>
<form action="receiveobject.do" method="post">
    姓名：<input type="text" name="name"> <br/>
    年龄：<input type="text" name="age"> <br/>
    <input type="submit" value="提交参数">
</form>

 /**
     * 处理器方法形参是java对象， 这个对象的属性名和请求中参数名一样的
     * 框架会创建形参的java对象， 给属性赋值。 请求中的参数是name，框架会调用setName()
     * @return
     */
    @RequestMapping(value = "/receiveobject.do")
    public ModelAndView receiveParam( Student myStudent){
        System.out.println("receiveParam, name="+myStudent.getName()+"   age="+myStudent.getAge());
        //可以在方法中直接使用 name ， age
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("myname",myStudent.getName());
        mv.addObject("myage",myStudent.getAge());
        mv.addObject("mystudent",myStudent);
        //show是视图文件的逻辑名称（文件名称）
        mv.setViewName("show");
        return mv;
    }

对象参数接收

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

定义类 Student：

public class Student {
    private String name;
    private Integer age;
}

index.jsp:

<p>使用java对象接收请求参数</p>
<form action="receiveobject.do" method="post">
    姓名：<input type="text" name="name"> <br/>
    年龄：<input type="text" name="age"> <br/>
    <input type="submit" value="提交参数">
</form>

 /**
     * 处理器方法形参是java对象， 这个对象的属性名和请求中参数名一样的
     * 框架会创建形参的java对象， 给属性赋值。 请求中的参数是name，框架会调用setName()
     * @return
     */
    @RequestMapping(value = "/receiveobject.do")
    public ModelAndView receiveParam( Student myStudent){
        System.out.println("receiveParam, name="+myStudent.getName()+"   age="+myStudent.getAge());
        //可以在方法中直接使用 name ， age
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("myname",myStudent.getName());
        mv.addObject("myage",myStudent.getAge());
        mv.addObject("mystudent",myStudent);
        //show是视图文件的逻辑名称（文件名称）
        mv.setViewName("show");
        return mv;
    }

处理器方法的返回值

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

第一种：ModelAndView
第二种：String
第三种：无返回值 void
第四种：返回自定义类型对象

根据不同的情况，使用不同的返回值。

返回 ModelAndView

若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回 ModelAndView 比较好。当然，若要返回 ModelAndView，则处理器方法中需要定义 ModelAndView 对象。

在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转（如对页面的 Ajax 异步响应），此时若返回 ModelAndView，则将总是有一部分多余：要么 Model 多余，要么 View 多余。即此时返回 ModelAndView 将不合适。

返回 String

处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器解析可以将其转换为物理视图地址。

<!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径-->
    <bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/" />
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp" />
    </bean>

/**
     * 处理器方法返回String--表示逻辑视图名称，需要配置视图解析器
     */
@RequestMapping(value = "/returnString-view.do")
public String doReturnView(HttpServletRequest request,String name, Integer age){
    System.out.println("doReturnView, name="+name+"   age="+age);
    //可以自己手工添加数据到request作用域
    request.setAttribute("myname",name);
    request.setAttribute("myage",age);
    // show : 逻辑视图名称，项目中配置了视图解析器
    // 框架对视图执行forward转发操作
    return "show";
}

返回 void（了解）

对于处理器方法返回 void 的应用场景，AJAX 响应.

若处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回 void。

例如，对于 AJAX 的异步请求的响应。

maven 加入 jackson 依赖

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

<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 库

由于本项目要使用 jQuery 的 ajax()方法提交 AJAX 请求，所以项目中需要引入 jQuery 的库。在 WebRoot 下新建一个 Folder（文件夹），命名为 js，并将 jquery-1.11.1.js 文件放入其中。

当然，该 jQuery 库文件，需要在使用 ajax()方法的 index 页面中引入。
```
<script type="text/javascript" src="js/jquery-3.4.1.js"></script>
```

index.jsp

index 页面由两部分内容构成：一个是，用于提交 AJAX 请求；一个是，用于处理 AJAX 请求。（其他返回值也是这个前端页面）

<head>
    <title>Title</title>
     <script type="text/javascript" src="js/jquery-3.4.1.js"></script>
     <script type="text/javascript">
         $(function(){
             $("button").click(function(){
                 //alert("button click");
                 $.ajax({
                     //url:"returnVoid-ajax.do",
                     //url:"returnStudentJsonArray.do",
                     url:"returnStringData.do",
                     data:{
                         name:"zhangsan",
                         age:20
                     },
                     type:"post",
                     dataType:"text",
                     //dataType:"json",
                     success:function(resp){
                         //resp从服务器端返回的是json格式的字符串 {"name":"zhangsan","age":20}
                         //jquery会把字符串转为json对象， 赋值给resp形参。

                         // [{"name":"李四同学","age":20},{"name":"张三","age":28}]
                         //alert(resp.name + "    "+resp.age);

                         /*$.each(resp,function(i,n){
                             alert(n.name+"   "+n.age)
                         })*/
                         alert("返回的是文本数据："+resp);

                     }
                 })
             })
         })
     </script>
</head>

<body>
	<button id="btn">发起ajax请求</button>
</body>

修改处理器类 MyController

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

以逐个方式接收参数：

//处理器方法返回void， 响应ajax请求
//手工实现ajax，json数据： 代码有重复的 1. java对象转为json； 2. 通过HttpServletResponse输出json数据
@RequestMapping(value = "/returnVoid-ajax.do")
public void doReturnVoidAjax(HttpServletResponse response, String name, Integer age) throws IOException {
    System.out.println("===doReturnVoidAjax====, name="+name+"   age="+age);
    //处理ajax， 使用json做数据的格式
    //service调用完成了， 使用Student表示处理结果
    Student student  = new Student();
    student.setName("张飞同学");
    student.setAge(28);

    String json = "";
    //把结果的对象转为json格式的数据
    if( student != null){
        ObjectMapper om  = new ObjectMapper();
        json  = om.writeValueAsString(student);
        System.out.println("student转换的json===="+json);
    }

    //输出数据，响应ajax的请求
    response.setContentType("application/json;charset=utf-8");
    PrintWriter pw  = response.getWriter();
    pw.println(json);
    pw.flush();
    pw.close();

}

返回对象 Object

现在做ajax， 主要使用json的数据格式。 实现步骤：
   1.加入处理json的工具库的依赖， springmvc默认使用的jackson。
   2.在sprigmvc配置文件之间加入 <mvc:annotation-driven> 注解驱动。
     json  = om.writeValueAsString(student);
   3.在处理器方法的上面加入@ResponseBody注解

处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer，String，自定义对象， Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。

返回对象，需要使用@ResponseBody注解，将转换后的 JSON 数据放入到响应体中。

maven pom.xml

由于返回 Object 数据，一般都是将数据转化为了 JSON 对象后传递给浏览器页面的。而这个由 Object 转换为 JSON，是由 Jackson 工具完成的。所以需要导入 Jackson 的相关 Jar 包。

<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>

声明注解驱动

将 Object 数据转化为 JSON 数据，需要由消息转换器 HttpMessageConverter 完成。而转换器的开启，需要由来完成。

SpringMVC 使用消息转换器实现请求数据和对象，处理器方法返回对象和响应输出之间的自动转换

当 Spring 容器进行初始化过程中，在处创建注解驱动时，默认创建了七个 HttpMessageConverter 对象。也就是说，我们注册，就是为了让容器为我们创建 HttpMessageConverter 对象。

HttpMessageConverter接口：消息转换器。
功能：定义了java转为json，xml等数据格式的方法。这个接口有很多的实现类。
这些实现类完成 java对象到json， java对象到xml，java对象到二进制数据的转换
```

<mvc:annotation-driven />
```

controller

 /**
     * 处理器方法返回一个Student，通过框架转为json，响应ajax请求
     * @ResponseBody:
     *    作用：把处理器方法返回对象转为json后，通过HttpServletResponse输出给浏览器。
     *    位置：方法的定义上面。 和其它注解没有顺序的关系。
     * 返回对象框架的处理流程：
     *  1. 框架会把返回Student类型，调用框架的中ArrayList<HttpMessageConverter>中每个类的canWrite()方法
     *     检查那个HttpMessageConverter接口的实现类能处理Student类型的数据--MappingJackson2HttpMessageConverter
     *
     *  2.框架会调用实现类的write（）， MappingJackson2HttpMessageConverter的write()方法
     *    把李四同学的student对象转为json， 调用Jackson的ObjectMapper实现转为json
     *    contentType: application/json;charset=utf-8
     *
     *  3.框架会调用@ResponseBody把2的结果数据输出到浏览器， ajax请求处理完成
     */
    @RequestMapping(value = "/returnStudentJson.do")
    @ResponseBody
    public Student doStudentJsonObject(String name, Integer age) {
        //调用service，获取请求结果数据 ， Student对象表示结果数据
        Student student = new Student();
        student.setName("李四同学");
        student.setAge(20);
        return student; // 会被框架转为json

    }

返回 List 集合

 /**
     *  处理器方法返回List<Student>
     * 返回对象框架的处理流程：(和上述几乎一致)
     *  1. 框架会把返回List<Student>类型，调用框架的中ArrayList<HttpMessageConverter>中每个类的canWrite()方法
     *     检查那个HttpMessageConverter接口的实现类能处理Student类型的数据--MappingJackson2HttpMessageConverter
     *
     *  2.框架会调用实现类的write（）， MappingJackson2HttpMessageConverter的write()方法
     *    把李四同学的student对象转为json， 调用Jackson的ObjectMapper实现转为json array
     *    contentType: application/json;charset=utf-8
     *
     *  3.框架会调用@ResponseBody把2的结果数据输出到浏览器， ajax请求处理完成
     */
    @RequestMapping(value = "/returnStudentJsonArray.do")
    @ResponseBody
    public List<Student> doStudentJsonObjectArray(String name, Integer age) {

        List<Student> list = new ArrayList<>();
        //调用service，获取请求结果数据 ， Student对象表示结果数据
        Student student = new Student();
        student.setName("李四同学");
        student.setAge(20);
        list.add(student);

        student = new Student();
        student.setName("张三");
        student.setAge(28);
        list.add(student);


        return list;

    }

返回字符串对象

若要返回非中文字符串，将前面返回数值型数据的返回值直接修改为字符串即可。但若返回的字符串中带有中文字符，则接收方页面将会出现乱码。此时需要使用 @RequestMapping 的 produces 属性指定字符集。

注意：ajax中的dataType要改为：text 或者删除dataType

 /**
     * 处理器方法返回的是String ， String表示数据的，不是视图。
     * 区分返回值String是数据，还是视图，看有没有@ResponseBody注解
     * 如果有@ResponseBody注解，返回String就是数据，反之就是视图
     *
     * 默认使用“text/plain;charset=ISO-8859-1”作为contentType,导致中文有乱码，
     * 解决方案：给RequestMapping增加一个属性 produces, 使用这个属性指定新的contentType.
     * 返回对象框架的处理流程：
     *  1. 框架会把返回String类型，调用框架的中ArrayList<HttpMessageConverter>中每个类的canWrite()方法
     *     检查那个HttpMessageConverter接口的实现类能处理String类型的数据--StringHttpMessageConverter
     *
     *  2.框架会调用实现类的write（）， StringHttpMessageConverter的write()方法
     *    把字符按照指定的编码处理 text/plain;charset=ISO-8859-1
     *
     *  3.框架会调用@ResponseBody把2的结果数据输出到浏览器， ajax请求处理完成
     */
    @RequestMapping(value = "/returnStringData.do",produces = "text/plain;charset=utf-8")
    @ResponseBody
    public String doStringData(String name,Integer age){
        return "Hello SpringMVC 返回对象，表示数据";
    }

静态资源访问

配置详解

*.do

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

可以写为/，因为 DispatcherServlet 会将向静态资源的获取请求，例如.css、.js、.jpg、.png 等资源的获取请求，当作是一个普通的 Controller 请求。中央调度器会调用处理器映射器为其查找相应的处理器。当然也是找不到的，所以在这种情况下，所有的静态资源获取请求也均会报 404 错误。

在项目中添加图片：在项目的 WebRoot 下添加一个目录 images，并在其中添加一张图片资源。

修改 index 页面：

 <img src="images/p3.jpg" alt="我是一个静态资源，不能显示">

修改<url-pattern/>的值:

保持的值为 *.do，扩展名方式，图片会正常显示。

静态资源访问

<url-pattern/>的值并不是说写为/后，静态资源就无法访问了。经过一些配置后，该问题也是可以解决的。

使用<mvc:default-servlet-handler/>

声明了 <mvc:default-servlet-handler />后， springmvc 框架会在容器中创建 DefaultServletHttpRequestHandler 处理器对象。它会像一个检查员，对进入 DispatcherServlet 的 URL 进行筛查，如果发现是静态资源的请求，就将该请求转由 Web 应用服务器默认的 Servlet 处理。一般的服务器都有默认的 Servlet。

在 Tomcat 中，有一个专门用于处理静态资源访问的 Servlet 名叫 DefaultServlet。其为 <servlet-name/>default。可以处理各种静态资源访问请求。该 Servlet 注册在 Tomcat 服务器的 web.xml 中。

在这里插入图片描述

只需要在 springmvc.xml 中添加<mvc:default-servlet-handler/>标签即可。

<!--第一种处理静态资源的方式：
        需要在springmvc配置文件加入 <mvc:default-servlet-handler>
        原理是： 加入这个标签后，框架会创健控制器对象DefaultServletHttpRequestHandler（类似我们自己创建的MyController）.
        DefaultServletHttpRequestHandler这个对象可以把接收的请求转发给 tomcat的default这个servlet。
    -->
<mvc:default-servlet-handler />

使用<mvc:resources/>（掌握）

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

 <!--第二种处理静态资源的方式
        mvc:resources 加入后框架会创建 ResourceHttpRequestHandler这个处理器对象。
        让这个对象处理静态资源的访问，不依赖tomcat服务器。
        mapping:访问静态资源的uri地址， 使用通配符 **
        location：静态资源在你的项目中的目录位置。

        images/**:表示 images/p1.jpg  , images/user/logo.gif , images/order/history/list.png
    -->
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/html/**" location="/html/" />
    <mvc:resources mapping="/js/**" location="/js/" />

    <!--mvc:resources和@RequestMapping有一定的冲突-->
    <mvc:annotation-driven />

    <!--使用一个配置语句，指定多种静态资源的访问(程序开发中，多为这样写法)-->
    <!--<mvc:resources mapping="/static/**" location="/static/" />-->

index.jsp:

<img src="images/p3.jpg" alt="我是一个静态资源，不能显示">
<img src="static/images/p1.jpg">

地址的相关问题

地址分类

绝对地址，带有协议名称的是绝对地址， http://www.baidu.com , ftp://202.122.23.1
相对地址，没有协议开头的，例如 user/some.do , /user/some.do

相对地址不能独立使用，必须有一个参考地址。通过参考地址+相对地址本身才能指定资源。（张三同学， 1班有张三， 2班也有张三）
参考地址
1. 在你的页面中的，访问地址不加 “/”
```
<a href="user/some.do">发起请求</a> </p>
```
  访问的是： http://localhost:8080/ch06_path/index.jsp
  
  路径： http://localhost:8080/ch06_path/ 资源： index.jsp
  
  在index.jsp发起 user/some.do请求，访问地址变为 http://localhost:8080/ch06_path/user/some.do
  
  当你的地址没有斜杠开头,例如 user/some.do , 当你点击链接时，访问地址是当前页面的地址加上链接的地址。
  
  http://localhost:8080/ch06_path/ + user/some.do
  
  问题：
  
  index.jsp 访问 user/some.do ，访问后现在的地址： http://localhost:8080/ch06_path/user/some.do
  
  路径： http://localhost:8080/ch06_path/user/
  资源： some.do
  
  改动代码：去掉视图解析器: mv.setViewName("/show.jsp");
  
  就变为 http://localhost:8080/ch06_path/user/user/some.do
  
  解决方案：
  - 加入${pageContext.request.contextPath}(每句话都要加，麻烦)
  - 加入一个base标签，是html语言中的标签。表示当前页面中访问地址的基地址。你的页面中所有没有“/”开头的地址，都是以base标签中的地址为参考地址，使用base中的地址 + user/some.do 组成访问地址。
    
    [HTML<base> 标签](html base标签)
```
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<html>
<head>
    <title>Title</title>
    <base href="<%=basePath%>" />
</head>
<body>
     <p>第一个springmvc项目</p>
     <p><a href="user/some.do">发起user/some.do的get请求</a> </p>
     <br/>


</body>
</html>
```
2. 在你的页面中，访问地址加 “/”
  
  访问的是： http://localhost:8080/ch06_path/index.jsp
  
  路径： http://localhost:8080/ch06_path/
  
  资源： index.jsp
  
  点击 /user/some.do, 访问地址变为 http://localhost:8080/user/some.do
  
  参考地址是你的服务器地址，也就是 http://localhost:8080
  
  如果你的资源不能访问：加入${pageContext.request.contextPath}
```
<a href="${pageContext.request.contextPath}/user/some.do">发起user/some.do的get请求</a>
```

SSM 整合开发

SSM 编程，即 SpringMVC + Spring + MyBatis 整合(可以认为springmvc对应视图层，spring对应service层，mybatis对应dao层)，是当前最为流行的 JavaEE 开发技术架构。其实 SSM 整合的实质，仅仅就是将 MyBatis整合入 Spring。因为 SpringMVC原本就是 Spring 的一部分，不用专门整合。

SSM 整合的实现方式可分为两种：基于 XML 配置方式，基于注解方式。

SpringMVC:视图层，界面层，负责接收请求，显示处理结果的。
Spring：业务层，管理service，dao，工具类对象的。
MyBatis：持久层， 访问数据库的

用户发起请求--SpringMVC接收--Spring中的Service对象--MyBatis处理数据

SSM整合也叫做SSI (IBatis也就是mybatis的前身)， 整合中有容器。
1.第一个容器SpringMVC容器， 管理Controller控制器对象的。
2.第二个容器Spring容器，管理Service，Dao,工具类对象的
我们要做的把使用的对象交给合适的容器创建，管理。 把Controller还有web开发的相关对象
交给springmvc容器， 这些web用的对象写在springmvc配置文件中

service，dao对象定义在spring的配置文件中，让spring管理这些对象。

springmvc容器和spring容器是有关系的，关系已经确定好了
springmvc容器是spring容器的子容器， 类似java中的继承。 子可以访问父的内容
在子容器中的Controller可以访问父容器中的Service对象， 就可以实现controller使用service对象

搭建 SSM 开发环境

实现步骤：
0.使用springdb的mysql库， 表使用student（id auto_increment, name, age）
1.新建maven web项目
2.加入依赖
  springmvc，spring，mybatis三个框架的依赖，jackson依赖，mysql驱动，druid连接池
  jsp，servlet依赖

3.写web.xml
  1)注册DispatcherServlet ,目的：1.创建springmvc容器对象，才能创建Controller类对象。
                                2.创建的是Servlet，才能接受用户的请求。

  2）注册spring的监听器：ContextLoaderListener,目的： 创建spring的容器对象，才能创建service，dao等对象。

  3）注册字符集过滤器，解决post请求乱码的问题


4.创建包， Controller包， service ，dao，实体类包名创建好

5.写springmvc，spring，mybatis的配置文件
 1）springmvc配置文件
 2）spring配置文件
 3）mybatis主配置文件
 4）数据库的属性配置文件

6.写代码， dao接口和mapper文件， service和实现类，controller， 实体类。
7.写jsp页面

新建meaven，骨架选择webapp。

数据库springdb，表student

在这里插入图片描述

maven pom.xml

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <!-- jsp依赖 -->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2.1-b03</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <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>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
  </dependencies>

  <build>
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

配置 web.xml

配置中央调度器

配置中央调度器时需要注意，SpringMVC的配置文件名与其它 Spring配置文件名不相同。这样做的目的是 Spring 容器创建管理 Spring 配置文件中的 bean， SpringMVC 容器中负责视图层 bean 的初始。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
<!--  中央调度器-->
  <servlet>
    <servlet-name>myweb</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  
    <init-param>
      <param-name>contextConfigLocation</param-name>
       <!--指定自定义文件的位置,在resources目录下创建conf目录-->
      <param-value>classpath:conf/springmvc.xml</param-value>
    </init-param>
    
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>myweb</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

<!--注册spring的监听器-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:conf/applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

注册字符集过滤器

<!--注册声明过滤器，解决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>
    <!--强制请求对象（HttpServletRequest）使用encoding编码的值-->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    <!--强制应答对象（HttpServletResponse）使用encoding编码的值-->
    <init-param>
        <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>

定义包，组织程序的结构。

在这里插入图片描述

编写配置文件

Jdbc 属性配置文件 jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/springdb
jdbc.username=root
jdbc.passwd=123
jdbc.max=30

Spring 配置文件 applicationContext.xml

<?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:property-placeholder location="classpath:conf/jdbc.properties"/>

    <!--声明数据源DataSource, 作用是连接数据库的-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/><!--setUrl()-->
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.passwd}"/>
        <property name="maxActive" value="${jdbc.max}"/>
    </bean>

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"/>
        <property name="configLocation" value="classpath:conf/mybatis.xml"/>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="ysk.dao"/>
    </bean>

    <!--声明service的注解@Service所在的包名位置-->
    <context:component-scan base-package="ysk.service" />
</beans>

Springmvc 配置文件：springmvc.xml

<?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="ysk.controller"/>

    <!--声明 springmvc框架中的视图解析器-->
    <bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/" />
        <property name="suffix" value=".jsp" />
    </bean>
    
    <mvc:annotation-driven />
    <!--
      1. 响应ajax请求，返回json
      2. 解决静态资源访问问题。
    -->
</beans>

mybatis主配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--settings：控制mybatis全局行为-->
    <settings>
        <!--设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!--设置别名-->
    <typeAliases>
        <!--name:实体类所在的包名
            表示ysk.domain包中的列名就是别名
            你可以使用Student表示ysk.domain.Student
        -->
        <package name="ysk.domain"/>
    </typeAliases>


    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--
          name：是包名， 这个包中的所有mapper.xml一次都能加载
        -->
        <package name="ysk.dao"/>
    </mappers>
</configuration>

实体类

public class Student {
    private Integer id;
    private String name;
    private String email;
    private Integer age;
}

dao接口和映射文件

List<Student> selectAllStudent();
int insertStudent(Student student);

<mapper namespace="ysk.dao.StudentDao">
<!--    已定义别名-->
    <select id="selectAllStudents" resultType="Student">
       select id,name,age from student2
    </select>

    <insert id="insertStudent">
        insert  into student2(name,age) values (#{name},#{age})
    </insert>
</mapper>

service接口和实现类

int addStudent(Student student);
List<Student> findStudents();

@Service
public class StudentServiceImpl implements StudentService {

    @Resource
    private StudentDao dao;

    @Override
    public List<Student> findStudents() {
        return dao.selectAllStudent();
    }

    @Override
    public int addStudent(Student student) {
        return dao.insertStudent(student);
    }
}

处理器定义

@Controller
@RequestMapping("/student")
public class StudentController {

    @Resource
    private StudentService service;

    @RequestMapping("/addStudent.do")
    public ModelAndView addStudent(Student student){
        String tips = "注册失败！";
        ModelAndView mv =  new ModelAndView();
        int nums = service.addStudent(student);
        if( nums > 0 ){
            //注册成功
            tips = "学生【" + student.getName() + "】注册成功";
        }
        mv.addObject("tips",tips);
        mv.setViewName("result");
        return mv;
    }

    @RequestMapping("/queryStudent.do")
    @ResponseBody
    public List<Student> queryStudent(){
        List<Student> list = service.findStudents();
        return list;
    }
}

首页文件 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<html>
<head>
    <title>功能入口</title>
    <base href="<%=basePath%>" />
</head>
<body>
<div align="center">
    <p>SSM整合的例子</p>
    <table>
        <tr>
            <td><a href="addStudent.jsp"> 注册学生</a></td>
        </tr>
        <tr>
            <td><a href="listStudent.jsp">浏览学生</a></td>
        </tr>
    </table>
</div>

</body>
</html>

注册学生页面 — addStudent.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>

<html>
<head>
    <title>注册学生</title>
    <base href="<%=basePath%>" />
</head>
<body>
    <div align="center">
        <form action="student/addStudent.do" method="post">
            <table>
                <tr>
                    <td>姓名：</td>
                    <td><input type="text" name="name"></td>
                </tr>
                <tr>
                    <td>年龄：</td>
                    <td><input type="text" name="age"></td>
                </tr>
                <tr>
                    <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</td>
                    <td><input type="submit" value="注册"></td>
                </tr>
            </table>
        </form>
    </div>
</body>
</html>

浏览学生页面 — listStudent.jsp

<body>
    <div align="center">
        <table>
            <thead>
             <tr>
                 <td>学号</td>
                 <td>姓名</td>
                 <td>年龄</td>
             </tr>
            </thead>
            <tbody id="info">

            </tbody>
        </table>
        <input type="button" id="btnLoader" value="查询数据">
        <select id="country">
            <option value="1">中国</option>
            <option value="2">俄罗斯</option>
            <option value="3">西班牙</option>
        </select>
    </div>
</body>

引入 JQuery:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<html>
<head>
    <title>查询学生ajax</title>
    <base href="<%=basePath%>" />
    <script type="text/javascript" src="js/jquery-3.4.1.js"></script>

js 发起 ajax:

 function loadStudentData(){
            $.ajax({
                url:"student/queryStudent.do",
                type:"get",
                dataType:"json",
                success:function(data){
                    //清除旧的数据
                    $("#info").html("");
                    //增加新的数据
                    $.each(data,function(i,n){
                        $("#info").append("<tr>")
                            .append("<td>"+n.id+"</td>")
                            .append("<td>"+n.name+"</td>")
                            .append("<td>"+n.age+"</td>")
                            .append("</tr>")

                    })
                }
            })
        }

SpringMVC 核心技术

请求重定向和转发

当处理器对请求处理完毕后，向其它资源进行跳转时，有两种跳转方式：请求转发与重定向。而根据所要跳转的资源类型，又可分为两类：跳转到页面与跳转到其它处理器。

注意，对于请求转发的页面，可以是WEB-INF中页面；而重定向的页面，是不能为WEB-INF 中页的。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资源的。

在这里插入图片描述

SpringMVC 框架把原来 Servlet 中的请求转发和重定向操作进行了封装。现在可以使用简单的方式实现转发和重定向。

forward:表示转发，实现 request.getRequestDispatcher(“xx.jsp”).forward()

redirect:表示重定向，实现 response.sendRedirect(“xxx.jsp”)

请求转发

处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 forward:，且此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图（即有视图解析器时转发的是添加了前后缀的路径，而用forward可以转发到别的路径）。视图页面必须写出相对于项目根的路径。forward 操作不需要视图解析器。

处理器方法返回 String,在视图路径前面加入 forward: 视图完整路径。

/**
     * 处理器方法返回ModelAndView,实现转发forward
     * 语法： setViewName("forward:视图文件完整路径")
     * forward特点： 不和视图解析器一同使用，就当项目中没有视图解析器
     */
    @RequestMapping(value = "/doForward.do")
    public ModelAndView doSome(){
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        //显示转发
        //mv.setViewName("forward:/WEB-INF/view/show.jsp");

        mv.setViewName("forward:/hello.jsp"); //根目录下的hello.jsp
        return mv;
    }

请求重定向

在处理器方法返回的视图字符串的前面添加 redirect:，则可实现重定向跳转。

处理器方法定义：

/**
     * 处理器方法返回ModelAndView,实现重定向redirect
     * 语法：setViewName("redirect:视图完整路径")
     * redirect特点： 不和视图解析器一同使用，就当项目中没有视图解析器
     *
     * 框架对重定向的操作：
     * 1.框架会把Model中的简单类型的数据，转为string使用，作为hello.jsp的get请求参数使用。
     *   目的是在 doRedirect.do 和 hello.jsp 两次请求之间传递数据
     *
     * 2.在目标hello.jsp页面可以使用参数集合对象 ${param}获取请求参数值
     *    ${param.myname}
     *
     * 3.重定向不能访问/WEB-INF资源
     */
    @RequestMapping(value = "/doRedirect.do")
    public ModelAndView doWithRedirect(String name,Integer age){
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        //数据放入到 request作用域
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        //重定向
        //mv.setViewName("redirect:/hello.jsp");
        //http://localhost:8080/ch08_forard_redirect/hello.jsp?myname=lisi&myage=22

        //重定向不能访问/WEB-INF资源
        mv.setViewName("redirect:/WEB-INF/view/show.jsp");
        return mv;
    }

异常处理

异常处理步骤：
1.新建maven web项目
2.加入依赖
3.新建一个自定义异常类 MyUserException , 再定义它的子类NameException ,AgeException
4.在controller抛出NameException , AgeException
5.创建一个普通类，作用全局异常处理类
  1）在类的上面加入@ControllerAdvice
  2) 在类中定义方法，方法的上面加入@ExceptionHandler
6.创建处理异常的视图页面
7.创建springmvc的配置文件
 1）组件扫描器 ，扫描@Controller注解
 2）组件扫描器，扫描@ControllerAdvice所在的包名
 3）声明注解驱动

@ExceptionHandler 注解

使用注解@ExceptionHandler 可以将一个方法指定为异常处理方法。该注解只有一个可选属性 value，为一个 Class<?>数组，用于指定该注解的方法所要处理的异常类，即所要匹配的异常。

而被注解的方法，其返回值可以是 ModelAndView、String，或 void，方法名随意，方法参数可以是 Exception 及其子类对象、HttpServletRequest、HttpServletResponse 等。系统会自动为这些方法参数赋值。

对于异常处理注解的用法，也可以直接将异常处理方法注解于 Controller 之中。

自定义异常类

定义三个异常类：NameException、AgeException、MyUserException。其中 MyUserException 是另外两个异常的父

//当年龄有问题时，抛出的异常
public class AgeException extends MyUserException {
    public AgeException() {
        super();
    }

    public AgeException(String message) {
        super(message);
    }
}

//表示当用户的姓名有异常，抛出NameException
public class NameException extends MyUserException {
    public NameException() {
        super();
    }

    public NameException(String message) {
        super(message);
    }
}

public class MyUserException extends Exception {
    public MyUserException() {
        super();
    }

    public MyUserException(String message) {
        super(message);
    }
}

修改 Controller 抛出异常

/**
 * @RequestMapping:
 *    value ： 所有请求地址的公共部分，叫做模块名称
 *    位置： 放在类的上面
 */
@Controller
public class MyController {


    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age) throws MyUserException {
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();

        //try {
            //根据请求参数抛出异常
            if (!"zs".equals(name)) {
                throw new NameException("姓名不正确！！！");
            }

            if (age == null || age > 80) {
                throw new AgeException("年龄比较大！！！");
            }

        //}catch(Exception e){
        //   e.printStackTrace();
        //}

        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

定义异常响应页面

index.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<html>
<head>
    <title>Title</title>
    <base href="<%=basePath%>" />
</head>
<body>

     <p>处理异常的，全局异常处理</p>
    <form action="some.do" method="post">
        姓名：<input type="text" name="name"> <br/>
        年龄：<input type="text" name="age"> <br/>
        <input type="submit" value="提交请求">
    </form>

</body>
</html>

ageError.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
   ageError.jsp <br/>
   提示信息：${msg} <br/>
   系统异常消息：${ex.message}

</body>
</html>

default.jsp:

<html>
<head>
    <title>Title</title>
</head>
<body>
   defaultError.jsp <br/>
   提示信息：${msg} <br/>
   系统异常消息：${ex.message}

</body>
</html>

nameError.jsp:

<html>
<head>
    <title>Title</title>
</head>
<body>
   nameError.jsp <br/>
   提示信息：${msg} <br/>
   系统异常消息：${ex.message}

</body>
</html>

定义全局异常处理类

/**
 * @ControllerAdvice : 控制器增强（也就是说给控制器类增加功能--异常处理功能）
 *           位置：在类的上面。
 *  特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件声明组件扫描器。
 *  指定@ControllerAdvice所在的包名
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法，处理发生的异常
    /*
        处理异常的方法和控制器方法的定义一样， 可以有多个参数，可以有ModelAndView,
        String, void,对象类型的返回值

        形参：Exception，表示Controller中抛出的异常对象。
        通过形参可以获取发生的异常信息。

        @ExceptionHandler(异常的class)：表示异常的类型，当发生此类型异常时，
        由当前方法处理
     */

    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception exception){
        //处理NameException的异常。
        /*
           异常发生处理逻辑：
           1.需要把异常记录下来， 记录到数据库，日志文件。
             记录日志发生的时间，哪个方法发生的，异常错误内容。
           2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
           3.给用户友好的提示。
         */
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","姓名必须是zs，其它用户不能访问");
        mv.addObject("ex",exception);
        mv.setViewName("nameError");
        return mv;
    }


    //处理AgeException
    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeException(Exception exception){
        //处理AgeException的异常。
       
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","你的年龄不能大于80");
        mv.addObject("ex",exception);
        mv.setViewName("ageError");
        return mv;
    }

    //处理其它异常， NameException, AgeException以外，可能会出现不知类型的异常
    @ExceptionHandler
    public ModelAndView doOtherException(Exception exception){
        //处理其它异常
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","你的年龄不能大于80");
        mv.addObject("ex",exception);
        mv.setViewName("defaultError");
        return mv;
    }
}

定义 Spring 配置文件

<!--声明组件扫描器-->
<context:component-scan base-package="com.bjpowernode.controller" />

<!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径-->
<bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀：视图文件的路径-->
    <property name="prefix" value="/WEB-INF/view/" />
    <!--后缀：视图文件的扩展名-->
    <property name="suffix" value=".jsp" />
</bean>


<!--处理需要的两步-->
<context:component-scan base-package="com.bjpowernode.handler" />
<mvc:annotation-driven />

拦截器

SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。

拦截器的使用步骤：
 1.定义类实现HandlerInterceptor接口
 2.在springmvc配置文件中，声明拦截器， 让框架知道拦截器的存在。

拦截器的执行时间：
  1）在请求处理之前， 也就是controller类中的方法执行之前先被拦截。
  2）在控制器方法执行之后也会执行拦截器。
  3）在请求处理完成后也会执行拦截器。


拦截器：看做是多个Controller中公用的功能，集中到拦截器统一处理。使用的aop的思想

一个拦截器的执行

//拦截器类：拦截用户的请求。
public class MyInterceptor implements HandlerInterceptor {

    private long btime = 0;
    /*
     * preHandle叫做预处理方法。
     *   重要：是整个项目的入口，门户。 当preHandle返回true 请求可以被处理。
     *        preHandle返回false，请求到此方法就截止。
     *
     * 参数：
     *  Object handler ： 被拦截的控制器对象
     * 返回值boolean
     *   true：请求是通过了拦截器的验证，可以执行处理器方法。
         *   拦截器的MyInterceptor的preHandle()
             =====执行MyController中的doSome方法=====
             拦截器的MyInterceptor的postHandle()
             拦截器的MyInterceptor的afterCompletion()
         *
     *   false：请求没有通过拦截器的验证，请求到达拦截器就截止了。 请求没有被处理
     *      拦截器的MyInterceptor的preHandle()
     *
     *
     *  特点：
     *   1.方法在控制器方法（MyController的doSome）之前先执行的。
     *     用户的请求首先到达此方法
     *
     *   2.在这个 方法中可以获取请求的信息， 验证请求是否符合要求。
     *     可以验证用户是否登录， 验证用户是否有权限访问某个连接地址（url）。
     *      如果验证失败，可以截断请求，请求不能被处理。
     *      如果验证成功，可以放行请求，此时控制器方法才能执行。
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        btime = System.currentTimeMillis();
        System.out.println("拦截器的MyInterceptor的preHandle()");
        //计算的业务逻辑，根据计算结果，返回true或者false
        //给浏览器一个返回结果
        //request.getRequestDispatcher("/tips.jsp").forward(request,response);
        return true;
    }

    /*
       postHandle:后处理方法。
       参数：
        Object handler：被拦截的处理器对象MyController
        ModelAndView mv:处理器方法的返回值

        特点：
         1.在处理器方法之后执行的（MyController.doSome()）
         2.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的
         数据和视图，可以影响到最后的执行结果。
         3.主要是对原来的执行结果做二次修正，

         ModelAndView mv = MyController.doSome();
         postHandle(request,response,handler,mv);
     */
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("拦截器的MyInterceptor的postHandle()");
        //对原来的doSome执行结果，需要调整。
        if( mv != null){
            //修改数据
            mv.addObject("mydate",new Date());
            //修改视图
            mv.setViewName("other");
        }
    }

    /*
      afterCompletion:最后执行的方法
      参数
        Object handler:被拦截器的处理器对象
        Exception ex：程序中发生的异常
      特点:
       1.在请求处理完成后执行的。框架中规定是当你的视图处理完成后，对视图执行了forward。就认为请求处理完成。
       2.一般做资源回收工作的， 程序请求过程中创建了一些对象，在这里可以删除，把占用的内存回收。
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        System.out.println("拦截器的MyInterceptor的afterCompletion()");

        long etime = System.currentTimeMillis();
        System.out.println("计算从preHandle到请求处理完成的时间："+(etime - btime ));
    }
}

/**
 * @RequestMapping:
 *    value ： 所有请求地址的公共部分，叫做模块名称
 *    位置： 放在类的上面
 */
@Controller
public class MyController {

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age)  {
        System.out.println("=====执行MyController中的doSome方法=====");
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

}

 <!--springmvc.xml 声明拦截器： 拦截器可以有0或多个-->
    <mvc:interceptors>
        <!--声明第一个拦截器-->
        <mvc:interceptor>
            <!--指定拦截的请求uri地址
                path：就是uri地址，可以使用通配符 **
                      ** ： 表示任意的字符，文件或者多级目录和目录中的文件
                http://localhost:8080/myweb/user/listUser.do
                http://localhost:8080/myweb/student/addStudent.do
            -->
            <mvc:mapping path="/**"/>
            <!--声明拦截器对象-->
            <bean class="com.bjpowernode.handler.MyInterceptor" />
        </mvc:interceptor>
    </mvc:interceptors>

拦截器中方法与处理器方法的执行顺序如下图：

在这里插入图片描述

多个拦截器的执行

<mvc:interceptors>
    <!--声明第一个拦截器-->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <!--声明拦截器对象-->
        <bean class="com.bjpowernode.handler.MyInterceptor" />
    </mvc:interceptor>
    <!--声明第二个拦截器-->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="com.bjpowernode.handler.MyInterceptor2" />
    </mvc:interceptor>
</mvc:interceptors>

多个拦截器：
第一个拦截器preHandle=true , 第二个拦截器preHandle=true 

111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
=====执行MyController中的doSome方法=====
22222-拦截器的MyInterceptor的postHandle()
111111-拦截器的MyInterceptor的postHandle()
22222-拦截器的MyInterceptor的afterCompletion()
111111-拦截器的MyInterceptor的afterCompletion()

---------------------------------------------------
第一个拦截器preHandle=true , 第二个拦截器preHandle=false(只要有一个为false controller都不会执行)

111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
111111-拦截器的MyInterceptor的afterCompletion()

----------------------------------------------------------
第一个拦截器preHandle=false , 第二个拦截器preHandle=true|false

111111-拦截器的MyInterceptor的preHandle()

当有多个拦截器时，形成拦截器链。拦截器链的执行顺序，与其注册顺序一致。需要再次强调一点的是，当某一个拦截器的 preHandle()方法返回 true 并被执行到时，会向一个专门的方法栈中放入该拦截器的 afterCompletion()方法。

多个拦截器中方法与处理器方法的执行顺序如下图：
在这里插入图片描述

从图中可以看出，只要有一个 preHandle()方法返回 false，则上部的执行链将被断开，其后续的处理器方法与 postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要方法栈中有方法，即执行链中只要有 preHandle()方法返回 true，就会执行方法栈中的 afterCompletion()方法。最终都会给出响应。

拦截器和过滤器的区别

过滤器是servlet中的对象，拦截器是框架中的对象
过滤器实现Filter接口的对象，拦截器是实现HandlerInterceptor
过滤器是用来设置request，response的参数，属性的，侧重对数据过滤的。拦截器是用来验证请求的，能截断请求。
过滤器是在拦截器之前先执行的。
过滤器是tomcat服务器创建的对象；拦截器是springmvc容器中创建的对象
过滤器是一个执行时间点；拦截器有三个执行时间点
过滤器可以处理jsp，js，html等等
拦截器是侧重拦截对Controller的对象。如果你的请求不能被DispatcherServlet接收，这个请求不会执行拦截器内容
拦截器拦截普通类方法执行，过滤器过滤servlet请求响应

权限拦截器举例

只有经过登录的用户方可访问处理器，否则，将返回“无权访问”提示。

本例的登录，由一个 JSP 页面完成。即在该页面里将用户信息放入 session 中。也就是说，只要访问过该页面，就说明登录了。没访问过，则为未登录用户。

定义权限拦截器

//拦截器类：拦截用户的请求。
public class MyInterceptor implements HandlerInterceptor {


    //验证登录的用户信息， 正确return true，其它return false
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("111111-拦截器的MyInterceptor的preHandle()");
        String loginName = "";
        //从session中获取name的值
        Object attr  = request.getSession().getAttribute("name");
        if( attr != null){
            loginName = (String)attr;
        }

        //判断登录的账户，是否符合要求
        if( !"zs".equals(loginName)){
            //不能访问系统
            //给用户提示
            request.getRequestDispatcher("/tips.jsp").forward(request,response);
            return false;
        }

        //zs登录
        return true;
    }


}

<body>
    模拟登录,zs登录系统
    <%
        session.setAttribute("name","zs");
    %>

</body>

tips.jsp

<body>
  tips.jsp  非zs不能访问系统
</body>

index.jsp

<body>

    <p>一个拦截器</p>
    <form action="some.do" method="post">
        姓名：<input type="text" name="name"> <br/>
        年龄：<input type="text" name="age"> <br/>
        <input type="submit" value="提交请求">
    </form>


</body>