SSM框架中项目逻辑层：SpringMVC

雨落水涨next

已于 2022-02-14 17:48:26 修改

748

分类专栏：后端天梯成长之路 Java框架大礼包文章标签： java mvc 开发语言

于 2022-02-13 20:13:25 首次发布

本文链接：https://blog.csdn.net/qq_48322523/article/details/122913310

版权

后端天梯成长之路同时被 2 个专栏收录

18 篇文章 1 订阅

订阅专栏

Java框架大礼包

7 篇文章 0 订阅

订阅专栏

SpringMVC

前言：SSM框架快告一段落了，感觉SSM被誉为Java这种极度符合软件工程开发思想和OOP的入门框架果然有他的一套。“高内聚，低耦合”这六个字表现的淋漓尽致了真的是。

希望Java越来越好，希望大家越学越好。

SSM-Spring篇：SSM框架中项目核心层：Spring

SSM-MaBtis篇：SSM框架中项目持久层：MyBatis

Maven篇：Java项目管理神器：Maven

SpringMVC概述

Spring web MVC 框架提供了模型-视图-控制的体系结构和可以用来开发灵活、松散耦合的 web 应用程序的组件。MVC模式导致了应用程序的不同方面(输入逻辑、业务逻辑和 UI 逻辑)的分离，同时提供了在这些元素之间的松散耦合。

模型封装了应用程序数据，并且通常它们由 POJO组成。
视图主要用于呈现模型数据，并且通常它生成客户端的浏览器可以解释的 HTML 输出。
控制器主要用于处理用户请求，并且构建合适的模型并将其传递到视图呈现。

以上说明来自w3cschool

SpringMVC底层也是Servlet。以Servlet为核心，接收请求,处理请求。显示处理结果给用户。

DispatcherServlet

DispatcherServlet是框架一个Servlet对象。负责接收请求，响应处理结果。

DispatcherServlet父类是HttpServlet。也叫做前端控制器。

DispatcherServlet作用：

在init()中创建容器对象，WebApplicationContext，即Controller对象
是一个servlet，能够接收请求

默认servlet配置文件位置

在Servlet的init()方法中，创建springmvc使用的容器对象WebApplicationContext。WebApplicationContext ctx = new ClassPathXmlApplicationContext(config);``config的默认路径: /WEB-INF/<servlet-name> -servlet.xml

自定义配置文件位置：放在resource路径下，名称直接写servlet-name内容即可

<!-- 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>
  <!-- 声明springmvc的核心对象 -->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 自定义配置文件位置 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
      <!-- 把一些请求交给指定的servlet处理
 		使用中央调用器(DispatcherServlet)
		1. 使用扩展名方式，格式*.xxx
		2. 使用斜杠 "/"
		-->
    <url-pattern>/mymvc</url-pattern>
  </servlet-mapping>
</web-app>

此处补充一个选项

<!--表示服务器tomcat创建对象的顺序，是 个整数值，大于等于0.
数值越小，创建对象的时间越早。-->
<servlet>
    <!--
	...
	-->
<load-on-startup>1</load-on-startup>
</servlet>

此处放一个模板，后续解释

package com.bjpowernode.controller;

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

/**
 * @Controller
 * 创建控制器对象，控制器：后端控制器，自定义类，处理请求
 * 位置：在类的上面，表示创建此类的对象，对象在springmvc的容器中
 */
@Controller
public class MyController {
    /**
     * 方法的形参，表示请求中的参数
     * 方法的返回值，表示本次请求的处理结果
     * @return
     */
    /**
     * @RequestMapping 请求映射
     * 属性：value 请求的url地址，唯一值，以"/"开头
     * 位置：1.在方法上面（必须） 2.在类定义的上面（可选）
     * 作用：把指定的请求交给指定的方法处理,等同于url-pattern
     */
    @RequestMapping(value = {"/some.do"， "/first.do"})
    public ModelAndView doSome() {
        // 使用这个方法处理请求，能处理请求的方法叫做控制器方法
        // 调用service对象处理请求
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "处理了请求"); // 此处的msg是jsp文件中的内容
        mv.addObject("fun", "执行了请求");

        // 指定视图，视图的完整路径
        mv.setViewName("/show.jsp");
        /**
         * 当框架调用完doSome()方法后，得到返回中ModelLAndview.
         * 框架会在后续的处理逻辑值， 处fmv对象里面的数据和视图。
         * 对数据执行request. setAttribute( "msg", ”处理I some . do请求"); 把数据放入到request作用域。
         * 对视图执i行forward转发操作。 等同于request. getReques tDispather( "/show. jsp"). forward(.. )
         */
        // 返回结果
        return mv;
    }
}

SpringMVC请求处理过程

简单处理过程：

用户发起请求
Tomcat接收了请求。
Tomcat根据<url-pattern/>标签把请求交给了其上的<servlet-name/>中央调度器
DispatcherServlet根据请求进行分配
查看该中央调度器的.xml文件，寻找控制器，查找注解RequestMapping
返回ModelAndView对象

tips：WEB-INF中的文件浏览器无法访问。

视图解析器

<!-- controller.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 声明组件扫描器 -->
    <context:component-scan base-package="com.bjpowernode.controller"/>
    <!-- 声明视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀：指定视图文件的路径 -->
        <property name="prefix" value="/xxx/"/>
        <!-- 后缀：视图文件的扩展名 -->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>>

在Controller中，使用文件名作为视图名使用，叫做视图逻辑名称

mv.setViewName("show");

使用Controller处理不同的请求

@RequestMapping(value = {"/some.do"， "/first.do"})

SpringMVC的MVC组件

M：后端控制器，返回数据model
V：视图，view
C：前端控制器（中央调度器），front controller

SpringMVC执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DekRibRD-1644832094943)(C:\Users\ASUS\Desktop\springmvc.jpg)]

SpringMVC注解式开发

@RequestMapping

请求映射

属性：value 请求的url地址，唯一值，以"/"开头
位置：
- 在方法上面（必须）
- 在类定义的上面（可选，对于公用的字符串使用）
作用：把指定的请求交给指定的方法处理,等同于url-pattern

在类定义的上面：比如/text/a.jsp和/test/b.jsp，都有前缀/text，因此此时在类上面定义RequestMapping("/text")，可以看做是一个模块的名称。

对请求提交方式的定义

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

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

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@RequestMapping(value = "/some.do", method = RequestMethod.POST)

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

序号	请求方式	提交方式
1	表单请求	默认GET，可以指定POST
2	AJAX请求	默认GET，可以指定POST
3	地址栏请求	GET请求
4	超链接请求	GET请求
5	src资源路径请求	GET请求

web开发中配置文件的说明

web.xml部署描述符文件，给服务器(tomcat)。

作用:服务器在启动的时候，读取web.xml，根据文件中的声明创建各种对象，根据文件中的声明知道请求和servlet等对象的关系。
框架的配置文件，springmvc的配置文件

作用:声明框架创建的项目中的各种对象，主要是创建Controller对象的。

服务器开启流程

tomcat服务器启动，读取web.xml，根据web.xml文件中的说明，创建对象。
springmvc框架，new ClassPathXmlApplicationContext()读取springmvc的配置文件。
用户发起请求……

处理器方法的参数

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

HttpServletRequest
HtpServletResponse
HttpSession
请求中所携带的请求参数

接收请求中的参数：逐个接收，对象接收

逐个接收

概念：请求中的参数名和控制器方法的形参名一样，按照名称对象接收参数

<form...>
	<input type="text" name="name"/>
    <input type="text" name="age"/>
</form...>

@RequestMapping(value = "/some.do", method = RequestMethod.POST)
public ModelAndView doSome(String name, Integer age) {
    //
}

参数接收

框架使用request对象，接收参数

String name = request.getParameter("name");
String age = request.getParameter("age");

在中央调度器的内部调用doProperParam方法时，按名称传递参数
```
doProperParam(name, Integer.valueOf(age));
```
框架可以实现请求参数String到Integer，Long，Float等类型的转化。

问题：

在类型转化时，容易产生异常，比如""转换成int（解决方法：int设置为Integer）

在POST方式中，接收中文的时候，产生乱码（解决方法：设置编码格式，一般写在过滤器中）

spring-web中的CharacterEncodingFilter类

<!-- web.xml -->
<filter>
	<filter-name>characterEnodingFilter</filter-name>
	<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
	<!-- 给过滤器属性赋值 -->
	<init-param>
  		<!-- 项目所使用的字符编码 -->
  		<param-name>encoding</param-name>
 	 	<param-value>utf8</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>characterEnodingFilter</filter-name>
	<!-- 强制所有请求先经过过滤器处理 -->
	<url-pattern>/*</url-pattern>
</filter-mapping>

当请求中参数名和接收参数名不一致时，可以使用@RequestParam注解

作用：解决名称不一样的问题

属性

value：请求中的参数名称
required :boolean类型的，默认是true
- true：请求中必须有此参数，没有报错。
- false：请求中不必有此参数，没有报错。

位置:在形参定义的前面

public ModelAndView doSome(@RequestParam(value="name")String rname, 
                           @RequestParam(value="age")Integer rage) {
    // 
}

对象接收

对象接收：在控制器方法的形参是java对象，使用java对象的属性接收请求中参数值。

要求: java对象的属性名和请求中参数名一样。

public ModelAndView doSome(Student student) {
    ModelAndView mv = new ModelAndView();
    mv.addObject("myname", student.getName());
    mv.setViewName("show");
    return mv;
}

处理器方法的返回值

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

ModelAndView数据和视图

请求的结果有数据和视图，使用ModelAndView最方便

数据：存放request作用域。
视图：执行forward转发操作。

String视图

框架的返回值是String，执行的是forward操作。

视图可以表示为完成视图路径，或者视图的逻辑名称。

逻辑名称（配合配置文件.xml，视图解析器）

/**原
public ModelAndView doSome(Student student) {
    ModelAndView mv = new ModelAndView();
    mv.addObject("myname", student.getName());
    mv.setViewName("show");
    return mv;
}
*/
public String doSome(Student student) {
    return "show";
}

完整视图路径，项目中不能配置视图解析器

public String doSome(Student student) {
    return "/WEB-INF/view/show.jsp";
}

void

没有数据和视图，可以使用HttpServletResponse对象输出数据响应AJAX请求处理

Maven中加入依赖

<!-- pom.xml -->
<dependency>
	<groudId>com.fasterxml.jackson.core</groudId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
	<groudId>com.fasterxml.jackson.core</groudId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

把对象转为AJAX

public String doSome(HttpServletResponse res, String name, Integer age) {
    ObjectMapper on = new ObjectMapper();
	String json = on.writeValueAsString(student);

	// 输出json，响应Ajax
    res.setContentType("application/json;charset=utf-8");
    PrintWriter pw = res.getWriter();
    pw.println(json);
    pw.flush();
    pw.close();
}

Object

返回对象Object是数据，而ajax请求需要的都是数据。在ajax请求中，一般返回的是json格式数据。

框架提供了处理java对象到json转换，还是数据输出工作。

HttpMessageConverter消息转换器：是一个接口

作用：
- 实现请求的数据转为Java对象；
- 把控制器方法返回的对象转为json、text、xml、二进制等不同格式的数据；

public interface HttpMessageConverter<T> {
    /* 检查var1，如果能转化成MediaType返回真 */
    boolean canRead(Class<?> var1, @Nullable MediaType var2);
	/* 检查var1，如果能转化成MediaType返回真 */
    boolean canWrite(Class<?> var1, @Nullable MediaType var2);

    List<MediaType> getSupportedMediaTypes();

    /* 接收请求中的对象，把数据转化成var1 */
    T read(Class<? extends T> var1, HttpInputMessage var2) throws IOException, HttpMessageNotReadableException;
	
    /* 把数据转化成var3，发送数据 */
    void write(T var1, @Nullable MediaType var2, HttpOutputMessage var3) throws IOException, HttpMessageNotWritableException;
}

MediaType：媒体类型，表示互联网中数据的格式。例如application/json, text/html, image/gif

框架根据控制器方法的返回类型，自动查找使用的实现类。

默认情况下: springmvc使用了HttpMessageConveter接口的4个实现类。包括了StringHttpMessageConverter。

需要在springmvc的配置文件，加入注解驱动的标签mvc:annotation-driven加入这个标签后，springmvc项目
启动后，会创建HttpMessageConveter接口的7个实现类对象，包括StringHttpMessageConverter 和
Mappinglackson2HttpMessageConverter。

<mvc:annotation-driven />

public Student doSome(HttpServletResponse res, String name, Integer age) {
    //
    return student;
}

@ResponseBody：注解的作用，就是把student转换后的json通过HttpServletResponse对象输出给浏览器。

相当于

res.setContentType("application/json;charset=utf-8");
PrintWriter pw = res.getWriter();
pw.println(json);
pw.flush();
pw.close();

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

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

List

与Object同理

在控制器中返回String，前端采用text格式，但是会产生乱码

解决方法：使用@RequestMapping中的produces属性，
@RequestMapping(produces="text/plain;charset=utf-8")

解读url-pattern

静态资源的处理

主要是由Tomcat进行处理的

提供静态资源的处理
处理所有未映射到其他请求的请求处理

    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

如果在中央调度器使用

  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

如果在项目中，中央调度器使用了\，动态资源能访问，静态资源不能访问，因此需要处理静态资源的访问工作

第一种处理静态资源的方法：使用<mvc:default-servlet-handler/>

在springmvc的配置文件中加入mvc:default-servlet-handler标签，springmvc框架会在项目运行时，加入DefaultServletHttpRequestHandler对象，让这个对象处理静态资源的访问。

原理：DefaultServletHttpRequestHandler把接收的静态资源的地址，转发给了tomcat的default

优点：解决方法简单

缺点：依赖于Tomcat服务器

<mvc:annotation-driven /> <!-- 一般与其下配置防止冲突 -->

<mvc:default-servlet-handler/>

第二种处理静态资源的方法：使用<mvc:resources/>

在springmvc配置文件中加入一个mvc:resources标签，框架会创建ResourceHttpRequestHandler控制器对象，使用这个对象处理静态资源的访问。（不依赖tomcat服务器，推荐使用）

<mvc:annotation-driven /> <!-- 一般与其下配置防止冲突 -->

<!--
	mapping:访问静态资源的url地址，可以使用通配符(**)
	location:静态在项目中的位置 不要使用/WEB-INF目录
-->
<mvc:resources mapping="/images/**" location=""/>
<mvc:resources mapping="/js/**" location=""/>
<mvc:resources mapping="/css/**" location=""/>

<!-- 一句话设置静态资源 -->
<mvc:resources mapping="/static/**" location=""/>

通常情况下，使用其他服务器存储静态资源，如nginx

SSM整合

SSM编程,即SpringMVC + Spring + MyBatis整合,是当前最为流行的JavaEE开发技术架构。其实SSM整合的实质，仅仅就是将MyBatis整合入Spring。因为SpringMVC原本就是Spring的- -部分, 不用专门整台。SSM整合的实现方式可分为两种:基于XML配置方式，基于注解方式。

整合思路

SSM整合就是把对象交给容器管理。两个容器共存。各自负责管理不同的对象。把对象声明到配置文件中，让
两个容器创建对象。

spring创建service, dao; springmvc创建controller

SSM整合，需要把对象交给容器管理，让容器去创建项目中要使用的java对象。现在有两个容器。

第一个是Spring容器: Spring容器是管理service 和dao等对象的。是业务层对象的容器。
第二个是SpringMVC容器:管理控制器对象的。是视图层对象。

容器的创建

Spring容器创建:在web.xml声明了监听器ContextLoaderListener ,这个功能框架写好了。功能是创建spring的
容器对象WebApplicationContext.在创建WebApplicationContext对象时，读取spring的配置文件，读取文件的
时候，遇到bean标签或者注解，就能创建service ，dao等对象，放到容器中。

SpringMVC容器:在web.xml声明了中央调度器DispatcherServlet。在这个servlet的init ()方法中，创建了容器对象WebApplicationContext,在创建WebApplicationContext对象，读取springmvc的配置文件，读取文件的时候，遇到@Controller注解，创建控制器controller对象，放到容器中。

两个容器的关系

SpringMVC容器和Spring容器的关系:设计上SpringMVC容器对象是Spring容器的子容器。
Spring是父容器。SpringMVC子容器。相当于java中的继承关系。

相对路径

在页面中，有路径的问题，访问路径有/开头的，还有没有/开头的。

如

<!-- 无协议开头 -->
<a href="test/dome.do"></a> <!-- 无斜杠开头 -->
<a href="/test/dome.do"></a> <!-- 无斜杠开头 -->
<!-- 有协议开头 -->
<a href="http://test/dome.do"></a>

地址的区别：现在看到的都是页面中的地址。

有协议开头的，都是绝对地址，地址唯一，可以直接访问
没有协议开头的，是相对地址，相对地址单独不能使用不能表示某个资源，不能访问。相对地址必须有参考地址一起，才能表示一个资源的完整地址。

参考地址：有/开头的，没有/开头的。

有/开头的时，其路径为服务器地址 + 当前相对地址

问题：缺少项目访问路径

解决方法：在路径前加上${pageContex.request.contextPath}

没有/开头的，以https://mybatis.org/mybatis-3/zh/logging.html为例

# 资源地址 logging.html
# 资源路径 https://mybatis.org/mybatis-3/zh/

点击没有/开头的地址后，其路径为资源路径 + 当前相对地址

解决方法，加上<base>标签

<base href="http://ip:port/project/">

SpringMVC核心技术

请求重定向和转发

转发：forward

不和视图解析器一块工作。

mv.setViewName("forward:/show.jsp")

重定向：redirect

不和视图解析器一块工作。

框架提供的重定向的功能

框架可以实现两次请求之间的数据传递，把第一个请求中的Model里面简单类型的数据，转为字符串，附加到目标页面的后面，做get 参数传递。可以在目标页面中获取参数值使用。

mv.setViewName("redirect:/show.jsp")

异常处理

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

框架使用的是集中的异常处理。把各个Controller中抛出的异常集中到一一个地方处理。处理异常的叫做异常处理
器。

框架中使用两个注解完成异常的集中处理。这样每个controller不用单独处理异常了。

@ExceptionHandler：放在方法的上面，表示此方法可以处理某个类型的异常。当异常发生时，执行这个方法
@ControllerAdvice：放在类的上面，表示这个类中有异常的处理方法。相当于aop中的@Aspect

@ControllerAdvice
public class exc {
    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception e) {
        // 发生异常
        // 记录异常，记录到日志文件
        // 发送通知，邮件，短信等等
        // 给用户友好的提示
    }
}

<!-- springmvc.xml -->
<context:component-scan base-package="xx"/> <!-- 声明组件扫描器 -->
<mvc:annotation-driven /> <!-- 注解驱动 -->

拦截器

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

拦截器：是springmvc框架中的一-种对象，需要实现接口HandlerInterceptor，拦截用户的请求。拦截到
controller的请求。

作用：拦截用户的请求，可以预先对请求做处理。根据处理结果，决定是否执行controller。也可以把多个controller中共用的功能定义到拦截器。

特点:

拦截器可以分为系统拦截器和自定义拦截器。
一个项目可以多个拦截器。0、或多个自定义拦截器。
拦截器侧重拦截用户的请求。
拦截器是在请求处理之前先执行的。

拦截器的定义: .

创建类实现拦截器接口HandlerInterceptor,实现接口中的方法(3个)
在springmvc配置文件中，声明拦截器对象，并指定拦截的url地址

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

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

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

进行重载

package com.bjpowernode.handle;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Inter implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

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

preHandle：预处理方法
- ```
/**
HttpServletRequest request, 
HttpServletResponse response, 
Object handler  被拦截的控制器对象(MyController)
*/
```
- 特点：预处理方法他的执行时间: 在控制器方法之前先执行的；可以对请求做处理，可以做登录的检查，权限的判断，统计数据等等；决定请求是否执行
postHandle：后处理方法
- ```
/**
HttpServletRequest request, 
HttpServletResponse response, 
Object handler, 被拦截的控制器对象(MyController)
ModelAndView modelAndView 控制器方法的返回值
*/
```
- 在控制器方法之后执行的；能获取到控制器方法的执行结果。可以修改原来的执行结果。可以修改数据，也可以修改视图；可以做对请求的二次处理。
afterCompletion：最后执行的方法
- ```
/**
HttpServletRequest request, 
HttpServletResponse response, 
Object handler, 被拦截的控制器对象(MyController)
Exception ex 异常对象
*/
```
- 在请求处理完成后执行的，请求处理完成的标志是视图处理完成；对视图执行forward操作后；可以做程序最后要做的工作，释放内存，清理临时变量。
- 方法的执行条件：当前的拦截器他的preHandle()方法必须执行；preHandle()必须返回true。

在springmvc.xml进行声明

<!-- 声明拦截器 -->
<mvc:interceptors>
    <!-- 声明第一个拦截器 -->
	<mvc:interceptor>
    	<!-- 指定拦截器的拦截地址 path:拦截url地址，可以使用**通配符 -->
        <mvc:mapping path=""/>
        <!-- 指定使用的拦截器 -->
        <bean class="全限定名称"/>
    </mvc:interceptor>
</mvc:interceptors>

多拦截器

为什么要使用多个拦截器?

把验证功能分散到独立的拦截器。每个拦截器做单-的验证处理。
组合多个拦截器。

多个拦截器是如何工作的？以数组HandlerInterceptor循环的方式实现

public class HandlerExecutionChain {
    private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);
    private final Object handler;
    @Nullable
    private HandlerInterceptor[] interceptors;
    @Nullable
    private List<HandlerInterceptor> interceptorList;
}

雨落水涨next

关注

0
点赞
踩
5
收藏
打赏
0
评论
SSM框架中项目逻辑层：SpringMVC

目录SpringMVCSpringMVC概述DispatcherServletSpringMVC请求处理过程SpringMVC的MVC组件SpringMVC注解式开发@RequestMapping处理器方法的参数处理器方法的返回值解读url-patternSSM整合SpringMVC前言：SSM框架快告一段落了，感觉SSM被誉为Java这种极度符合软件工程开发思想和OOP的入门框架果然有他的一套。“高内聚，低耦合”这六个字表现的淋漓尽致了真的是。希望Java越来越好，希望大家越学越好。SSM-Spr
复制链接

扫一扫