掌握SpringMVC一篇就够了

一、关于三层架构和 MVC

1.1.WEB三层架构

我们的开发架构一般都是基于两种形式，一种是 C/S 架构，也就是客户端/服务器，另一种是 B/S 架构，也就是浏览器服务器。在 JavaEE 开发中，几乎全都是基于 B/S 架构的开发。那么在 B/S 架构中，系统标准的三层架构.包括：表现层、业务层、持久层。三层架构在我们的实际开发中使用的非常多，所以我们课程中的案例也都是基于三层架构设计的。三层架构中，每一层各司其职，接下来我们就说说每层都负责哪些方面：

client/server: 客户端/服务器 QQ 微信 优酷 酷狗

Broswer/server : 浏览器/服务器 web站点 淘宝 京东 天猫

• 表现层：
  也就是我们常说的web层。它负责接收客户端请求，向客户端响应结果，通常客户端使用http协议请求web 层，web 需要接收 http 请求，完成 http 响应。表现层包括展示层和控制层：控制层负责接收请求，展示层负责结果的展示。表现层依赖业务层，接收到客户端请求一般会调用业务层进行业务处理，并将处理结果响应给客户端。表现层的设计一般都使用 MVC 模型。（MVC 是表现层的设计模型，和其他层没有关系）
• 业务层：
  也就是我们常说的 service 层。它负责业务逻辑处理，和我们开发项目的需求息息相关。web 层依赖业务层，但是业务层不依赖 web 层。
  业务层在业务处理时可能会依赖持久层，如果要对数据持久化需要保证事务一致性。（也就是我们说的，事务应该放到业务层来控制）
• 持久层：
  也就是我们是常说的 dao 层。负责数据持久化，包括数据层即数据库和数据访问层，数据库是对数据进行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库中。通俗的讲，持久层就是和数据库交互，对数据库表进行曾删改查的。

1.2. MVC 模型

MVC 全名是 Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，
是一种用于设计创建 Web 应用程序表现层的模式。MVC 中每个部分各司其职：

• Model（模型）：
  通常指的就是我们的数据模型。作用一般情况下用于封装数据。
• View（视图）：
  通常指的就是我们的 jsp 或者 html。作用一般就是展示数据的。
  通常视图是依据模型数据创建的。
• Controller（控制器）：
  是应用程序中处理用户交互的部分。作用一般就是处理程序逻辑的。
  它相对于前两个不是很好理解，这里举个例子：例如：我们要保存一个用户的信息，该用户信息中包含了姓名，性别，年龄等等。这时候表单输入要求年龄必须是 1~100 之间的整数。姓名和性别不能为空。并且把数据填充到模型之中。此时除了 js 的校验之外，服务器端也应该有数据准确性的校验，那么校验就是控制器的该做的。当校验失败后，由控制器负责把错误页面展示给使用者。如果校验成功，也是控制器负责把数据填充到模型，并且调用业务层实现完整的业务需求。

1.3.经典三层架构和MVC的关系

他们是两个毫无相关的东西，经典三层架构是一种分层思想，将开发模式分为了这三层，每个人根据自己的专长，开发不同的模块，比如，前端工程师，那么就专研表示层即可，想办法如何让页面变的更好看，如何吸引别人，而有些专门做数据库工作的人，就可以只关注操作数据库的活，如何让查询更加快速有效，而不必关注数据该如何显示这种问题。这就是分层带来的巨大好处。

而MVC是一种设计模式，目的是让HTML代码和业务逻辑代码分开，让代码看起来更加清晰，便于开发。
硬说他们有关系的话，只能说他们有共同的点，分层，解耦。
实际项目中的包命名结构，其也是按照三层架构思想来进行编写代码的，脑袋里要保持着这种思想进行开发.

xxx:代表公司名称
yyy：代表项目名称

com.xxx.yyy.dao　　　　　　dao层接口
com.xxx.yyy.dao.impl　　　　dao层实现
com.xxx.yyy.service　　　　 service层接口
com.xxx.yyy.service.impl　　 service层实现　　　　　　
com.xxx.yyy.web　　　　　　web层
com.xxx.yyy.util　　　　　　 工具包
com.xxx.yyy.domain　　　　 javabean、pojo、bean、vo、entity

二、SpringMVC 概述

2.1.SpringMVC 是什么

SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于 Spring FrameWork 的后续产品，已经融合在 Spring Web Flow 里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用 Spring 进行 WEB 开发时，可以选择使用 Spring的 Spring MVC 框架或集成其他 MVC 开发框架，如 Struts1(现在一般不用)，Struts2 等。

SpringMVC 已经成为目前最主流的 MVC 框架之一，并且随着 Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持RESTful 编程风格的请求。

2.2.SpringMVC 在三层架构的位置

2.3.SpringMVC的优势

• 1.清晰的角色划分：

  前端控制器（DispatcherServlet）
  请求到处理器映射（HandlerMapping）
  处理器适配器（HandlerAdapter）
  视图解析器（ViewResolver）
  处理器或页面控制器（Controller）
  验证器（ Validator）
  命令对象（Command 请求参数绑定到的对象就叫命令对象）
  表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。

• 2.分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要。

• 3.由于命令对象就是一个 POJO，无需继承框架特定 API，可以使用命令对象直接作为业务对象。

• 4.和 Spring 其他框架无缝集成，是其它 Web 框架所不具备的。

• 5、可适配，通过 HandlerAdapter 可以支持任意的类作为处理器。

• 6、可定制性，HandlerMapping、ViewResolver 等能够非常简单的定制。

• 7、功能强大的数据验证、格式化、绑定机制。

• 8、利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试。

• 9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换。

• 10、强大的 JSP 标签库，使 JSP 编写更容易。

  还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配
  置支持等等。

  Thymeleaf

  FreeMarker

  Velocity

  JSP

2.4.SpringMVC 和 Struts2 的优略分析

• 共同点：
  它们都是表现层框架，都是基于 MVC 模型编写的。
  它们的底层都离不开原始 ServletAPI。
  它们处理请求的机制都是一个核心控制器。

• 区别：
  Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter

  Spring MVC 是基于方法设计的，而 Struts2 是基于类，Struts2 每次执行都会创建一个动作类。所以 Spring MVC 会稍微比 Struts2 快些。Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便(JSR303 是一套 JavaBean 参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注解加在我们 JavaBean 的属性上面，就可以在需要校验的时候进行校验了)Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比 JSTL 提升，尤其是 struts2 的表单标签，远没有 html 执行效率高。

三、SpringMVC 的入门案例

3.1 创建一个maven工程并导入依赖

• maven项目pom配置:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>haidi8_springmvcartifactId>
        <groupId>com.haidi8.mybatisgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <groupId>com.haidi8.springmvcgroupId>
    <artifactId>springmvc_v1.0artifactId>
    <packaging>warpackaging>

    <name>springmvc_v1.0 Maven Webappname>
    
    <url>http://www.example.comurl>

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

    <dependencies>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-testartifactId>
            <version>5.3.2version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.3.2version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-aspectsartifactId>
            <version>5.3.2version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webartifactId>
            <version>5.3.2version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.3.2version>
        dependency>

        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>javax.servlet-apiartifactId>
            <version>3.1.0version>
            <scope>providedscope>
        dependency>

    dependencies>

    <build>
        <finalName>springmvc_v1.0finalName>
        <pluginManagement>
            <plugins>
                <plugin>
                    <artifactId>maven-clean-pluginartifactId>
                    <version>3.1.0version>
                plugin>
                
                <plugin>
                    <artifactId>maven-resources-pluginartifactId>
                    <version>3.0.2version>
                plugin>
                <plugin>
                    <artifactId>maven-compiler-pluginartifactId>
                    <version>3.8.0version>
                plugin>
                <plugin>
                    <artifactId>maven-surefire-pluginartifactId>
                    <version>2.22.1version>
                plugin>
                <plugin>
                    <artifactId>maven-war-pluginartifactId>
                    <version>3.2.2version>
                plugin>
                <plugin>
                    <artifactId>maven-install-pluginartifactId>
                    <version>2.5.2version>
                plugin>
                <plugin>
                    <artifactId>maven-deploy-pluginartifactId>
                    <version>2.8.2version>
                plugin>
            plugins>
        pluginManagement>


        <resources>
            
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    
                    <include>**/*.xmlinclude>
                includes>
            resource>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*include>
                includes>
            resource>
        resources>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.6.0version>
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                configuration>
            plugin>
        plugins>
    build>
project>

3.2.配置核心控制器

配置在 web.xml 中配置 DispatcherServlet 核心控制器(Servlet)

DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Applicationdisplay-name>

  
  <servlet>
    <servlet-name>DispatcherServletservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    
    <init-param>
      <param-name>contextConfigLocationparam-name>
      <param-value>classpath:springmvc.xmlparam-value>
    init-param>

    
    <load-on-startup>1load-on-startup>
  servlet>
  
  <servlet-mapping>
    <servlet-name>DispatcherServletservlet-name>
    <url-pattern>/url-pattern>
  servlet-mapping>
web-app>

3.3.创建 spring mvc 的配置文件

<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.haidi8.springmvc.controller">context:component-scan>

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

3.4.编写控制器并使用注解配置

//声明Bean对象，为一个控制器组件
@Controller
public class HelloWorld {
	
	/**
	 * 映射请求的名称：用于客户端请求；类似Struts2中action映射配置的action名称
	 * 1. 使用 @RequestMapping 注解来映射请求的 URL
	 * 2. 返回值会通过视图解析器解析为实际的物理视图, 对于 InternalResourceViewResolver 视图解析器, 
	 * 会做如下的解析:
	 *                 通过 prefix + returnVal + suffix 这样的方式得到实际的物理视图, 然后做转发操作.
	 *                 /WEB-INF/views/success.jsp
	 */
	
    @RequestMapping("/hello")
    public String helloword(HttpServletRequest request){
        System.out.println("hello控制器被访问啦！");
        request.setAttribute("msg","欢迎来到SpringMvc！"); //存值
        return "hello"; //默认转发forward：视图  /WEB-INF/jsp/hello.jsp
    }
}

@Controller 来源于@Component标示为控制层，用于加在类上。
@RequestMapping(“/helloworld”) 该方法对应的uri;
控制器类的方法返回字符串类型非常常见,返回字符串,代表根据返回的字符串找到对应的视图!
根据springmvc配置文件中视图解析器(InternalResourceViewResolver) 配置的视图文件的前缀和后缀!
helloworld()方法返回 “helloworld” 会找到 WEB-INF/jsp/success.jsp文件!

3.5.测试Spring MVC

发布项目,通过浏览器,访问 当前项目对应地址+ /helloworld即可
http://localhost:8080/springmvc-demo1/helloworld

四、入门案例的执行过程及原理分析

4.1 案例的执行过程

1、服务器启动，应用被加载。读取到 web.xml 中的配置创建 spring 容器并且初始化容器中的对象。从入门案例中可以看到的是：HelloController 和 InternalResourceViewResolver，但是远不
止这些。
2、浏览器发送请求，被 DispatherServlet 捕获，该 Servlet 并不处理请求，而是把请求转发出去。转发
的路径是根据请求 URL，匹配@RequestMapping 中的内容。
3、匹配到了后，执行对应方法。该方法有一个返回值。
4、根据方法的返回值，借助 InternalResourceViewResolver 找到对应的结果视图。
5、渲染结果视图，响应浏览器。

4.2 SpringMVC 的请求响应流程

第一步：用户发送请求到前端控制器（DispatcherServlet）。
第二步：前端控制器请求 HandlerMapping 查找 Handler(Controller)，可以根据 xml 配置或者注解进行查找。
第三步：处理器映射器 HandlerMapping 向前端控制器返回 Handler(Controller)
第四步：前端控制器调用处理器适配器(HandlerAdapter)去执行 Handler(Controller)
第五步：处理器适配器执行 Handler
第六步：Handler 执行完成后给适配器返回 ModelAndView
第七步：处理器适配器向前端控制器返回 ModelAndView
　　　　ModelAndView 是SpringMVC 框架的一个底层对象，包括 Model(模型数据) 和 View(视图)
第八步：前端控制器请求试图解析器去进行视图解析
　　　　根据逻辑视图名来解析真正的视图。
第九步：试图解析器向前端控制器返回 view
第十步：前端控制器进行视图渲染
　　　　就是将模型数据（在 ModelAndView 对象中）填充到 request 域
第十一步：前端控制器向用户响应结果

4.3 SpringMVC的组件

• DispatcherServlet：前端控制器（不需要程序员开发,需要WEB.xml配置）
  用户请求到达前端控制器，它就相当于 mvc 模式中的 c，dispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet 的存在降低了组件之间的耦合性。
• HandlerMapping：处理器映射器（不需要程序员开发）
  HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
• Handler（Controller）：处理器（需要程序员开发）
  它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由Handler 对具体的用户请求进行处理。
• HandlAdapter：处理器适配器（不需要程序员开发）
  通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。按照特定规则（HandlerAdapter要求的规则）去执行Handler（Controller）
• View Resolver：视图解析器（不需要程序员开发，只需要配置）
  View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。
• View：视图
  SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是 jsp。
  一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

五、springmvc的请求参数绑定说明

5.1.绑定的机制

我们都知道，表单中请求参数都是基于 key=value 的。
SpringMVC 绑定请求参数的过程是通过把表单提交请求参数，作为控制器中方法参数进行绑定的。
例如：

查询账户

中请求参数是：

accountId=10

Controller实现：

/**
* 查询账户
* @return
*/
@RequestMapping("/findAccount")
public String findAccount(Integer accountId) {
   System.out.println("查询了账户。。。。"+accountId);
   return "success"; 
}

5.2.支持的数据类型

• 基本类型参数：
  包括基本类型和 String 类型
• POJO 类型参数：
  包括实体类，以及关联的实体类
• 数组和集合类型参数：
  包括 List 结构和 Map 结构的集合（包括数组）
  SpringMVC 绑定请求参数是自动实现的，但是要想使用，必须遵循使用要求。

5.3.使用要求

• 如果是基本类型或者 String 类型：
  要求我们的参数名称必须和控制器中方法的形参名称保持一致。(严格区分大小写)
• 如果是 POJO 类型，或者它的关联对象：
  要求表单中参数名称和 POJO 类的属性名称保持一致。并且控制器方法的参数类型是 POJO 类型。
• 如果是集合类型,有两种方式：
  第一种：
  要求集合类型的请求参数必须在 POJO 中。在表单中请求参数名称要和 POJO 中集合属性名称相同。
  给 List 集合中的元素赋值，使用下标。
  给 Map 集合中的元素赋值，使用键值对。
  第二种：
  接收的请求参数是 json 格式数据。需要借助一个注解实现。

注意: 它还可以实现一些数据类型自动转换。内置转换器全都在：
org.springframework.core.convert.support 包下。

有： java.lang.Boolean ->
java.lang.String : ObjectToStringConverter java.lang.Character ->
java.lang.Number : CharacterToNumberFactory java.lang.Character ->
java.lang.String : ObjectToStringConverter java.lang.Enum ->
java.lang.String : EnumToStringConverter java.lang.Number ->
java.lang.Character : NumberToCharacterConverter java.lang.Number ->
java.lang.Number : NumberToNumberConverterFactory java.lang.Number ->
java.lang.String : ObjectToStringConverter java.lang.String ->
java.lang.Boolean : StringToBooleanConverter java.lang.String ->
java.lang.Character : StringToCharacterConverter java.lang.String ->
java.lang.Enum : StringToEnumConverterFactory java.lang.String ->
java.lang.Number : StringToNumberConverterFactory java.lang.String ->
java.util.Locale : StringToLocaleConverter java.lang.String ->
java.util.Properties : StringToPropertiesConverter java.lang.String ->
java.util.UUID : StringToUUIDConverter java.util.Locale ->
java.lang.String : ObjectToStringConverter java.util.Properties ->
java.lang.String : PropertiesToStringConverter java.util.UUID ->
java.lang.String : ObjectToStringConverter …
如遇特殊类型转换要求，需要我们自己编写自定义类型转换器。

5.4.使用示例

5.4.1.基本类型和 String 类型作为参数

• jsp 代码：

<a href="account/findAccount?accountId=10&accountName=zhangsan">查询账户a>

• 控制器代码：

/**
* 查询账户
* @return
*/
@RequestMapping("/findAccount")
public String findAccount(Integer accountId,String accountName) {
   System.out.println("查询了账户。。。。"+accountId+","+accountName);
   return "success";
}

5.4.2.POJO 类型作为参数

• 实体类代码：

/**
* 账户信息
* @Version 1.0
*/
public class Account implements Serializable {
	private Integer id;
	private String name;
	private Float money;
	private Address address;
	//getters and setters
}

/**
* 地址的实体类
* @Version 1.0
*/
public class Address implements Serializable {
	private String provinceName;
	private String cityName;
	//getters and setters
}

• jsp 代码：

 
<form action="account/saveAccount" method="post">
	账户名称：<input type="text" name="name" ><br/>
	账户金额：<input type="text" name="money" ><br/>
	账户省份：<input type="text" name="address.provinceName" ><br/>
	账户城市：<input type="text" name="address.cityName" ><br/>
	<input type="submit" value="保存">
form>

• 控制器代码：

/**
* 保存账户
* @param account
* @return
*/
@RequestMapping("/saveAccount")
public String saveAccount(Account account) {
	System.out.println("保存了账户。。。。"+account);
	return "success"; 
}

5.4.3.POJO POJO 类中包含集合类型参数

• 实体类代码：

/**
* 用户实体类
* @Version 1.0
*/
public class User implements Serializable {
	private String username;
	private String password;
	private Integer age;
	private List<Account> accounts;
	private Map<String,Account> accountMap;
	//getters and setters
	@Override
	public String toString() {
	return "User [username=" + username + ", password=" + password + ", age="
	+ age + ",\n accounts=" + accounts
	+ ",\n accountMap=" + accountMap + "]";
	}
}

• jsp 代码：

 
<form action="account/updateAccount" method="post">
	用户名称：<input type="text" name="username" ><br/>
	用户密码：<input type="password" name="password" ><br/>
	用户年龄：<input type="text" name="age" ><br/>
	账户 1 名称：<input type="text" name="accounts[0].name" ><br/>
	账户 1 金额：<input type="text" name="accounts[0].money" ><br/>
	账户 2 名称：<input type="text" name="accounts[1].name" ><br/>
	账户 2 金额：<input type="text" name="accounts[1].money" ><br/>
	账户 3 名称：<input type="text" name="accountMap['one'].name" ><br/>
	账户 3 金额：<input type="text" name="accountMap['one'].money" ><br/>
	账户 4 名称：<input type="text" name="accountMap['two'].name" ><br/>
	账户 4 金额：<input type="text" name="accountMap['two'].money" ><br/>
	<input type="submit" value="保存">
form>

• 控制器代码：

/**
* 更新账户
* @return
*/
@RequestMapping("/updateAccount")
public String updateAccount(User user) {
	System.out.println("更新了账户。。。。"+user);
	return "success"; 
}

5.4.4.请求参数乱码问题

• post 请求方式：
  在 web.xml 中配置一个过滤器

 
<filter> 
	<filter-name>CharacterEncodingFilterfilter-name> 
	<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
	 
	<init-param> 
		<param-name>encodingparam-name> 
		<param-value>UTF-8param-value>
	init-param>
	 
	<init-param> 
		<param-name>forceEncodingparam-name> 
		<param-value>trueparam-value>
	init-param>
filter>
 
<filter-mapping> 
	<filter-name>CharacterEncodingFilterfilter-name> 
	<url-pattern>/*url-pattern>
filter-mapping>

• get请求方式：
  tomacat 对 GET和POST请求处理方式是不同的,GET请求的编码问题，要改tomcat的server.xml
  配置文件，如下：

<Connector connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

改为:

<Connector connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443" useBodyEncodingForURI="true"/>

如果遇到 ajax 请求仍然乱码，请把：

useBodyEncodingForURI="true" 改为 URIEncoding="UTF-8"

即可。

5.4.5.静态资源过滤问题

在 springmvc 的配置文件中可以配置，静态资源不过滤：

<mvc:resources location="/css/" mapping="/css/**"/>
<mvc:resources location="/images/" mapping="/images/**"/>
<mvc:resources location="/scripts/" mapping="/javascript/**"/>

5.5.自定义类型转换器

5.5.1.使用场景

• jsp代码：

 
<a href="account/deleteAccount?date=2018-01-01">根据日期删除账户a>

• 控制器代码：

/**
* 删除账户
* @return
*/
@RequestMapping("/deleteAccount")
public String deleteAccount(String date) {
	System.out.println("删除了账户。。。。"+date);
	return "success"; 
}

• 运行结果：
  
  当我们把控制器中方法参数的类型改为 Date 时：

/**
* 删除账户
* @return
*/
@RequestMapping("/deleteAccount")
public String deleteAccount(Date date) {
	System.out.println("删除了账户。。。。"+date);
	return "success"; 
}

• 运行结果：
  
• 异常提示:
  Failed to bind request element: org.springframework.web.method.annotation.MethodArgumentTypeMismatchException: Failed to convert value of type 'java.lang.String' to required type 'java.util.Date'; nested exception is org.springframework.core.convert.ConversionFailedException: Failed to convert from type [java.lang.String] to type [java.util.Date] for value '2018-01-01'; nested exception is java.lang.IllegalArgumentException

5.5.2.使用步骤

• 第一步：定义一个类，实现 Converter 接口，该接口有两个泛型。

public interface Converter<S, T> {//S:表示接受的类型，T：表示目标类型
	/**
	* 实现类型转换的方法
	*/
	@Nullable
	T convert(S source);
}

/**
* 自定义类型转换器
* @Version 1.0
*/
public class StringToDateConverter implements Converter<String, Date> {
	/**
	* 用于把 String 类型转成日期类型
	*/
	@Override
	public Date convert(String source) {
		DateFormat format = null;
		try {
			if(StringUtils.isEmpty(source)) {
			   throw new NullPointerException("请输入要转换的日期");
		    }
			format = new SimpleDateFormat("yyyy-MM-dd");
			Date date = format.parse(source);
			return date;
	    } catch (Exception e) {
		    throw new RuntimeException("输入日期有误");
		} 
    } 
}

• 第二步：在 spring 配置文件中配置类型转换器。
  spring 配置类型转换器的机制是，将自定义的转换器注册到类型转换服务中去。

 
<bean id="converterService"
class="org.springframework.context.support.ConversionServiceFactoryBean">
	 
	<property name="converters"> 
		<array>
			 
			<bean class="com.bruceliu.web.converter.StringToDateConverter">bean>
		array>
	property>
bean>

• 第三步：在 annotation-driven 标签中引用配置的类型转换服务

 <mvc:annotation-driven
conversion-service="converterService">mvc:annotation-driven>

• 运行结果：
  

5.6.使用 ServletAPI 对象作为方法参数

SpringMVC 还支持使用原始 ServletAPI 对象作为控制器方法的参数。支持原始 ServletAPI 对象有：

HttpServletRequest 
HttpServletResponse
HttpSession
java.security.Principal
Locale
InputStream 
OutputStream 
Reader 
Writer

我们可以把上述对象，直接写在控制的方法参数中使用。部分示例代码：

• jsp 代码：

<a href="account/testServletAPI">测试访问 ServletAPIa>

• 控制器中的代码：

/**
* 测试访问 testServletAPI
* @return
*/
@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request,HttpServletResponse response,
HttpSession session) {
	System.out.println(request);
	System.out.println(response);
	System.out.println(session);
	return "success"; 
}

• 执行结果：

六、图书管理系统springmvc项目

项目目录：

建表：

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for tb_book
-- ----------------------------
DROP TABLE IF EXISTS `tb_book`;
CREATE TABLE `tb_book` (
  `id` int NOT NULL AUTO_INCREMENT,
  `title` varchar(255) COLLATE utf8_bin DEFAULT NULL,
  `author` varchar(255) COLLATE utf8_bin DEFAULT NULL,
  `price` double(10,2) DEFAULT NULL,
  `publishtime` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
  `publish` varchar(255) COLLATE utf8_bin DEFAULT NULL,
  `photo` varchar(500) COLLATE utf8_bin DEFAULT NULL,
  `type_id` int DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_type_id` (`type_id`),
  CONSTRAINT `FK_type_id` FOREIGN KEY (`type_id`) REFERENCES `tb_book_type` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb3 COLLATE=utf8_bin;

-- ----------------------------
-- Records of tb_book
-- ----------------------------
INSERT INTO `tb_book` VALUES ('1', '三国演义', '罗贯中', '122.00', '2022-02-15 14:31:07', '人民教育出版社', '3434.jpg', '1');
INSERT INTO `tb_book` VALUES ('3', '红楼梦', '曹雪芹', '233.00', '2022-02-16 09:12:34', '人民教育出版社', '2323.jpg', '1');

-- ----------------------------
-- Table structure for tb_book_type
-- ----------------------------
DROP TABLE IF EXISTS `tb_book_type`;
CREATE TABLE `tb_book_type` (
  `id` int NOT NULL AUTO_INCREMENT,
  `type` varchar(255) COLLATE utf8_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb3 COLLATE=utf8_bin;

-- ----------------------------
-- Records of tb_book_type
-- ----------------------------
INSERT INTO `tb_book_type` VALUES ('1', '历史类');
INSERT INTO `tb_book_type` VALUES ('2', '言情类');
INSERT INTO `tb_book_type` VALUES ('3', '计算机类');

pom文件：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
    <artifactId>haidi8_springmvcartifactId>
    <groupId>com.haidi8.mybatisgroupId>
    <version>1.0-SNAPSHOTversion>
  parent>
  <modelVersion>4.0.0modelVersion>

  <groupId>com.haidi8.springmvcgroupId>
  <artifactId>springmvc_v4.0artifactId>
  <packaging>warpackaging>

  <name>springmvc_v4.0 Maven Webappname>
  
  <url>http://www.example.comurl>

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

  <dependencies>

    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.12version>
      <scope>testscope>
    dependency>

    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>5.3.2version>
    dependency>

    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.3.2version>
    dependency>

    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-aspectsartifactId>
      <version>5.3.2version>
    dependency>

    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webartifactId>
      <version>5.3.2version>
    dependency>

    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>5.3.2version>
    dependency>

    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>javax.servlet-apiartifactId>
      <version>3.1.0version>
      <scope>providedscope>
    dependency>

    
    <dependency>
      <groupId>org.projectlombokgroupId>
      <artifactId>lombokartifactId>
      <version>1.16.18version>
      <scope>providedscope>
    dependency>

    <dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.6version>
    dependency>

    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>8.0.25version>
    dependency>

    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatis-springartifactId>
      <version>1.3.0version>
    dependency>

    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>3.4.5version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-jdbcartifactId>
      <version>5.3.2version>
    dependency>

    <dependency>
      <groupId>log4jgroupId>
      <artifactId>log4jartifactId>
      <version>1.2.14version>
    dependency>

    <dependency>
      <groupId>org.slf4jgroupId>
      <artifactId>slf4j-apiartifactId>
      <version>1.7.22version>
    dependency>

    <dependency>
      <groupId>org.slf4jgroupId>
      <artifactId>slf4j-log4j12artifactId>
      <version>1.7.22version>
    dependency>

    
    
    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>jstlartifactId>
      <version>1.2version>
    dependency>

  dependencies>

  <build>
    <finalName>springmvc_v4.0finalName>
    <pluginManagement>
      <plugins>
        <plugin>
          <artifactId>maven-clean-pluginartifactId>
          <version>3.1.0version>
        plugin>
        
        <plugin>
          <artifactId>maven-resources-pluginartifactId>
          <version>3.0.2version>
        plugin>
        <plugin>
          <artifactId>maven-compiler-pluginartifactId>
          <version>3.8.0version>
        plugin>
        <plugin>
          <artifactId>maven-surefire-pluginartifactId>
          <version>2.22.1version>
        plugin>
        <plugin>
          <artifactId>maven-war-pluginartifactId>
          <version>3.2.2version>
        plugin>
        <plugin>
          <artifactId>maven-install-pluginartifactId>
          <version>2.5.2version>
        plugin>
        <plugin>
          <artifactId>maven-deploy-pluginartifactId>
          <version>2.8.2version>
        plugin>
      plugins>
    pluginManagement>

    <resources>
      
      <resource>
        <directory>src/main/javadirectory>
        <includes>
          
          <include>**/*.xmlinclude>
        includes>
      resource>
      <resource>
        <directory>src/main/resourcesdirectory>
        <includes>
          <include>**/*include>
        includes>
      resource>
    resources>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.pluginsgroupId>
        <artifactId>maven-compiler-pluginartifactId>
        <version>3.6.0version>
        <configuration>
          <source>1.8source>
          <target>1.8target>
        configuration>
      plugin>
    plugins>
  build>
project>

实体类：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {

    private Integer id;
    private String title;
    private String author;
    private Double price;

    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date publishtime;  //TODO：SpringMvc时间需要类型转换  400异常！！

    private String publish;
    private String photo; //图片地址
    private Integer type_id;

    //图书类别
    private BookType bookType;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class BookType {

    private Integer id;
    private String type; //数据库type
}

mapper层：

public interface BookMapper {

    List<Book> list();

    int deleteById(Integer id);

    int add(Book book);

    Book findById(Integer id);

    int update(Book book);
}


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ssm.mapper.BookMapper">

    <resultMap id="bookMap" type="com.haidi8.springmvc.bean.Book">
        <id column="id" property="id"/>
        <result column="title" property="title"/>
        <result column="author" property="author"/>
        <result column="price" property="price"/>
        <result column="publishtime" property="publishtime"/>
        <result column="publish" property="publish"/>
        <result column="photo" property="photo"/>
        <result column="type_id" property="type_id"/>
        <association property="bookType" javaType="com.haidi8.springmvc.bean.BookType">
            <id column="tid" property="id"/>
            <result column="type" property="type"/>
        </association>
    </resultMap>

    <select id="list" resultMap="bookMap">
        SELECT
            tb_book.*, tb_book_type.id tid,
            tb_book_type.type
        FROM
            tb_book
                INNER JOIN tb_book_type ON tb_book.type_id = tb_book_type.id
    </select>

    <delete id="deleteById">
        delete from tb_book where id=#{id}
    </delete>

    <insert id="add">
        insert  into tb_book values (null,#{title},#{author},#{price},#{publishtime},#{publish},#{photo},#{type_id})
    </insert>

    <select id="findById" resultType="com.ssm.bean.Book">
        select * from tb_book where id=#{id}
    </select>

    <update id="update">
        update tb_book
        <set>
            <if test="title!=null and title!=''">
                title=#{title},
            </if>
            <if test="author!=null and author!=''">
                author=#{author},
            </if>
            <if test="publish!=null and publish!=''">
                publish=#{publish},
            </if>
            <if test="price!=null">
                price=#{price},
            </if>
            <if test="publishtime!=null">
                publishtime=#{publishtime},
            </if>
            <if test="photo!=null and photo!=''">
                photo=#{photo},
            </if>
            <if test="type_id!=null">
                type_id=#{type_id}
            </if>
        </set>
        where id=#{id}
    </update>

</mapper>
        
        
public interface BookTypeMapper {

    List<BookType> list();
}


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ssm.mapper.BookTypeMapper">

    <select id="list" resultType="com.haidi8.springmvc.bean.BookType">
        select * from tb_book_type
    </select>

</mapper>

service层：

public interface BookService {

    List<Book> list();

    int deleteById(Integer id);

    int add(Book book);

    Book findById(Integer id);

    int update(Book book);
}


@Service
public class BookServiceImpl implements BookService {

    @Autowired
    BookMapper bookMapper;

    @Override
    public List<Book> list() {
        return bookMapper.list();
    }

    @Override
    public int deleteById(Integer id) {
        return bookMapper.deleteById(id);
    }

    @Override
    public int add(Book book) {
        return bookMapper.add(book);
    }

    @Override
    public Book findById(Integer id) {
        return bookMapper.findById(id);
    }

    @Override
    public int update(Book book) {
        return bookMapper.update(book);
    }
}


public interface BookTypeService {

    List<BookType> list();
}


@Service
public class BookTypeServiceImpl implements BookTypeService {

    @Autowired
    BookTypeMapper bookTypeMapper;

    @Override
    public List<BookType> list() {
        return bookTypeMapper.list();
    }
}

控制层：

/**
 * 控制器
 */
@Controller
@RequestMapping("/book")  //访问控制器的 父路径
public class BookController {

    /**
     * 控制器层获取业务逻辑层对象
     */
    @Resource
    BookService bookService;

    /**
     * 01-查询
     * @param request
     * @return
     */
    @RequestMapping("/list")
    public String list(HttpServletRequest request) {
        List<Book> books = bookService.list();
        request.setAttribute("books", books);
        System.out.println("books=" + books);
        return "book_list";
    }

    /**
     * 02-根据ID删除
     */
    @RequestMapping("/delete")
    public void delete(Integer id, HttpServletResponse response) throws Exception{
        response.setContentType("text/html;charset=utf-8");//设置响应乱码
        System.out.println("删除的ID是:"+id);
        int count=bookService.deleteById(id);
        if(count>0){
            response.getWriter().write("");
        }else{
            response.getWriter().write("");
        }
    }

    /**
     * 03-跳转到新增页面
     * @return
     */
    @RequestMapping("/toadd")
    public String toadd(){
        return "book_add"; //跳转 /WEB-INF/jsp/book_add.jsp
    }

    /**
     * 04-新增图书
     * @param book
     */
    @RequestMapping("/add")
    public void add(Book book, HttpServletResponse response, MultipartFile file,HttpServletRequest request) throws Exception{
        response.setContentType("text/html;charset=utf-8");//设置响应乱码
        System.out.println("表单新增的对象数据:"+book);

        //1.获取原始文件名
        String uploadFileName = file.getOriginalFilename();
        System.out.println("要上传的原始文件名字是:"+uploadFileName); //2222.jpg
        //2.截取文件扩展名
        String extendName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1, uploadFileName.length());
        //3.把文件加上随机数，防止文件重复
        String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
        //4.生成的新的服务器文件名
        String newfileName=uuid+"."+extendName;
        System.out.println("生成的新的服务器文件名是:"+newfileName); //防止服务器文件名重名
        //5.获取真实的服务器文件上传地址
        String filePath=request.getServletContext().getRealPath("/images/upload")+"/"+newfileName;
        System.out.println("服务器运行目录，最终上传的路径:"+filePath);
        //6.执行上传
        file.transferTo(new File(filePath));
        System.out.println("文件上传结束！");

        book.setPhoto(newfileName); //文件数据名字
        int count=bookService.add(book);
        if(count>0){
            response.getWriter().write("");
        }else{
            response.getWriter().write("");
        }
    }

    /**
     * 05-跳转更新页面
     * @param id
     * @return
     */
    @RequestMapping("/toupdate")
    public String topupdate(Integer id,HttpServletRequest request){
        System.out.println("要更新的ID是："+id);
        //根据ID查询对象
        Book book=bookService.findById(id);
        request.setAttribute("book",book);
        return "book_update";
    }

    /**
     * 06-更新图书
     * @param book
     */
    @RequestMapping("/update")
    public void update(Book book,HttpServletResponse response) throws Exception{
        response.setContentType("text/html;charset=utf-8");//设置响应乱码
        System.out.println("表单更新的对象数据:"+book);
        int count=bookService.update(book);
        if(count>0){
            response.getWriter().write("");
        }else{
            response.getWriter().write("");
        }
    }
}


@Controller
@RequestMapping("/booktype")
public class BookTypeController {

    @Autowired
    BookTypeService bookTypeService;

    /**
     * 查询所有的图书类别  Ajax请求
     */
    @ResponseBody //把方法返回值自动转JSON 需要导入依赖！！！
    @RequestMapping("/types")
    public List<BookType> list() throws Exception{
          return bookTypeService.list();
//        response.setContentType("application/json;charset=utf-8");
//        //图书列别集合
//        List bookTypes =
//        //转JSON
//        String s = JSON.toJSONString(bookTypes);
//        response.getWriter().write(s);
    }
}

db.properties

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=123456
jdbc.url=jdbc:mysql://127.0.0.1:3306/springmvc2022?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai

log4j.properties:

# log4J日志框架的配置文件 文件名字不能改
# DEBUG 表示日志的级别  调试
# Console 日志打印在控制台
# INFO 正常信息
log4j.rootLogger=INFO, Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n

# 哪些日志需要打印
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.org.apache=DEBUG
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

spring.xml:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    
    <context:component-scan base-package="com.haidi8.springmvc.service"/>

    <context:property-placeholder location="classpath:db.properties" file-encoding="UTF-8"/>

    <bean id="ds" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}">property>
        <property name="password" value="${jdbc.password}">property>
        <property name="url" value="${jdbc.url}">property>
        <property name="driverClassName" value="${jdbc.driverClassName}">property>
    bean>

    
    
    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        
        <property name="dataSource" ref="ds"/>
        
        
        <property name="typeAliasesPackage" value="com.ssm.bean"/>
    bean>

    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="basePackage" value="com.ssm.mapper"/>
    bean>

    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="ds"/>
    bean>

    
    <tx:annotation-driven transaction-manager="transactionManager"/>

beans>

springmvc.xml:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

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


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

    
    <mvc:resources location="/images/" mapping="/images/**"/>
    <mvc:resources location="/css/" mapping="/css/**"/>
    <mvc:resources location="/scripts/" mapping="/scripts/**"/>

    
    <mvc:annotation-driven/>

    
    
    
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        
        <property name="maxUploadSize" value="5242880"/>
    bean>

beans>

book_list.jsp:

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>


    

    

    



    
图书列表
    

    
            

        

            
编号
            
标题
            
封面
            
价格
            
类型
            
作者
            
出版社
            
出版时间
            
操作
        
        

                
${book.id}
                
${book.title}
                

                    
                
                
${book.price}
                
${book.bookType.type}
                
${book.author}
                
${book.publish}
                

                   
                
                

                    更新
                    删除
                
            
        
    
    

    

    

    图书新增

book_add.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    
    
    
    
    
    


  
      
图书新增
      

          标题：  

          类型：  
                 
                 

          作者：  

          图片：  
                 

          价格：  

          出版社：  

          出版时间：


          
          
      
  

book_update.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>


    
    
    
    
    
    


  
      
图书更新
      

          标题：  

                  
                  
          类型：  

                 
                 

          作者：  

          图片：  

          价格：  

          出版社：  

          出版时间：


          
          
      
  

web.xml:

DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>Archetype Created Web Applicationdisplay-name>

    
    <context-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:spring.xmlparam-value>
    context-param>

    
    <filter>
        <filter-name>CharacterEncodingFilterfilter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
        
        <init-param>
            <param-name>encodingparam-name>
            <param-value>UTF-8param-value>
        init-param>
        
        <init-param>
            <param-name>forceEncodingparam-name>
            <param-value>trueparam-value>
        init-param>
    filter>
    
    <filter-mapping>
        <filter-name>CharacterEncodingFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>


    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    listener>

    
    <servlet>
        <servlet-name>DispatcherServletservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:springmvc.xmlparam-value>
        init-param>
        
        <load-on-startup>1load-on-startup>
    servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServletservlet-name>
        
        <url-pattern>/url-pattern>
    servlet-mapping>

web-app>

注意：

SpringMvc请求流程：

springMvc入门程序：

配置视图解析器：

springMvc流程详细图：

spring框架的web启动方式：

springMvc运行流程：

fastJson转换器配置：

Goson转换器：

Post请求过滤器：

SpringMvc同步文件上传：

springMvc时间处理：

ｓｐｒｉｎｇＭｖｃ的文件上传字段要求：

七、返回值分类

7.1.字符串

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

• Cronller代码：

//指定逻辑视图名，经过视图解析器解析为 jsp 物理路径：/WEB-INF/pages/success.jsp
@RequestMapping("/testReturnString")
public String testReturnString() {
	System.out.println("AccountController的testReturnString 方法执行了。。。。");
	return "success"; 
}

• 运行结果：

7.2.void

我们知道 Servlet 原始 API 可以作为控制器中方法的参数：

@RequestMapping("/testReturnVoid")
public void testReturnVoid(HttpServletRequest request,HttpServletResponse response) 
throws Exception {
}

在 controller 方法形参上可以定义 request 和 response，使用 request 或 response 指定响应结果：
1、使用 request 转向页面，如下：

request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request, response);

2、也可以通过 response 页面重定向：

response.sendRedirect("testRetrunString");

3、也可以通过 response 指定响应结果，例如响应 json 数据：

response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
response.getWriter().write("json 串");

7.3.ModelAndView

ModelAndView 是 SpringMVC 为我们提供的一个对象，该对象也可以用作控制器方法的返回值。
该对象中有两个方法：

• 示例代码：

/**
* 返回 ModeAndView
* @return
*/
@RequestMapping("/testReturnModelAndView")
public ModelAndView testReturnModelAndView() {
	ModelAndView mv = new ModelAndView();
	mv.addObject("username", "张三");
	mv.setViewName("success");
	return mv; 
}

• 响应的 jsp 代码：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>执行成功title>
head> 
<body>
	执行成功！
	${requestScope.username}
body>
html>

• 输出结果：

注意：我们在页面上上获取使用的是 requestScope.username 取的，所以返回 ModelAndView 类型时，浏
览器跳转只能是请求转发。

7.4.转发和重定向

7.4.1 forward 转发

controller 方法在提供了 String 类型的返回值之后，默认就是请求转发。我们也可以写成：

/**
* 转发
* @return
*/
@RequestMapping("/testForward")
public String testForward() {
	System.out.println("AccountController的testForward方法执行了。。。。");
	return "forward:/WEB-INF/pages/success.jsp";
}

需要注意的是，如果用了 formward：则路径必须写成实际视图 url，不能写逻辑视图。
它相当于“request.getRequestDispatcher("url").forward(request,response)”。使用请求
转发，既可以转发到 jsp，也可以转发到其他的控制器方法。

7.4.2 Redirect 重定向

contrller 方法提供了一个 String 类型返回值之后，它需要在返回值里使用:redirect:

/**
* 重定向
* @return
*/
@RequestMapping("/testRedirect")
public String testRedirect() {
	System.out.println("AccountController 的 testRedirect 方法执行了。。。。");
	return "redirect:/testReturnModelAndView";
}

它相当于“response.sendRedirect(url)”。需要注意的是，如果是重定向到 jsp 页面，则 jsp 页面不能写在 WEB-INF 目录中，否则无法找到。

7.5.ResponseBody响应json数据

7.5.1.使用说明

• 作用：
  该注解用于将 Controller 的方法返回的对象，通过 HttpMessageConverter 接口转换为指定格式的数据如：json,xml 等，通过 Response 响应给客户端.

7.5.2.使用示例

• 需求：
  使用@ResponseBody 注解实现将 controller 方法返回对象转换为 json 响应给客户端。
• 前置知识点：
  Springmvc 默认用 MappingJacksonHttpMessageConverter 对 json 数据进行转换，需要加入
  jackson 的包。

<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.9.0version>
dependency>

注意：2.7.0 以下的版本用不了

• jsp 中的代码：

<script type="text/javascript"
src="${pageContext.request.contextPath}/js/jquery.min.js">script> <script type="text/javascript">
	$(function(){
		$("#testJson").click(function(){
			$.ajax({
				type:"post",
				url:"${pageContext.request.contextPath}/testResponseJson",
				contentType:"application/json;charset=utf-8",
				data:'{"id":1,"name":"test","money":999.0}',
				dataType:"json",
				success:function(data){
				alert(data);
				}
			});
		});
	})
script>
 
<input type="button" value="测试 ajax 请求 json 和响应 json" id="testJson"/>

• 控制器中的代码：

/**
* 响应json数据的控制器
* @Version 1.0
*/
@Controller("jsonController")
public class JsonController {

/**
* 测试响应 json 数据
*/
@RequestMapping("/testResponseJson")
public @ResponseBody Account testResponseJson(@RequestBody Account account) {
	System.out.println("异步请求："+account);
	return account; 
   }
}

• 运行结果：

八、SpringＭｖｃ实现文件上传

８.１回顾

８.１.1.文件上传的必要前提

A、form 表单的 enctype 取值必须是：multipart/form-data(默认值是:application/x-www-form-urlencoded) enctype:是表单请求正文的类型
B、method 属性取值必须是 Post
C、提供一个文件选择域

８.１.2.文件上传的原理分析

当 form 表单的 enctype 取值不是默认值后，request.getParameter()将失效。 enctype=”application/x-www-form-urlencoded”时，form 表单的正文内容是：
key=value&key=value&key=value，当 form 表单的 enctype 取值为Mutilpart/form-data时，请求正文内容就变成：
每一部分都是 MIME 类型描述的正文

８.１.3.借助第三方组件实现文件上传

使用 Commons-fileupload 组件实现文件上传，需要导入该组件相应的支撑 jar 包：Commons-fileupload 和commons-io。commons-io 不属于文件上传组件的开发 jar 文件，但Commons-fileupload 组件从 1.1 版本开始，它工作时需要 commons-io 包的支持。

８.２.springmvc 传统方式的文件上传

８.2.1.说明

传统方式的文件上传，指的是我们上传的文件和访问的应用存在于同一台服务器上。并且上传完成之后，浏览器可能跳转。

８.2.2.实现步骤

８.2.2.1.第一步：拷贝文件上传的 jar 包到工程的 lib 目录

<dependency>
    <groupId>org.apache.commonsgroupId>
    <artifactId>commons-ioartifactId>
    <version>1.3.2version>
dependency>

<dependency>
    <groupId>commons-fileuploadgroupId>
    <artifactId>commons-fileuploadartifactId>
    <version>1.3.1version>
dependency>

８.2.2.2.第二步：编写 jsp 页面

<form action="/fileUpload" method="post" enctype="multipart/form-data">
	名称：<input type="text" name="picname"/><br/>
	图片：<input type="file" name="uploadFile"/><br/>
	<input type="submit" value="上传"/>
form>

８.2.2.3.第三步：编写控制器

/**
* 文件上传的的控制器
* @Version 1.0
*/
@Controller("fileUploadController")
public class FileUploadController {
   
    /**
     * 文件上传
     */
    @RequestMapping("/fileUpload")
    public String testResponseJson(String picname, MultipartFile
            uploadFile, HttpServletRequest request) throws Exception {
        //定义文件名
        String fileName = "";
        //1.获取原始文件名
        String uploadFileName = uploadFile.getOriginalFilename();
        //2.截取文件扩展名
        String extendName =
                uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1,
                        uploadFileName.length());
        //3.把文件加上随机数，防止文件重复
        String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
        //4.判断是否输入了文件名
        if (!StringUtils.isEmpty(picname)) {
            fileName = uuid + "_" + picname + "." + extendName;
        } else {
            fileName = uuid + "_" + uploadFileName;
        }
        System.out.println(fileName);
        //2.获取文件路径
        ServletContext context = request.getServletContext();
        String basePath = context.getRealPath("/uploads");
        //3.解决同一文件夹中文件过多问题
        String datePath = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        //4.判断路径是否存在
        File file = new File(basePath + "/" + datePath);
        if (!file.exists()) {
            file.mkdirs();
        }
        //5.使用 MulitpartFile 接口中方法，把上传的文件写到指定位置
        uploadFile.transferTo(new File(file, fileName));
        return "success";
    }

}

８.2.2.4.第四步：配置文件解析器

 

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
	 
	<property name="maxUploadSize">
		<value>5242880value>
	property>
bean>

注意：
文件上传的解析器 id 是固定的，不能起别的名称，否则无法实现请求参数的绑定。（不光是文件，其他字段也将无法绑定）

８.3.SpringMvc拦截静态资源问题

方式1：

<mvc:default-servlet-handler/>

<mvc:annotation-driven>mvc:annotation-driven>

方式2：

  
  <mvc:resources mapping="/girls/**" location="/girls/">mvc:resources>
  <mvc:resources mapping="/images/**" location="/images/">mvc:resources>
  <mvc:resources mapping="/js/**" location="/js/">mvc:resources>
  <mvc:resources mapping="/css/**" location="/css/">mvc:resources>
......

<mvc:annotation-driven>mvc:annotation-driven>

８.４异步文件上传

@Controller
@RequestMapping("/file")
public class FileUploadController {

    /**
     * 异步文件上传
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/upload", method = RequestMethod.POST)
    public DataResults upload(@RequestParam("f") MultipartFile file, HttpServletRequest request) {
        DataResults results = null;
        try {
            //1.获取原始文件名
            String uploadFileName = file.getOriginalFilename();
            System.out.println("要上传的原始文件名字是:" + uploadFileName); //2222.jpg
            //2.截取文件扩展名
            String extendName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1, uploadFileName.length());
            //3.把文件加上随机数，防止文件重复
            String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
            //4.生成的新的服务器文件名
            String newfileName = uuid + "." + extendName;
            System.out.println("生成的新的服务器文件名是:" + newfileName); //防止服务器文件名重名
            //5.获取真实的服务器文件上传地址
            String filePath = request.getServletContext().getRealPath("/images/upload") + "/" + newfileName;
            System.out.println("服务器运行目录，最终上传的路径:" + filePath);
            //6.执行上传
            file.transferTo(new File(filePath));
            System.out.println("文件上传结束！");
            results = new DataResults(200, "文件上传成功",newfileName);
        } catch (IOException e) {
            e.printStackTrace();
            results = new DataResults(500, "文件上传异常");
        }
        return results;
    }
}

九、全局异常处理

我们知道，系统中异常包括：编译时异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。在开发中，不管是dao层、service层还是controller层，都有可能抛出异常，在springmvc中，能将所有类型的异常处理从各处理过程解耦出来，既保证了相关处理过程的功能较单一，也实现了异常信息的统一处理和维护。

９.1.异常处理思路

在springmvc中，异常处理的思路

如上图所示，系统的dao、service、controller出现异常都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理。springmvc提供全局异常处理器（一个系统只有一个异常处理器）进行统一异常处理。明白了springmvc中的异常处理机制，下面就开始分析springmvc中的异常处理。

９.2.异常处理结构体系

Spring MVC通过HandlerExceptionResolver处理程序的异常,包括处理映射,数据绑定及处理器执行时发生异常。HandlerExceptionResolver仅有一个接口方法:

/**
 * Interface to be implemented by objects that can resolve exceptions thrown during
 * handler mapping or execution, in the typical case to error views. Implementors are
 * typically registered as beans in the application context.
 *
 * 
Error views are analogous to JSP error pages but can be used with any kind of
 * exception including any checked exception, with potentially fine-grained mappings for
 * specific handlers.
 *
 * @author Juergen Hoeller
 * @since 22.11.2003
 */
public interface HandlerExceptionResolver {

	/**
	 * Try to resolve the given exception that got thrown during handler execution,
	 * returning a {@link ModelAndView} that represents a specific error page if appropriate.
	 * 
The returned {@code ModelAndView} may be {@linkplain ModelAndView#isEmpty() empty}
	 * to indicate that the exception has been resolved successfully but that no view
	 * should be rendered, for instance by setting a status code.
	 * @param request current HTTP request
	 * @param response current HTTP response
	 * @param handler the executed handler, or {@code null} if none chosen at the
	 * time of the exception (for example, if multipart resolution failed)
	 * @param ex the exception that got thrown during handler execution
	 * @return a corresponding {@code ModelAndView} to forward to, or {@code null}
	 * for default processing
	 */
	ModelAndView resolveException(
			HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex);

}

当发生异常时,Spring MVC将调用 resolveException()方法,并转到ModelAndView对应视图中,作为一个异常报告页面,反馈给用户!
HandlerExceptionResolver拥有4个常见实现类:

９.3.异常处理方案

９.3.1.DefaultHandlerExceptionResolver

Spring MVC默认装配了DefaultHandlerExceptionResolver,它会将Spring MVC框架的异常转换为相应的相应状态码!
异常和相应状态码对应表

在web.xml响应状态码配置一个对应页面

<error-page>
	<error>404error>
	<location>/static/404.htmllocation>
error-page>

注意: 静态资源注意会被DispatcherServlet拦截!

９.3.2.SimpleMappingExceptionResolver

如果希望对所有的异常进行统一的处理，比如当指定的异常发生时，把它映射到要显示的错误的网页中，此时用SimpleMappingExceptionResolver进行解析。DispatcherServlet中没有实现SimpleMappingExceptionResolver的Bean，所有需要在springmvc的配置文件中进行配置。

• 示例如下：

@Controller
public class DemoServlet2 {

	@RequestMapping("/testSimpleMappingExceptionResolver")
	public String testSimpleMappingExceptionResolver() {
		String[] values = new String[10];
		// 下标越界了
		System.out.println(values[11]);
		return "success";
	}
}

发送index.jsp中的超链接请求，控制器捕获请求后处理控制器逻辑，由于在逻辑中，数组越界，会抛出ArrayIndexOutOfBoundsException异常。

• 处理异常

<mvc:annotation-driven />  

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
		
		<property name="exceptionAttribute" value="ex">property>
		<property name="exceptionMappings">
			<props>
				
				<prop key="java.lang.ArrayIndexOutOfBoundsException">errorprop>
			props>
		property>
bean>

另外在/WEB-INF/jsp下新建一个error.jsp视图。因为上面配置的InternalResourceViewResolver视图解析器默认把error字符串解析为error.jsp视图。error.jsp内容为：

<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%>
DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title heretitle>
head>
<body>
    <h1>Error Pageh1>
    ${requestScope.ex}
body>
html>

下面重新发送index.jsp中的超链接请求后，控制器截获请求并处理请求时，数组越界抛出一个ArrayIndexOutOfBoundsException一个异常，此时由SimpleMappingExceptionResolver异常解析！

９.3.3.AnnotationMethodHandlerExceptionResolver

Spring MVC 默认注册了 AnnotationMethodHandlerExceptionResolver,它允许通过@ExceptionHandler注解指定处理特定异常的方法!

@Controller
public class DemoController1 {

	@ExceptionHandler(value = { RuntimeException.class })
	public ModelAndView handleArithmeticException2(Exception ex) {
		System.out.println("[出异常了]:" + ex);
		ModelAndView mv = new ModelAndView("error");
		mv.addObject("exception", ex);
		return mv;
	}

	@ExceptionHandler(value = { ArithmeticException.class })
	public ModelAndView handleArithmeticException(Exception ex) {
		System.out.println("出异常了，算术异常:" + ex);
		ModelAndView mv = new ModelAndView("error");
		mv.addObject("exception", ex);
		return mv;
	}

	@RequestMapping("/testExceptionHandler1")
	public String test1() {
		String s=null;
		System.out.println(s.length());
		return "success";
	}
	
	@RequestMapping("/testExceptionHandler2")
	public String test2() {
		int i=100/0;
		return "success";
	}
}

目标方法内抛出了一个ArithmeticException异常，将由继承关系最近的异常处理捕捉到，即由handleArithmeticException捕捉到。
若将handleArithmeticException方法注释掉，则发生ArithmeticException异常将由handleArithmeticException2进行处理。

缺点:

• 使用该注解有一个不好的地方就是：进行异常处理的方法必须与出错的方法在同一个Controller里面。
• 不能全局控制异常。每个类都要写一遍。

９.3.4.全局异常处理

上文说到 @ ExceptionHandler 需要进行异常处理的方法必须与出错的方法在同一个Controller里面。那么当代码加入了 @ControllerAdvice，则不需要必须在同一个 controller 中了。这也是 Spring 3.2 带来的新特性。从名字上可以看出大体意思是控制器增强。 也就是说，@controlleradvice + @ ExceptionHandler 也可以实现全局的异常捕捉。
请确保此WebExceptionHandle 类能被扫描到并装载进 Spring 容器中。

@Controller
@ControllerAdvice
public class WebExceptionHandle {

	@ExceptionHandler(Exception.class)
	public ModelAndView handleException(Exception ex) {
		System.out.println("全局异常:ex = " + ex);
		ModelAndView modelAndView = new ModelAndView();
		
		modelAndView.setViewName("error");
		modelAndView.addObject("exception", ex);
		return modelAndView;
	}
}

此处可以捕捉全局异常,但是不要忘了在spring配置的时候扫描该类!

若在其他的由@Controller标记的Handler类中的Handle方法抛出异常，且没有在Handler类中定义@ExceptionHandler方法，则会去由@ControllerAdvice标记的类中去找，若也找不到，则在页面抛出异常。

十、springＭｖｃ拦截器

## １０.１.拦截器的作用

Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。用户可以自己定义一些拦截器来实现特定的功能。谈到拦截器，还要向大家提一个词——拦截器链（Interceptor Chain）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。

说到这里，可能大家脑海中有了一个疑问，这不是我们之前学的过滤器吗？是的它和过滤器是有几分相似，但是也有区别，接下来我们就来说说他们的区别：
过滤器是 servlet 规范中的一部分，任何 java web 工程都可以使用。
拦截器是 SpringMVC 框架自己的，只有使用了 SpringMVC 框架的工程才能用。
过滤器在 url-pattern 中配置了/*之后，可以对所有要访问的资源拦截。
拦截器它是只会拦截访问的控制器方法，如果访问的是 jsp，html,css,image 或者 js 是不会进行拦
截的(需要配置)。它也是 AOP 思想的具体应用。

我们要想自定义拦截器， 要求必须实现：HandlerInterceptor接口。

１０.2.自定义拦截器的步骤

１０.2.1.第一步：编写一个普通类实现 HandlerInterceptor 接口

/**
 * @author bruceliu
 * @create 2019-07-20 23:26
 * @description
 */
public class HandlerInterceptorDemo1 implements HandlerInterceptor {
   
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse
            response, Object handler)
            throws Exception {
        System.out.println("preHandle 拦截器拦截了");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler,
                           ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle 方法执行了");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse
            response, Object handler, Exception ex)
            throws Exception {
        System.out.println("afterCompletion 方法执行了");
    }
}

１０.2.2.第二步：配置拦截器

 
<mvc:interceptors> 
	<mvc:interceptor> 
	<mvc:mapping path="/**"/>
		<bean id="handlerInterceptorDemo1"
		class="com.bruceliu.web.interceptor.HandlerInterceptorDemo1">bean>
	mvc:interceptor>
mvc:interceptors>

１０.2.3 测试运行结果

１０.3.拦截器的细节

１０.3.1.拦截器的放行

放行的含义是指，如果有下一个拦截器就执行下一个，如果该拦截器处于拦截器链的最后一个，则执行控制器中的方法。

１０.3.2.拦截器中方法的说明

public interface HandlerInterceptor {
	/**
	* 如何调用：
	* 按拦截器定义顺序调用
	* 何时调用：
	* 只要配置了都会调用
	* 有什么用：
	* 如果程序员决定该拦截器对请求进行拦截处理后还要调用其他的拦截器，或者是业务处理器去
	* 进行处理，则返回 true。 * 如果程序员决定不需要再调用其他的组件去处理请求，则返回 false。 */
	default boolean preHandle(HttpServletRequest request, HttpServletResponse 
	response, Object handler)
	throws Exception {
		return true;
	}
	
	/**
	* 如何调用：
	* 按拦截器定义逆序调用
	* 何时调用：
	* 在拦截器链内所有拦截器返成功调用
	* 有什么用：
	* 在业务处理器处理完请求后，但是 DispatcherServlet 向客户端返回响应前被调用，
	* 在该方法中对用户请求 request 进行处理。
	*/
	default void postHandle(HttpServletRequest request, HttpServletResponse 
	response, Object handler,
	@Nullable ModelAndView modelAndView) throws Exception {
	}
	
	
	/**
	* 如何调用：
	* 按拦截器定义逆序调用
	* 何时调用：
	* 只有 preHandle 返回 true 才调用
	* 有什么用： * 在 DispatcherServlet 完全处理完请求后被调用，
	* 可以在该方法中进行一些资源清理的操作。
	*/
	default void afterCompletion(HttpServletRequest request, HttpServletResponse 
	response, Object handler,
	@Nullable Exception ex) throws Exception {
	} 
}

１０.3.3.拦截器的作用路径

作用路径可以通过在配置文件中配置。

<mvc:interceptors> 
	<mvc:interceptor> 
		<mvc:mapping path="/**" />
		 
		<mvc:exclude-mapping path=""/>
		 
		<bean id="handlerInterceptorDemo1"
		class="com.bruceliu.web.interceptor.HandlerInterceptorDemo1">bean>
	mvc:interceptor>
mvc:interceptors>

１０.3.4 多个拦截器的执行顺序

多个拦截器是按照配置的顺序决定的。

１０.4.拦截器的简单案例（验证用户是否登录）

１０.4.1.实现思路

1、有一个登录页面，需要写一个 controller 访问页面 2、登录页面有一提交表单的动作。需要在 controller 中处理。
 2.1、判断用户名密码是否正确
 2.2、如果正确 向 session 中写入用户信息
2.3、返回登录成功。
3、拦截用户请求，判断用户是否登录
 3.1、如果用户已经登录。放行
 3.2、如果用户未登录，跳转到登录页面

１０.4.2.控制器代码

/**
 * @author bruceliu
 * @create 2019-07-20 23:39
 * @description
 */
public class Demo1 {

    //登陆页面
    @RequestMapping("/login")
    public String login(Model model) throws Exception {
        return "login";
    }

    //登陆提交
    //userid：用户账号，pwd：密码
    @RequestMapping("/loginsubmit")
    public String loginsubmit(HttpSession session, String userid, String pwd) throws
            Exception {
        //向 session 记录用户身份信息
        session.setAttribute("activeUser", userid);
        return "redirect:/main.jsp";
    }

    //退出
    @RequestMapping("/logout")
    public String logout(HttpSession session) throws Exception {
        //session 过期
        session.invalidate();
        return "redirect:index.jsp";
    }
}

１０.4.3.拦截器代码

/**
 * @author bruceliu
 * @create 2019-07-20 23:41
 * @description
 */
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response, Object handler) throws Exception {
        //如果是登录页面则放行
        if (request.getRequestURI().indexOf("login.action") >= 0) {
            return true;
        }
        HttpSession session = request.getSession();
        //如果用户已登录也放行
        if (session.getAttribute("user") != null) {
            return true;
        }
        //用户没有登录挑战到登录页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

10.5 RESTFULL风格

10.5.1.概念

一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

10.5.2.URL定义

资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
分别对应 添加、 删除、修改、查询。

POST 添加

GET 查询

DELETE 删除

PUT 修改

10.5.3.传统方式操作资源

http://127.0.0.1/item/queryUser?id=1 查询,GET
http://127.0.0.1/item/saveUser 新增,POST
http://127.0.0.1/item/updateUser 更新,POST
http://127.0.0.1/item/deleteUser?id=1 删除,GET或POST

http://www.verycd.com/entries/findById?id=454849/ 传统方式

http://www.verycd.com/entries/454849/ RESTFUL风格

10.5.4.RESTFUL风格

使用RESTful操作资源

【GET】 /users # 查询用户信息列表

【POST】 /users # 新建用户信息

【GET】 /users/1001 # 查看某个用户信息

【PUT】 /users/1001 # 更新用户信息(全部字段)

【DELETE】 /users/1001 # 删除用户信息

10.6 注意

json字符串封装对象：

导入MybatisPlus依赖

spring整合mybatisPlus

Put请求转换过滤器：

springMvc放开静态资源：

发送put请求方式：

SpringMvc 拦截器执行流程：