第一章 SpringMVC概述

1.1SpringMVC简介

SpringMVC：是基于spring的一个框架，实际上就是spring的一个模块，专门是做web开发的。可以理解是servlet的一个升级。它在servlet的基础上面添加了一些功能，使开发人员开发web更加方便。

SpringMVC就是一个Spring。 Spring是容器，ioc能够管理对象，使用< bean>, @Component, @Repository, @Service, @Controller，SpringMVC能够创建对象，放入到容器中（SpringMVC容器），SpringMVC容器中放的是控制器对象，开发人员需要做的就是使用@Contorller创建控制器对象，把对象放入到springmvc容器中，把创建的对象作为控制器使用。

这个控制器对象能接收用户的请求，显示处理结果，就当做是一个servlet使用（具有servlet的功能，实际上不是servlet类型）。
使用@Controller注解创建的是一个普通类的对象，不是Servlet。 springmvc赋予了控制器对象一些额外的功能。

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

处理过程：

index.jsp-----DispatherServlet(Servlet)----转发，分配给—Controller对象（@Controller注解创建的对象）
main.jsp MainController
addUser.jsp UserController

1.2SpringMVC的优点

基于MVC架构。功能明确，解耦合。
轻量、简单、易学。
作为Spring框架的一部分，能够使用IoC、AOP，能够方便的整合其他框架。
Spring强化注解的使用。方便灵活。

1.3第一个注解的SpringMVC程序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-98pt3mZL-1650982167666)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407220537854.png)]

所谓 SpringMVC 的注解式开发是指，在代码中通过对类与方法的注解，便可完成处理器在 springmvc 容器的注册。注解式开发是重点。

1.3.1pom.xml配置依赖

<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><!--springmvc依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.2.5.RELEASE</version></dependency>
</dependencies>

1.3.2注册中央调度器

在web.xml中注册一个servlet：DispatcherServlet，是HttpServlet的子类，称为中央调度器，也被称作前端控制器（front controller）。其作用在上文中介绍过。这个角色是SpriingMVC项目的标志，其本身并不处理请求，他把请求转发给了我们自己创建的Controller也就是后端控制器（back controller）来处理请求。

当tomcat服务器启动时，DispatcherServlet创建时会首先初始化执行init()方法，方法里会创建容器对象WebApplicationContext，而创建容器需要读取spring配置文件，当读取到spring配置文件此时容器里的对象就被创建好了。之后容器对象会被放到全局作用域对象ServletContext中保存，当需要用到容器对象时，再把它从作用域中取出来。

<?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"><!--声明，注册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等等不能使用 *.jsphttp://localhost:8080/myweb/some.dohttp://localhost:8080/myweb/other.do2.使用斜杠 "/"--><url-pattern>*.do</url-pattern><!--.do结尾的请求交给中央调度器处理--></servlet-mapping></web-app>

< url-pattern>*.do</ url-pattern>表示以.do结尾的请求统统都交给中央调度器处理

1.3.3创建请求页面

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

1.3.4创建处理器

/***  @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","/first.do"})public ModelAndView doSome(){  // doGet()--service请求处理//处理some.do请求了。 相当于service调用处理完成了。ModelAndView mv  = new ModelAndView();//添加数据， 框架在请求的最后把数据放入到request作用域。//request.setAttribute("msg","欢迎使用springmvc做web开发");mv.addObject("msg","欢迎使用springmvc做web开发");mv.addObject("fun","执行的是doSome方法");//指定视图, 指定视图的完整路径//框架对视图执行的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");//mv.setView( new RedirectView("/a.jsp"));//返回mvreturn mv;}@RequestMapping(value = {"/other.do","/second.do"})public ModelAndView doOther(){ModelAndView mv  = new ModelAndView();mv.addObject("msg","====欢迎使用springmvc做web开发====");mv.addObject("fun","执行的是doOther方法");mv.setViewName("other");return mv;}
}

1.3.5声明组件扫描器

<?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.bjpowernode.controller" />
</beans>

1.3.6定义目标页面

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

1.3.6视图解析器的注册

当jsp页面放到webapp目录之下，用户是可以是有权利访问的，这样做没有安全性，因此我们要把jsp页面放到WEB-INF目录下面，因为WEB-INF目录的所有文件对用户都是不开放的是访问不了的，外部访问不到WEB-INF下面的文件，这样就可以实现把文件保护起来。

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

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

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

1.3.7修改处理器

@Controller
public class MyController {@RequestMapping(value = {"/some.do","/first.do"})public ModelAndView doSome(){  // doGet()--service请求处理ModelAndView mv  = new ModelAndView();mv.addObject("msg","欢迎使用springmvc做web开发");mv.addObject("fun","执行的是doSome方法");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");//mv.setView( new RedirectView("/a.jsp"));//返回mvreturn mv;}@RequestMapping(value = {"/other.do","/second.do"})public ModelAndView doOther(){ModelAndView mv  = new ModelAndView();mv.addObject("msg","====欢迎使用springmvc做web开发====");mv.addObject("fun","执行的是doOther方法");mv.setViewName("other");return mv;}
}

使用逻辑视图名称，show 是逻辑视图名称。

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

1）发起some.do
2）tomcat(web.xml–url-pattern知道 *.do的请求给DispatcherServlet)
3）DispatcherServlet（根据springmvc.xml配置知道 some.do—doSome()）
4）DispatcherServlet把some.do转发个MyController.doSome()方法
5）框架执行doSome（）把得到ModelAndView进行处理，转发到show.jsp

上面的过程简化的方式
some.do—DispatcherServlet—MyController

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KAJJgPAX-1650982167667)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407090539729.png)]

1.4 SpringMVC 的 MVC 组件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tsPMvNGg-1650982167668)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407092853795.png)]

1.5 SpringMVC 执行流程

中央调度器充当的是门面。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rIShi128-1650982167669)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220406194830712.png)]

发起some.do

请求被tomcat接收，tomcat根据web.xml的标签servletmapper的属性url-pattern 知道*.do的请求交给DispatcherServlet处理。

DispatcherServlet如何去处理some.do呢？他首先会去读取springmvc的配置文件，这个文件中所对应的组件扫描器，而组件扫描器能创建对象，创建时他能扫描到有@RequestMapping(value = “/some.do”)注解和MyController这个doSome方法是对应的（也就是根据springmvc.xml配置文件的信息就知道some.do----对应的是doSome()）

然后中央调度器就把some.do转发给MyController方法doSome()了。然后框架执行dosome方法把得到的modelandview进行处理，转发到show.jsp。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DjYxzlA6-1650982167670)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220406194133814.png)]

servlet初始化时会执行init方法，会去读取springmvc的配置文件来从创建容器对象。

1.5.1流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RTsT4PL5-1650982167671)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407093016203.png)]

1.5.2 执行流程简单分析

（1）浏览器提交请求到中央调度器

（2）中央调度器直接将请求转给处理器映射器。

（3）处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链后返回给中央调度器。

（4）中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。

（5）处理器适配器调用执行处理器。

（6）处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView 中，并将其返回给处理器适配器。

（7）处理器适配器直接将结果返回给中央调度器。

（8）中央调度器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象。

（9）视图解析器将封装了的视图对象返回给中央调度器

（10）中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。

（11）中央调度器响应浏览器。

不一样的参数名，

表达的含义是：请求中rname的参数他的值要赋给name这个形参

在请求参数少的时候用这种参数方便，但是参数一旦多起来，就很麻烦，所以我们就用对象来接收参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JVVzEwS1-1650982167671)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407182554046.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FB8bG7ZT-1650982167672)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407171340791.png)]

ajax里面的dataType会转成这里的Accept传给控制器对象，来期望获取的格式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fniKYPJC-1650982167672)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407190428175.png)]

当ajax指定期望值时，会传以下内容，虽然前端没指定，但是后端指定了，还是会返回这样的所返回的值，本来返回的是一个json字符串，但是jquey读取到后端想返回一个json对象的时候，jquey会去尝试把返回的内容当json进行转换和使用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZW2d5oM1-1650982167673)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407190533538.png)]

第二章 SpringMVC 注解式开发

讲注解式开发时，实际上就是讲解方法的完整定义，@RequestMapping目的是把请求接收过来，请求会交给他下面的方法来处理。接收请求参数，用的是形参列表，把用户真实提交的数据接收到，处理请求，然后处理结果用ModelAndView来表示返回本次的处理结果。

2.1 @RequestMapping 定义请求规则

2.1.1 指定模块名称（类上）

通过@RequestMapping 注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上，也可以注解在类上，但意义是不同的。value 属性值常以“/”开始。
@RequestMapping 的 value 属性用于定义所匹配请求的 URI。但对于注解在方法上与类上，其 value 属性所指定的 URI，意义是不同的。
一个@Controller 所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的 URI 是不同的。这些不同的 URI 被指定在注解于方法之上的@RequestMapping 的 value 属性中。但若这些请求具有相同的 URI 部分，则这些相同的 URI，可以被抽取到注解在类之上的@RequestMapping 的 value 属性中。此时的这个 URI 表示模块的名称。URI 的请求是相对于 Web 的根目录。
换个角度说，要访问处理器的指定方法，必须要在方法指定 URI 之前加上处理器类前定义的模块名称

/*** @RequestMapping:*    value ： 所有请求地址的公共部分，叫做模块名称*    位置： 放在类的上面*/
@Controller
@RequestMapping("/user")
public class MyController {/*** @RequestMapping : 请求映射*             属性： method， 表示请求的方式。 它的值RequestMethod类枚举值。*                    例如表示get请求方式， RequestMethod.GET*                    post方式， RequestMethod.POST**  你不用get方式，错误是：*  HTTP Status 405 - Request method 'GET' not supported*/@RequestMapping(value = "/some.do")public ModelAndView doSome(){  // doGet()--service请求处理//处理some.do请求了。 相当于service调用处理完成了。ModelAndView mv  = new ModelAndView();mv.addObject("msg","欢迎使用springmvc做web开发");mv.addObject("fun","执行的是doSome方法");mv.setViewName("show");return mv;}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-anwHBotJ-1650982167674)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407104641311.png)]

把some.do前面的test看成是一个模块的名称，而模块下面有很多处理的方法，这个模块名称就是一个公共的名称，我们可以把它抽取出来,放到类的上面统一定义。

2.1.2 对请求提交方式的定义

对于@RequestMapping，其有一个属性 method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该 method 属性指定的提交方式的请求，才会执行该被注解方法。
客户端浏览器常用的请求方式，及其提交方式有以下几种：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CDWgHVHO-1650982167675)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407212911795.png)]

也就是说，只要指定了处理器方法匹配的请求提交方式为 POST，则相当于指定了请求发送的方式：要么使用表单请求，要么使用 AJAX 请求。其它请求方式被禁用。
有三种限制方式来处理：

1.指定属性为RequestMethod.GET

@Controller
@RequestMapping("/user")
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 = "/some.do",method = RequestMethod.GET)public ModelAndView doSome(){  // doGet()--service请求处理//处理some.do请求了。 相当于service调用处理完成了。ModelAndView mv  = new ModelAndView();mv.addObject("msg","欢迎使用springmvc做web开发");mv.addObject("fun","执行的是doSome方法");mv.setViewName("show");return mv;}
}

以上处理器方法只能处理 GET 方式提交的请求。

2.指定属性为RequestMethod.POST

//指定other.do是post请求方式
@RequestMapping(value = "/other.do",method = RequestMethod.POST)
public ModelAndView doOther(){ModelAndView mv  = new ModelAndView();mv.addObject("msg","====欢迎使用springmvc做web开发====");mv.addObject("fun","执行的是doOther方法");mv.setViewName("other");return mv;
}

3.默认不指定其属性

当然，若不指定 method 属性，则无论是 GET 还是 POST 提交方式，均可匹配。即对于请求的提交方式无要求。

//不指定请求方式，没有限制
@RequestMapping(value = "/first.do")
public ModelAndView doFirst(){ModelAndView mv  = new ModelAndView();mv.addObject("msg","====欢迎使用springmvc做web开发====" + request.getParameter("name"));mv.addObject("fun","执行的是doFirst方法");mv.setViewName("other");return mv;
}

2.2处理器方法的参数

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

➢ HttpServletRequest

➢ HttpServletResponse

➢ HttpSession

➢ 请求中所携带的请求参数

2.2.1 逐个参数接收

只要保证请求参数名与该请求处理方法的参数名相同即可。对应前端传过来的参数名称，与位置无关。

/*** 逐个接收请求参数：*   要求： 处理器（控制器）方法的形参名和请求中参数名必须一致。*          同名的请求参数赋值给同名的形参* 框架接收请求参数*   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",age);//show是视图文件的逻辑名称（文件名称）mv.setViewName("show");return mv;
}

这里为什么不用int呢？因为在客户端用户输入参数时，可能不输入，那么在框架转换数据的时候就会发生异常，空字符串不能被转成int类型。所以用Integer包装类可以防止类型转换异常，当用户不输入时，框架会默认给null。

2.2.2 对象参数接收

只要保证请求参数名与这个对象的属性同名即可。

框架的做法是，首先会创建这个Student java对象，调用无参构造方法来创建。然后根据请求参数名称所对应的属性名称的set方法来实现赋值。

/*** 处理器方法形参是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;
}

2.2.3 注意

注意：
在提交请求参数时，get请求方式中文没有乱码。
使用post方式提交请求，中文有乱码，需要使用过滤器处理乱码的问题。

过滤器可以自定义，也可使用框架中提供的过滤器 CharacterEncodingFilter

1.请求参数中文乱码问题

get方式和post方式的解码方式不同，get解码中文没问题，而post解码中文是有乱码的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pk4pc3IO-1650982167675)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407113358105.png)]

因为项目过程中，每个发起请求的参数都可能会有解码问题，而每个方法都需要定义解码方式，太过繁琐，所以我们把解码方式定义到过滤器当中统一解码。

对于前面所接收的请求参数，若含有中文，则会出现中文乱码问题。

解决方案：

1.自己实现过滤器

2.通过框架已经实现专门的字符集过滤器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bjFslue7-1650982167676)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407215128696.png)]

实现过滤器

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xboAgq3b-1650982167676)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407161824285.png)]

对应着

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-njSKPzaL-1650982167677)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407161849716.png)]

2. 校正请求参数名@RequestParam

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

/*** 请求中参数名和处理器方法的形参名不一样* @RequestParam: 逐个接收请求参数中， 解决请求中参数名形参名不一样的问题*      属性： 1. value 请求中的参数名称*            2. required 是一个boolean，默认是true*                true：表示请求中必须包含此参数。false：可以没有此参数。*      位置： 在处理器方法的形参定义的前面*/
@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;
}

2.3 处理器方法的返回值

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

➢ 第一种：ModelAndView

➢ 第二种：String

➢ 第三种：无返回值 void

➢ 第四种：返回自定义类型对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uFMDjSdS-1650982167678)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407220624686.png)]

2.3.1 ModelAndView

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

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

2.3.2 String

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

指定逻辑名

/*** 处理器方法返回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";
}

指定完整视图路径

//处理器方法返回String,表示完整视图路径， 此时不能配置视图解析器
@RequestMapping(value = "/returnString-view2.do")
public String doReturnView2(HttpServletRequest request,String name, Integer age){System.out.println("===doReturnView2====, name="+name+"   age="+age);//可以自己手工添加数据到request作用域request.setAttribute("myname",name);request.setAttribute("myage",age);// 完整视图路径，项目中不能配置视图解析器// 框架对视图执行forward转发操作// /WEB-INF/view//WEB-INF/view/show.jsp.jsp// /WEB-INF/view/WEB-INF/view/show.jsp.jspreturn "/WEB-INF/view/show.jsp";
}

使用了完整路径还用了视图解析器会报错，写了完整路径就不能使用视图解析器，使用视图解析器就不能使用完整视图路径名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T2pmmf2M-1650982167679)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220407184214749.png)]

2.3.3 void

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

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

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

2.引入jQuery库

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lrjkz6cE-1650982167679)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220408213935226.png)]

3.定义index页面

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

<script src="static/js/jquery-3.4.1.js" type="text/javascript"></script>
<script>$(function () {$("#bt").click(function () {$.ajax({url:"returnVoid-ajax.do",data:{name:"zs",age:"12"},type:"post",success: function (res) {alert(res)}})})})
</script>

4.修改处理器类 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();
}

2.3.4 Object

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

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

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

springmvc处理器方法返回Object， 可以转为json输出到浏览器，响应ajax的内部原理1. <mvc:annotation-driven> 注解驱动。注解驱动实现的功能是 完成java对象到json，xml， text，二进制等数据格式的转换。<mvc:annotation-driven>在加入到springmvc配置文件后， 会自动创建HttpMessageConverter接口的8个实现类对象， 包括 MappingJackson2HttpMessageConverter （使用jackson工具库中的ObjectMapper实现java对象转为json字符串）HttpMessageConverter接口：消息转换器。功能：定义了java转为json，xml等数据格式的方法。 这个接口有很多的实现类。这些实现类完成 java对象到json， java对象到xml，java对象到二进制数据的转换下面的两个方法是控制器类把结果输出给浏览器时使用的：boolean canWrite(Class<?> var1, @Nullable MediaType var2);void write(T var1, @Nullable MediaType var2, HttpOutputMessage var3)例如处理器方法@RequestMapping(value = "/returnString.do")public Student doReturnView2(HttpServletRequest request,String name, Integer age){Student student = new Student();student.setName("lisi");student.setAge(20);return student;}1）canWrite作用检查处理器方法的返回值，能不能转为var2表示的数据格式。检查student(lisi，20)能不能转为var2表示的数据格式。如果检查能转为json，canWrite返回trueMediaType：表示数格式的， 例如json， xml等等2）write：把处理器方法的返回值对象，调用jackson中的ObjectMapper转为json字符串。json  = om.writeValueAsString(student);2. @ResponseBody注解放在处理器方法的上面， 通过HttpServletResponse输出数据，响应ajax请求的。PrintWriter pw  = response.getWriter();pw.println(json);pw.flush();pw.close();

没有加入注解驱动标签<mvc:annotation-driven /> 时的状态
org.springframework.http.converter.ByteArrayHttpMessageConverter
org.springframework.http.converter.StringHttpMessageConverter
org.springframework.http.converter.xml.SourceHttpMessageConverter
org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter

加入注解驱动标签时**<mvc:annotation-driven />**的状态
org.springframework.http.converter.ByteArrayHttpMessageConverter
org.springframework.http.converter.StringHttpMessageConverter
org.springframework.http.converter.ResourceHttpMessageConverter
org.springframework.http.converter.ResourceRegionHttpMessageConverter
org.springframework.http.converter.xml.SourceHttpMessageConverter
org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

1.环境搭建

A.maven pom.xml添加依赖

由于返回 Object 数据，一般都是将数据转化为了 JSON 对象后传递给浏览器页面的。而这个由 Object 转换为 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>

B.声明注解驱动

将 Object 数据转化为 JSON 数据，需要由< mvc:annotation-driven/>消息转换器 HttpMessageConverter 完成。而转换器的开启，需要由来完成。

C.添加@ReponsBody

2.返回自定义类型对象

返回自定义类型对象时，不能以对象的形式直接返回给客户端浏览器，而是将对象转换为 JSON 格式的数据发送给浏览器的。

A.定义数据类

//保存请求参数值的一个普通类
public class Student {// 属性名和请求中参数名一样private String name;private Integer age;
}

B.修改处理器 MyController

对比之前返回void时手动转换为json格式方便了需多。

/*** 处理器方法返回一个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}

C.修改index页面

<script type="text/javascript" src="js/jquery-3.4.1.js"></script>
<script type="text/javascript">$(function(){$("button").click(function(){$.ajax({url:"returnStudentJson.do",data:{name:"zhangsan",age:20},type:"post",dataType:"json",success:function(resp){//jquery会把字符串转为json对象， 赋值给resp形参。}})})})
</script>

3.返回List集合

A.修改处理器 MyController

/***  处理器方法返回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;}

B.修改 index 页面

<script type="text/javascript" src="js/jquery-3.4.1.js"></script>
<script type="text/javascript">
$(function(){$("button").click(function(){$.ajax({url:"returnStudentJsonArray.do",data:{name:"zhangsan",age:20},type:"post",dataType:"json",success:function(resp){// [{"name":"李四同学","age":20},{"name":"张三","age":28}]$.each(resp,function(i,n){alert(n.name+"   "+n.age)})}})})})
</script>

2.3.5 返回字符串对象

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

produces，产品，结果，即该属性用于设置输出结果类型。

区分返回值String是数据，还是视图，看有没有@ResponseBody注解，如果有@ResponseBody注解，返回String就是数据，反之就是视图

当后端传的是字符串，但是前端要求是json格式数据，会报错。因为jquery会把拿到的数据直接转换成json对象，转换异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-quYU8Cgf-1650982167680)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220408091005972.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-suWxQGjS-1650982167680)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220408091113469.png)]

之前不是配置了过滤器吗，为什么还会乱码？用过滤器是不好使的，因为我们通过RequestBody是通过网络的方式输入输出，来把数据直接输出给你的ajax请求的，输出过程中并不走我们的过滤器。过滤器只对请求有效，所以我们必须加一个属性去指定字符编码。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FLRFFfO5-1650982167681)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220408091217798.png)]

使用普通的string作为数据，要加@ResponseBody，不加就会被视图解析器处理。

1.修改处理器

/*** 处理器方法返回的是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 返回对象，表示数据";
}

2.修改页面

<script type="text/javascript" src="js/jquery-3.4.1.js"></script>
<script type="text/javascript">$(function(){$("button").click(function(){$.ajax({url:"returnStringData.do",data:{name:"zhangsan",age:20},type:"post",dataType:"text",//dataType:"json",success:function(resp){alert("返回的是文本数据："+resp);}})})})
</script>

2.4 解读< url-pattern/>

2.4.1 配置详解

1. *.do

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

2. /

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

修改< url-pattern/>的值，保持的值为 *.do，扩展名方式，图片会正常显示。将的值修改为 / ，则图片将无法显示。

2.4.2 静态资源访问

<servlet-mapping><servlet-name>myweb</servlet-name><!--使用框架的时候， url-pattern可以使用两种值1. 使用扩展名方式， 语法 *.xxxx , xxxx是自定义的扩展名。 常用的方式 *.do, *.action, *.mvc等等不能使用 *.jsphttp://localhost:8080/myweb/some.dohttp://localhost:8080/myweb/other.do2.使用斜杠 "/"当你的项目中使用了  / ，它会替代 tomcat中的default。导致所有的静态资源都给DispatcherServlet处理， 默认情况下DispatcherServlet没有处理静态资源的能力。没有控制器对象能处理静态资源的访问。所以静态资源（html，js，图片，css）都是404.动态资源some.do是可以访问，的因为我们程序中有MyController控制器对象，能处理some.do请求。--><url-pattern>/</url-pattern>
</servlet-mapping>

条件：只有中央调度器配置的是/后，动态资源可以正常访问，而静态资源不能访问，这时候才需要配置静态资源的访问工作

tomcat处理静态资源是这样做的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IOBG7Xcu-1650982167681)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220408094013957.png)]

中央调度器加了/之后表示，所有的请求都交给DispatcherServlet（中央调度器）处理，导致静态资源文件也交给他，但是我们默认的中央调度器是没有能力去处理静态资源文件的。

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

加入了default-servlet-handler之后把所有请求都转发给了tomcat的default这个servlet，导致动态资源some.do文件也交给了他，所以tomcat处理不了。访问失败。为了解决这个冲突，需要添加注解驱动，加了注解驱动之后default-servlet-handler和@RequestMapping的冲突问题就解决了。静态资源文件就会交给服务器，而动态资源文件就会交给中央调度器分派给控制器对象。这种方式的缺点就是default-servlet-handler需要依赖tomcat的default才能用，否则访问静态资源文件依然是失败的，优点就是方便
resources来指定静态资源给框架 ResourceHttpRequestHandler处理，记住只要用了静态资源就要有注解驱动。因为resources也和@RequestMapping有冲突。mapping：代表这样形式的请求，就是指定凡是images开头的请求，都到location那个目录上去找资源，前面的斜杠代表web应用的根，后面的斜杠代表是个目录，不能缺！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5rszA832-1650982167682)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220408161224872.png)]

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

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fkSFHl7v-1650982167684)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220409091342329.png)]

表示使用 DefaultServletHttpRequestHandler 处理器对象。而该处理器调用了 Tomcat 的 DefaultServlet 来处理静态资源的访问请求。

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

2.使用< mvc:resources/>

Spring 定义了专门用于处理静态资源访问请求的处理器 ResourceHttpRequestHandler。并且添加了标签，专门用于解决静态资源无法访问问题。需要在 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/" />-->

location 表示静态资源所在目录。当然，目录不要使用/WEB-INF/及其子目录。

mapping 表示对该资源的请求（以 /images/ 开始的请求，如 /image/beauty.jpg , /images/car.png 等）。注意，后面是两个星号**。

3.声明注解

解决动态资源和静态资源冲突的问题都需要声明注解驱动。

总结注解驱动用到的地方有三个：

1）访问静态资源的时候，

2）使用事务的时候，

3）使用@ResponsBody的时候，用来进行对象格式转换

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-17ZLpYdt-1650982167684)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220409164617859.png)]

第三章 SSM整合开发

SSM 编程，即 SpringMVC + Spring + MyBatis 整合，是当前最为流行的 JavaEE 开发技术架构。其实 SSM 整合的实质，仅仅就是将 MyBatis整合入 Spring。因为 SpringMVC原本就是 Spring 的一部分，不用专门整合。

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

3.1 搭建 SSM 开发环境

3.1.1 maven pom.xml

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

3.1.2 配置 web.xml

1.注册 ContextLoaderListener 监听器

<!--注册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>

2.注册字符集过滤器

注册字符集过滤器，用于解决请求参数中携带中文时产生乱码问题。

<!--注册字符集过滤器-->
<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><param-name>forceRequestEncoding</param-name><param-value>true</param-value></init-param><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>

3.配置中央调度器

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

<!--注册中央调度器-->
<servlet><servlet-name>myweb</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:conf/dispatcherServlet.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>

3.2 SSM整合注解开发

ch07-ssm: SSM整合开发。
SSM： SpringMVC + Spring + MyBatis.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对象实现步骤：
0.使用springdb的mysql库， 表使用student（id auto_increment, name, age）
1.新建maven web项目
2.加入依赖springmvc，spring，mybatis三个框架的依赖，jackson依赖，mysql驱动，druid连接池jsp，servlet依赖3.写web.xml1)注册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页面

3.2.1 建表 Student

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-svCCQxyL-1650982167685)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410082959524.png)]

3.2.2 新建 Web 工程

3.2.3 maven 依赖

<!--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>
<!--springmvc-->
<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>
<!--aspectj 依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<!--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>
<!--mybatis 和 spring 整合的-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.1</version>
</dependency>
<!--mysql 驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>
<!--druid-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.12</version>
</dependency>
</dependencies>

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VLQNlC0G-1650982167686)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410083136384.png)]

3.2.5 编写配置文件

Jdbc 属性配置文件 jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/springdb
jdbc.username=root
jdbc.password=123456

Spring 配置文件 applicationContext.xml

<!--spring配置文件： 声明service，dao，工具类等对象--><context:property-placeholder location="classpath:conf/jdbc.properties" /><!--声明数据源，连接数据库-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"init-method="init" destroy-method="close"><property name="url" value="${jdbc.url}" /><property name="username" value="${jdbc.username}" /><property name="password" value="${jdbc.password}" />
</bean><!--SqlSessionFactoryBean创建SqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource" /><property name="configLocation"  value="classpath:conf/mybatis.xml" />
</bean><!--声明mybatis的扫描器，创建dao对象-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" /><property name="basePackage" value="com.bjpowernode.dao" />
</bean><!--声明service的注解@Service所在的包名位置-->
<context:component-scan base-package="com.bjpowernode.service" /><!--事务配置：注解的配置， aspectj的配置-->

Springmvc 配置文件：springmvc.xml

<!--springmvc配置文件， 声明controller和其它web相关的对象-->
<context:component-scan base-package="com.bjpowernode.controller" /><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/" /><property name="suffix" value=".jsp" />
</bean><mvc:annotation-driven />
<!--1. 响应ajax请求，返回json2. 解决静态资源访问问题。
-->

mybatis.xml

 <!--settings：控制mybatis全局行为-->
<!-- <settings>&lt;!&ndash;设置mybatis输出日志&ndash;&gt;<setting name="logImpl" value="STDOUT_LOGGING"/></settings>--><!--设置别名--><typeAliases><!--name:实体类所在的包名(不是实体类的包名也可以)--><package name="com.bjpowernode.domain"/></typeAliases><!-- sql mapper(sql映射文件)的位置--><mappers><!--name：是包名， 这个包中的所有mapper.xml一次都能加载使用package的要求：1. mapper文件名称和dao接口名必须完全一样，包括大小写2. mapper文件和dao接口必须在同一目录--><package name="com.bjpowernode.dao"/></mappers>

3.2.6 定义 web.xml

1）注册 ContextLoaderListener

2）注册 DisatcherServlet

3）注册字符集过滤器

4）同时创建 Spring 的配置文件和 SpringMVC 的配置文件

3.2.7 实体类 Student

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-guAjOFUP-1650982167687)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410083549667.png)]

3.2.8 Dao 接口和 sql 映射文件

public interface StudentDao {int insertStudent(Student student);List<Student> selectStudents();
}

<mapper namespace="com.bjpowernode.dao.StudentDao"><select id="selectStudents" resultType="Student">select id,name,age from student order by id desc</select><insert id="insertStudent">insert into student(name,age) values(#{name},#{age})</insert>

3.2.9 Service 接口和实现类

public interface StudentService {int addStudent(Student student);List<Student> findStudents();
}

@Service
public class StudentServiceImpl implements StudentService {//引用类型自动注入@Autowired, @Resource@Resourceprivate StudentDao studentDao;@Overridepublic int addStudent(Student student) {int nums = studentDao.insertStudent(student);return nums;}@Overridepublic List<Student> findStudents() {return studentDao.selectStudents();}
}

3.2.10 处理器定义

@Controller
@RequestMapping("/student")
public class StudentController {@Resourceprivate StudentService service;//注册学生@RequestMapping("/addStudent.do")public ModelAndView addStudent(Student student){ModelAndView mv = new ModelAndView();String tips = "注册失败";//调用service处理studentint nums = service.addStudent(student);if( nums > 0 ){//注册成功tips = "学生【" + student.getName() + "】注册成功";}//添加数据mv.addObject("tips",tips);//指定结果页面mv.setViewName("result");return mv;}//处理查询，响应ajax@RequestMapping("/queryStudent.do")@ResponseBodypublic List<Student> queryStudent(){//参数检查， 简单的数据处理List<Student> students = service.findStudents();return students;}
}

3.2.11 定义视图-首页文件— 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><img src="data:images/ssm.jpg" /><table><tr><td><a href="addStudent.jsp"> 注册学生</a></td></tr><tr><td><a href="listStudent.jsp">浏览学生</a></td></tr></table></div></body>
</html>

第四章 SpringMVC核心技术

4.1 请求重定向和转发

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8IGfwZgG-1650982167687)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220409235444988.png)]

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

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

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

4.1.1请求转发

处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 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");return mv;
}

4.1.2重定向

在处理器方法返回的视图字符串的前面添加 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;
}

在代码中我们有放到模型中的操作，当使用重定向的时候，el表达式为什么取不到值呢？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3IpQzJhO-1650982167687)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220409171550978.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yOSTDBqF-1650982167688)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220409171422429.png)]

第一个请求时是r1，这个时候那两个数据是放在r1作用域当中。当执行到这句话的时候会发起第二次请求，这个时候这个请求就是r2，换了一个请求，这时候到达页面hello.jsp当中应该是与r2相关，没有r1的东西了，因为请求换了个新的，在r2中并没有添加操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cNVHL5gk-1650982167689)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220409172326483.png)]

那要怎么拿呢？相当于下面那一行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PV4DkAz2-1650982167689)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220409172703108.png)]

param代表的是参数集合，WEB-INF不能直接在地址栏上访问，因为他是受保护的，只能由服务器调用。

WEB-INF是Java的web应用安全目录，只对服务端开放，对客户端是不可见的。所以我们可以把除首页（index.jsp）以外的页面都放在WEB-INF目录下，这样就无法通过URL直接访问页面了。web-inf目录是不对外开放的，外部没办法直接访问到（即不能通过URL访问）。所有只能通过映射来访问，比如映射为一个action或者servlet通过服务器端跳转来访问到具体的页面。这样可以限制访问，提高安全性.

扩展

forward和redirect他们都可以访问视图文件，比如某个jsp ，html
forward:/hello.jsp forward:/main.html

forward和redirect他们都可以访问其它的controller
forward:/some.do , redirect:/other.do

处理器方法可以返回ModelAndView, String , void 都可以使用forward，redirect

4.2 异常处理

SpringMVC 框架处理异常的常用方式：使用@ExceptionHandler 注解处理异常。

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

4.2.1 @ExceptionHandler 注解

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

而被注解的方法，其返回值可以是 ModelAndView、String，或 void，方法名随意，方法参数可以是 Exception 及其子类对象、HttpServletRequest、HttpServletResponse 等。系统会自动为这些方法参数赋值。对于异常处理注解的用法，也可以直接将异常处理方法注解于 Controller 之中。

1.自定义异常类

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

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

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

2.修改 Controller 抛出异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HFzSDvRm-1650982167690)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410095615370.png)]

3.定义异常响应页面

…

不过，一般不这样使用。而是将异常处理方法专门定义在一个类中，作为全局的异常处理类。

需要使用注解@ControllerAdvice，字面理解就是“控制器增强”，是给控制器对象增强功能的。使用@ControllerAdvice 修饰的类中可以使用@ExceptionHandler。当使用@RequestMapping 注解修饰的方法抛出异常时，会执行@ControllerAdvice 修饰的类中的异常处理方法。

@ControllerAdvice 是使用@Component 注解修饰的，可以<context:component-scan >扫描到@ControllerAdvice 所在的类路径(包名)，创建对象。

4.定义全局异常类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-56lA6Dit-1650982167690)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410100250350.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SV1yZIiQ-1650982167691)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410100234638.png)]

/*** @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的异常。/*异常发生处理逻辑：1.需要把异常记录下来， 记录到数据库，日志文件。记录日志发生的时间，哪个方法发生的，异常错误内容。2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。3.给用户友好的提示。*/ModelAndView mv = new ModelAndView();mv.addObject("msg","你的年龄不能大于80");mv.addObject("ex",exception);mv.setViewName("ageError");return mv;}//处理其它异常， NameException, AgeException以外，不知类型的异常@ExceptionHandlerpublic ModelAndView doOtherException(Exception exception){//处理其它异常ModelAndView mv = new ModelAndView();mv.addObject("msg","你的年龄不能大于80");mv.addObject("ex",exception);mv.setViewName("defaultError");return mv;}
}

5.定义Spring配置文件

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

4.3 拦截器

1）拦截器是springmvc中的一种，需要实现HandlerInterceptor接口。
2）拦截器和过滤器类似，功能方向侧重点不同。过滤器是用来过滤器请求参数，设置编码字符集等工作。
拦截器是拦截用户的请求，做请求做判断处理的。
3）拦截器是全局的，可以对多个Controller做拦截。
一个项目中可以有0个或多个拦截器，他们在一起拦截用户的请求。
拦截器常用在：用户登录处理，权限检查，记录日志。

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

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

拦截器：看做是多个Controller中公用的功能，集中到拦截器统一处理。使用的aop的思想，在项目中可以有0个或多个。

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

4.3.1 一个拦截器的执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CZRgKzOt-1650982167691)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410104048084.png)]

自定义拦截器，需要实现 HandlerInterceptor 接口。而该接口中含有三个方法：

➢ preHandle(request,response, Object handler)：该方法在处理器方法执行之前执行。其返回值为 boolean，若为 true，则紧接着会执行处理器方法，且会将 afterCompletion()方法放入到一个专门的方法栈中等待执行。

➢ postHandle(request,response, Object handler,modelAndView)：该方法在处理器方法执行之后执行。处理器方法若最终未被执行，则该方法不会执行。由于该方法是在处理器方法执行完后执行，且该方法参数中包含 ModelAndView，所以该方法可以修改处理器方法的处理结果数据，且可以修改跳转方向。

➢ afterCompletion(request,response, Object handler, Exception ex)：当 preHandle()方法返回 true 时，会将该方法放到专门的方法栈中，等到对请求进行响应的所有工作完成之后才执行该方法。即该方法是在中央调度器渲染（数据填充）了响应页面之后执行的，此时对 ModelAndView 再操作也对响应无济于事。 afterCompletion 最后执行的方法，清除资源，例如在 Controller 方法中加入数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ZQJNbQs-1650982167691)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410104634522.png)]

1.单个拦截器执行顺序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3pEale0K-1650982167692)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410104841950.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55dJ8rQ3-1650982167693)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410104908736.png)]

2.使用步骤

A.注册拦截器

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

B.自定义拦截器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O2g0Fc1p-1650982167693)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410111718541.png)]

//拦截器类：拦截用户的请求。
public class MyInterceptor implements HandlerInterceptor {/** 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）。*      如果验证失败，可以截断请求，请求不能被处理。*      如果验证成功，可以放行请求，此时控制器方法才能执行。*/@Overridepublic 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：被拦截的处理器对象MyControllerModelAndView mv:处理器方法的返回值特点：1.在处理器方法之后执行的（MyController.doSome()）2.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的数据和视图，可以影响到最后的执行结果。3.主要是对原来的执行结果做二次修正，ModelAndView mv = MyController.doSome();postHandle(request,response,handler,mv);*/@Overridepublic 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.一般做资源回收工作的， 程序请求过程中创建了一些对象，在这里可以删除，把占用的内存回收。*/@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response,Object handler, Exception ex) throws Exception {System.out.println("拦截器的MyInterceptor的afterCompletion()");}
}

C.创建页面

D.定义处理器

@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;
}

E.执行结果

当preHandle的返回值为true时的运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Poj2pELa-1650982167695)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410111025875.png)]

当preHandle的返回值为false时的运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hy1S1t4F-1650982167695)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410111206974.png)]

afterCompletion想要执行，preHandle就必须返回true

4.3.2 多个拦截器的执行

1.再定义一个拦截器

//拦截器类：拦截用户的请求。
public class MyInterceptor2 implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("22222-拦截器的MyInterceptor的preHandle()");return true;}@Overridepublic void postHandle(HttpServletRequest request,HttpServletResponse response,Object handler, ModelAndView mv) throws Exception {System.out.println("22222-拦截器的MyInterceptor的postHandle()");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response,Object handler, Exception ex) throws Exception {System.out.println("22222-拦截器的MyInterceptor的afterCompletion()");}
}

2.多个拦截器的注册与执行

<!--声明拦截器： 拦截器可以有0或多个在框架中保存多个拦截器是ArrayList，按照声明的先后顺序放入到ArrayList
-->
<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>

3.控制台执行结果

第一个拦截器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

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

这里我们可以看出，只要preHandle返回true，preHandle就肯定能够执行。

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

111111-拦截器的MyInterceptor的preHandle()

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uEUCXDoz-1650982167696)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410115535400.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zhANPSoP-1650982167696)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410115604473.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YBAqRz8Y-1650982167697)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410115805471.png)]

4.3.3 拦截器与过滤器的区别

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gI7O0Tit-1650982167697)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410131016074.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-61XF3k0p-1650982167698)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\image-20220410130935368.png)]

处理器映射器的作用，就是根据我们请求的地址找到能够处理some.do请求的controller，他找到的就是MyController这个对象，换句话说就是从容器中拿到处理器对象。

视图解析器会解析modelandview，创建出视图对象，最后中央调度器调用视图的方法，执行setattr，forward等，结果就输出给浏览器了。

SpringMVC的简单入门相关推荐

SpringMVC的简单知识
SpringMVC简单入门: 1,SpringMVC是什么? 优秀的MVC框架,支持注解配置,帮我们如何传数据到View层.帮我们如何去管理Model(如User类的set和get的管理).(JSP等 ...
这就是你要找的Spring-ioc简单入门！
Spring简单入门 - ioc 大二下学期了,发现身边的同学,工作室的下伙伴最近都准备考研,迷茫中不晓得怎么选择,学长考研复试中说这个CSDN写博客的阅读量是个加分点.之前学长一直叫我们写博客,记录 ...
Struts2框架简单入门
Struts2框架简单入门 1.前言 2.Struts2简介 2.1.Struts2介绍 2.2.Struts2优缺点 2.2.1.优点 2.2.2.缺点 2.2.3.Struts2获取 3.入门案例 ...
SpringMVC V4.1入门超详细解析
文章目录概述 1.初识SpringMVC 1.1入门程序 1.1.1导入jar包/配置文件 1.1.2创建ItemController 1.2Springmvc架构 1.2.1架构图 1.2.2组件 ...
BizTalk 2006 简单入门示例程序（附源项目文件下载）
BizTalk 2006 简单入门示例程序(附源项目文件下载) 为初学BizTalk Server 2006的开发人员,提供一个简单入门的示例程序,包括一个Receive Port.Send Port ...
python如何读取mat文件可视化_python Matplotlib数据可视化（1）：简单入门
1 matplot入门指南 matplotlib是Python科学计算中使用最多的一个可视化库,功能丰富,提供了非常多的可视化方案,基本能够满足各种场景下的数据可视化需求.但功能丰富从另一方面来说也意 ...
ARM NEON 编程简单入门1
原文:http://blog.csdn.net/silentob/article/details/72954618 ARM NEON 编程简单入门1 NEON简介 NEON是适用于ARM Corte ...
Python 简单入门指北(二)
Python 简单入门指北(二) 2 函数 2.1 函数是一等公民一等公民指的是 Python 的函数能够动态创建,能赋值给别的变量,能作为参传给函数,也能作为函数的返回值.总而言之,函数和普通变量 ...
EChart.js 简单入门
EChart.js 简单入门最近有一个统计的项目要做,在前端的数据需要用图表的形式展示.网上搜索了一下,发现有几种统计图库. MSChart 这个是Visual Studio里的自带控件,使用比 ...