SpringMVC笔记整理

第一章 SpringMVC概述

1.1 SpringMVC简介

		SpringMVC 也叫 Spring web mvc。是 Spring 框架的一部分，是在 Spring3.0 后发布的。

1.2 SpringMVC优点

1. 基于 MVC 架构
   基于 MVC 架构，功能分工明确。解耦合，
2. 容易理解，上手快；使用简单。
   就可以开发一个注解的 SpringMVC 项目，SpringMVC 也是轻量级的，jar 很小。不依赖的
   特定的接口和类。
3. 作 为 Spring 框 架 一 部 分 ， 能 够 使 用 Spring 的 IoC 和 Aop 。 。 方 便 整 合
   Strtus,MyBatis,Hiberate,JPA 等 等 其他 框架。 。
4. SpringMVC 强化注解的使用，在控制器，Service ，Dao 都可以使用注解 。方便灵活。
   使用@Controller 创建处理器对象,@Service 创建业务对象，@Autowired 或者@Resource
   在控制器类中注入 Service, Service 类中注入 Dao。

1.3 第一个注解的 SpringMVC 程序

完成功能：用户提交一个请求，服务端处理器在接收到这个请求后，给出一条欢迎信息，
在响应页面中显示该信息。

1. 新建 maven web 项目
   
2. pom.xml
   在创建好 web 项目后，加入 Servlet 依赖，SpringMVC 依赖

<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>javax.servlet-api</artifactId>
	<version>3.1.0</version>
	<scope>provided</scope>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-webmvc</artifactId>
	<version>5.2.5.RELEASE</version>
</dependency>
插件：
<build>
	<plugins>
	<!-- 编码和编译和JDK版本 -->
		<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 ） 全限定性类名
//该中央调度器为一个 Servlet，名称为 DispatcherServlet。中央调度器的全限定性类名在
//导入的 Jar 文件 spring-webmvc-5.2.5.RELEASE.jar 的第一个包 org.springframework.web.servlet
//下可找到。
 <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     //(4 )配置文件位置
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    //（3 ） <load-on-startup/>
			//在<servlet/>中添加<load-on-startup/>的作用是，标记是否在Web服务器（这里是Tomcat）
			//启动时会创建这个 Servlet 实例，即是否在 Web 服务器启动时调用执行该 Servlet 的 init()方
			//法，而不是在真正访问时才创建。
			//它的值必须是一个整数。
			//➢ 当值大于等于 0 时，表示容器在启动时就加载并初始化这个 servlet，数值越小，该 Servlet
			//的优先级就越高，其被创建的也就越早；
			//➢ 当值小于 0 或者没有指定时，则表示该 Servlet 在真正被使用时才会去创建。
			//➢ 当值相同时，容器会自己选择创建顺序。
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        //（4 ） <url-pattern/>
				//对于<url-pattern/>，可以写为 / ，建议写为*.do 的形式。
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
 

4. 创建 SpringMVC 配置文件
   在工程的类路径即 src 目录下创建 SpringMVC 的配置文件 springmvc.xml。该文件名可以
   任意命名。
5. 创建处理器
   在类上与方法上添加相应注解即可。
   @Controller：表示当前类为处理器
   @RequestMapping：表示当前方法为处理器方法。该方法要对 value 属性所指定的 URI
   进行处理与响应。被注解的方法的方法名可以随意。

@Controller
public class Mycontroller {
    /**
     *
     * @RequestMapping:请求映射，把指定的请求交给方法处理
     * value是个数组，若有多个请求路径均可匹配该处理器方法的执行，则
       @RequestMapping 的 value 属性中可以写上一个数组。
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){
        System.out.println("处理some.do请求");
        //调用service处理请求，把处理器结果放入到返回值MOdelAndView
        ModelAndView mv = new ModelAndView();
        mv.addObject("str1","使用注解的spring应用");
        mv.addObject("str2","dosome");
        mv.setViewName("/show.jsp");
        return mv;
    }

6. 声明组件扫描器

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

1.4 修改视图解析器的注册

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

应用：

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

第二章 SpringMVC 注解式开发

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 之前加上处理器类前定义的模块名称

2.1.2 对请求提交方式的定义

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

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

以上处理器方法只能处理 POST 方式提交的请求。客户端浏览器常用的请求方式，及其
提交方式有以下几种：

2.2 处理器方法的参数

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

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

2.2.1 逐个参数接收

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

2.2.2 请求参数中文乱码问题

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

    <!--注册字符集过滤器，解决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>
        <!--强制request使用字符集encoding-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <!--强制response使用字符集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>

2.2.3 校正请求参数名@RequestParam

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

required 属性：

2.2.4 对象参数接收

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

Step2：修改处理器类 MyController

2.3 处理器方法的返回值

使用@Controller 注解的处理器的处理器方法，其返回值常用的有四种类型：
➢ 第一种：ModelAndView
➢ 第二种：String
➢ 第三种：无返回值 void
➢ 第四种：返回自定义类型对象（Object）

2.3.1 返回 ModelAndView

若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回 ModelAndView 比较好。当然，若要返回 ModelAndView，则处理器方法中需要定义 ModelAndView 对象。
在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转（如对页面的 Ajax 异步响应），此时若返回 ModelAndView，则将总是有一部分多余：要么 Model 多余，要么 View 多余。即此时返回 ModelAndView 将不合适。

2.3.2 返回 String

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

返回内部资源逻辑视图名：
若要跳转的资源为内部资源，则视图解析器可以使用 InternalResourceViewResolver 内部资源视图解析器。此时处理器方法返回的字符串就是要跳转页面的文件名去掉文件扩展名后的部分。这个字符串与视图解析器中的 prefix、suffix 相结合，即可形成要访问的 URI。

2.3.3 返回 void（了解）

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

2.3.4 返回对象 Object

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

实现步骤：

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

2. 声明注解驱动
   
3. 加入注解@RequestBody

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

SpringMVC 使用消息转换器实现请求数据和对象，处理器方法返回对象和响应输出之间的自动转换
当 Spring 容器进行初始化过程中，在<mvc:annotation-driven/>处创建注解驱动时，默认创建了七个 HttpMessageConverter 对象。也就是说，我们注册<mvc:annotation-driven/>，就是为了让容器为我们创建 HttpMessageConverter 对象。HttpMessageConverter 接口 : HttpMessageConverter<T>是 Spring3.0 新添加的一个接口，为 负责将请求信息转换为一个对象（类型为 T ），将对象（类型为 T ）输出为响应信息

HttpMessageConverter<T>接口定义的方法：
boolean canRead(Class<?> clazz,MediaType mediaType): 指定转换器可以读取的对象类型，即转换器是否可将请求信息转换为 clazz 类型的对象，同时指定支持 MIME 类型(text/html,applaiction/json 等)

boolean canWrite(Class<?> clazz,MediaType mediaType):指定转换器是否可将 clazz 类型的对象写到响应流中，响应流支持的媒体类型在 MediaType 中定义。

LIst getSupportMediaTypes()：该转换器支持的媒体类型。

T read(Class<? extends T> clazz,HttpInputMessage inputMessage)：将请求信息流转换为 T 类型的对象。
void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage):将 T 类型的对象写到响应流中，同时指定相应的媒体类型为 contentType加入注解驱动<mvc:annotation-driven/>后适配器类的 messageConverters 属性值

HttpMessageConverter 接口实现类作用：

ByteArrayHttpMessageConverter 负责读取二进制格式的数据和写出二进制格式的数据

StringHttpMessageConverter 负责读取字符串格式的数据和写出字符串格式的数据

ResourceHttpMessageConverter 负责读取资源文件和写出资源文件数据

SourceHttpMessageConverter 能 够 读 / 写 来 自 HTTP 的 请 求 与 响 应 的javax.xml.transform.Source ,支持DOMSource,SAXSource, 和 StreamSource 的 XML 格式AllEncompassingFormHttpMessageConverter负责处理表单(form)数据

Jaxb2RootElementHttpMessageConverter 使用 JAXB负责读取和写入xml 标签格式的数据

MappingJackson2HttpMessageConverter 负责读取和写入 json 格式的数据。利用Jackson 的 ObjectMapper 读写 json 数据，操作Object 类型数据，可读取 application/json，响应媒体类型为 application/json

2.4 解读<url-pattern/>

2.4.1 配置详解

1. *.do
   在没有特殊要求的情况下，SpringMVC 的中央调度器 DispatcherServlet 的
   常使用后辍匹配方式，如写为*.do 或者 *.action, *.mvc 等。
2. /
   可以写为/，因为 DispatcherServlet 会将向静态资源的获取请求，例如.css、.js、.jpg、.png
   等资源的获取请求，当作是一个普通的 Controller 请求。中央调度器会调用处理器映射器为
   其查找相应的处理器。当然也是找不到的，所以在这种情况下，所有的静态资源获取请求也
   均会报 404 错误。

2.4.1.1两种方案解决

1. 使用<mvc:default-servlet-handler/>
   声 明 了 <mvc:default-servlet-handler /> 后 ， springmvc 框 架 会 在 容 器 中 创 建
   DefaultServletHttpRequestHandler 处理器对象。它会像一个检查员，对进入 DispatcherServlet
   的 URL 进行筛查，如果发现是静态资源的请求，就将该请求转由 Web 应用服务器默认的
   Servlet 处理。一般的服务器都有默认的 Servlet。
2. 使用<mvc:resources/> （掌握）
   在 Spring3.0 版本后，Spring 定义了专门用于处理静态资源访问请求的处理器
   ResourceHttpRequestHandler。并且添加了mvc:resources/标签，专门用于解决静态资源无法访问问题。需要在 springmvc 配置文件中添加如下形式的配置 ：
   
   location 表示静态资源所在目录。当然，目录不要使用/WEB-INF/及其子目录。
   mapping 表 示 对 该 资 源 的 请 求 （ 以 以 /images/ 开 始 的 请 求 ， 如 /image/beauty.jpg ,
   /images/car.png 等）。注意，后面是两个星号**

第三章 SSM整合开发

3.1 搭建开发环境

3.1.1 加入maven依赖

 <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>
    <!--spring事务依赖-->
    <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>

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

    <!--spring和mybatis整合依赖-->
    <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>
    <!--mysql驱动-->
    <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.2 配置web.xml

3.2.1 注册 ContextLoaderListener 监听器

注册 ServletContext 监听器的实现类 ContextLoaderListener，用于创建 Spring 容器及将创
建好的 Spring 容器对象放入到 ServletContext 的作用域中

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

3.2.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>
          <!--强制request使用字符集encoding-->
          <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
          </init-param>
          <!--强制response使用字符集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>

3.2.3 配置中央调度器

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

<!--注册中央调度器-->
          <servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
              <param-name>contextConfigLocation</param-name>
              <param-value>classpath:conf/dispatcherservlet.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
          </servlet>
        
          <servlet-mapping>
            <servlet-name>springmvc</servlet-name>
            <url-pattern>*.do</url-pattern>
          </servlet-mapping>

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

jsp 文件：

3.4 编写配置文件

3.4.1 jdbc.properties

Jdbc 属性配置文件 jdbc.properties

3.4.2 Spring配置文件

Spring 配置文件 applicationContext.xml

 <!--组件扫描器-->
        <context:component-scan base-package="com.xiaojie.service"/>
        <!--引入属性配置文件-->
        <context:property-placeholder location="classpath:conf/jdbc.properties"/>
        <!--配置阿里的Druid数据源-->
        <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-->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <property name="configLocation" value="classpath:conf/mybatis.xml"/>
        </bean>
        <!--动态代理对象-->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
            <property name="basePackage" value="com.xiaojie.dao"/>
        </bean>

        <bean id="studentService" class="com.xiaojie.service.Impl.StudentServiceImpl">
            <property name="studentDao" ref="studentDao"/>
        </bean>

3.4.3 SpringMVC配置文件

Springmvc 配置文件：springmvc.xml

		<!--组件扫描器-->
        <context:component-scan base-package="com.xiaojie.controller"/>
        <!--指定视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                <!--前缀和后缀-->
                <property name="prefix" value="/WEB-INF/view/"/>
                <property name="suffix" value=".jsp"/>
        </bean>
        
        <!--声明注解驱动-->
        <mvc:annotation-driven/>

3.4.4 mybatis配置文件

    <!--settings:控制mybatis全局行为-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <!--起别名标签，在com.xiaojie.domian包下的类文件，所有的别名都为类名-->
    <typeAliases>
        <package name="com.xiaojie.domian"/>
    </typeAliases>

    <mappers>
        <package name="com.xiaojie.dao"/>
    </mappers>

3.5 定义实体类、Dao接口和sql映射文件

实体类：

Dao接口：

映射文件：

3.6 Service接口和实现类

Service 接口

Service 实现类

3.7 处理器定义

3.8 定义视图文件----index.jsp

指定路径：

<%
String basePath = request.getScheme() + "://" +
request.getServerName() + ":" + request.getServerPort() +
request.getContextPath() + "/";
%>
指定 base 标签
<head>
<base href="<%=basePath%>">
<title>title</title>
</head>

第四章 SpringMVC核心技术

4.1 重定向和请求转发

当处理器对请求处理完毕后，向其它资源进行跳转时，有两种跳转方式：请求转发与重定向。而根据所要跳转的资源类型，又可分为两类：跳转到页面与跳转到其它处理器。注意，对于请求转发的页面，可以是WEB-INF中页面；而重定向的页面，是不能为WEB-INF中页的。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资源的。

forward:表示转发，实现 request.getRequestDispatcher(“xx.jsp”).forward()
redirect:表示重定向，实现 response.sendRedirect(“xxx.jsp”)

4.1.1 请求转发

处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 forward:，且此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。视图页面必须写出相对于项目根的路径。forward 操作不需要视图解析器。处理器方法返回 String,在视图路径前面加入 forward: 视图完整路径。

4.1.2 请求重定向

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

4.2 异常处理

springmvc采用的是统一，全局异常的处理，把Controller中所有的异常处理都集中在一个地方，采用的是aop思想，把业务逻辑和异常处理分离，实现解耦合。

4.2.1 @ExceptionHandler 注解

使用注解@ExceptionHandler 可以将一个方法指定为异常处理方法。该注解只有一个可选属性 value，为一个 Class<?>数组，用于指定该注解的方法所要处理的异常类，即所要匹配的异常。而被注解的方法，其返回值可以是 ModelAndView、String，或 void，方法名随意，方法参数可以是 Exception 及其子类对象、HttpServletRequest、HttpServletResponse 等。系统会自动为这些方法参数赋值。对于异常处理注解的用法，也可以直接将异常处理方法注解于 Controller 之中。

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

2. 修改 Controller 抛出异常
   

3. 定义异常响应页面
   定义三个异常响应页面。
   
   
   
   不过，一般不这样使用。而是将异常处理方法专门定义在一个类中，作为全局的异常处
   理类。
   需要使用注解@ControllerAdvice，字面理解就是“控制器增强”，是给控制器对象增强
   功能的。使用@ControllerAdvice 修饰的类中可以使用@ExceptionHandler。
   当使用@RequestMapping 注解修饰的方法抛出异常时，会执行@ControllerAdvice 修饰的
   类中的异常处理方法。
   @ControllerAdvice 是使用@Component 注解修饰的，可以context:component-scan
   扫描到@ControllerAdvice 所在的类路径(包名)，创建对象。

4. 定义全局异常处理类
   

5. 定义 Spring 配置文件
   

4.3 拦截器

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

4.3.1 一个拦截器的执行

自定义拦截器，需要实现 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 方法中加入数据

拦截器方法：

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

1. 注册拦截器
   
   <mvc:mapping/>用于指定当前所注册的拦截器可以拦截的请求路径，而/**表示拦截所
   有请求。
2. 创建普通类继承HandlerInterceptor类
   

4.3.2 多个拦截器的执行

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

附上思维导图