Spring 拦截器、异常处理与 AOP

# 1. Spring MVC 拦截器

Spring MVC 的拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。

将拦截器按一定的顺序联结成一条链，这条链称为拦截器链（Interceptor Chain）。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是 AOP 思想的具体实现。

拦截器 VS. 过滤器

区别	过滤器（Filter）	拦截器（Interceptor）
使用范围	是 servlet 规范中的一部分，任何 Java Web 工程都可以使用	是 Spring MVC 框架自己的，只有使用了 Spring MVC 框架的工程才能用
拦截范围	在 url-pattern 中配置了 `/*` 之后，可以对所有要访问的资源拦截	在 `<mvc:mapping path=""/>` 中配置了 `/**` 之后，也可以多所有资源进行拦截，但是可以通过 `<mvc:exclude-mapping path=""/>` 标签排除不需要拦截的资源

这俩的功能很多重叠，但在 Spring 中往往使用 Interceptor

# 1.1 拦截器快速入门

自定义拦截器很简单，只有如下三步：

创建拦截器类实现 HandlerInterceptor 接口
配置拦截器
测试拦截器的拦截效果

# 1）创建拦截器类实现 HandlerInterceptor 接口

public class MyHandlerInterceptor1 implements HandlerInterceptor {
    // 目标方法执行前
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
		System.out.println("preHandle running...");
		return true;
	}
    
    // 目标方法执行后
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
		System.out.println("postHandle running...");
	}
    
    // 在流程都执行完毕后
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
		System.out.println("afterCompletion running...");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

实现了 HandlerInterceptor 接口并重写相应的方法

# 2）配置拦截器

<!--配置拦截器-->
<mvc:interceptors>
	<mvc:interceptor>
		<mvc:mapping path="/**"/>
		<bean class="com.itheima.interceptor.MyHandlerInterceptor1"/>
	</mvc:interceptor>
</mvc:interceptors>

1
2
3
4
5
6
7

<mvc:mapping> 标签表示对哪些资源执行拦截操作

# 3）测试拦截器的拦截效果

对之前配置的资源进行访问时都会被拦截。

# 1.2 拦截器方法说明

方法名	说明
preHandle()	在请求处理之前调用，该方法的返回值是 boolean 类型的，当它返回为 false 时，表示请求结束，后续的 Interceptor 和 Controller 都不会再执行；当返回值为 true 时就会继续调用下一个 Interceptor 的 preHandle 方法.。
postHandle()	在当前请求进行处理之后被调用，它会在 DispatcherServlet 进行视图返回渲染之前被调用，所以我们可以在这个方法中对 Controller 处理之后的 ModelAndView 对象进行操作
afterCompletion()	在整个请求结束后，也就是在 DispatcherServlet 渲染了对应的视图之后执行

# 1.3 多拦截器操作

与之前相同，再编写一个 MyHandlerInterceptor2 类即可。

# 2. Spring MVC 异常处理机制

# 2.1 异常处理的思路

系统中异常包括两类：预期异常和运行时异常 RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试等手段减少运行时异常的发生。

系统的 Dao、Service、Controller 出现都通过 throws Exception 向上抛出，最后由 Spring MVC 前端控制器交由异常处理器进行异常处理，如下图：

# 2.2 异常处理的两种方式

方式一：使用 Spring MVC 提供的简单异常处理器 SimpleMappingExceptionResolver
方式二：实现 Spring 的异常处理接口 HandlerExceptionResolver 自定义自己的异常处理器

# 2.3 简单异常处理器 —— SimpleMappingExceptionResolver

Spring MVC 已经定义好了该类型转换器，在使用时可以根据项目情况进行相应异常与视图的映射配置。

<!--配置简单映射异常处理器-->
<bean 
class=“org.springframework.web.servlet.handler.SimpleMappingExceptionResolver”>
  <property name=“defaultErrorView” value=“error”/>
  <property name=“exceptionMappings”>
    <map>
      <entry key="com.itheima.exception.MyException" value="error"/>
      <entry key="java.lang.ClassCastException" value="error"/>
    </map>
  </property>
</bean>

1
2
3
4
5
6
7
8
9
10
11

line 4 的 property 表示默认错误视图。
<map> 下面的每个 <entry> 配置异常类型（key）与错误视图（value）的映射。

# 2.4 自定义异常处理步骤

创建异常处理器类实现 HandlerExceptionResolver
配置异常处理器
编写异常页面
测试异常跳转

# 1）创建异常处理器类实现 HandlerExceptionResolver

public class MyExceptionResolver implements HandlerExceptionResolver {
	@Override
	public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
		//处理异常的代码实现
		ModelAndView modelAndView = new ModelAndView();
		modelAndView.setViewName("exceptionPage");
		return modelAndView;
	}
}

1
2
3
4
5
6
7
8
9

参数 Exception：异常对象
返回值 ModelAndView：跳转到错误视图信息

# 2）配置异常处理器

<bean id="exceptionResolver" 
      class="com.itheima.exception.MyExceptionResolver"/>

1
2

# 3）编写异常页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>Title</title>
</head>
<body>
  这是一个最终异常的显示页面
</body>
</html>

1
2
3
4
5
6
7
8
9

# 4）测试异常跳转

@RequestMapping("/quick22")
@ResponseBody
public void quickMethod22() throws IOException, ParseException {
	SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
	simpleDateFormat.parse("abcde");
}

1
2
3
4
5
6

# 3. 面向切面编程 AOP

# 3.1 AOP 概述

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
优势：减少重复代码，提高开发效率，并且便于维护

AOP 的通俗表述

假设我们已经有了 save(user)、update(user) 和 delete(user) 三个功能，现在我们想对这三个功能进行增强，加上一个日志控制从而能够记录下他们执行的时间和次数，最简单的方法是将 日志控制 的代码加到原先的三个功能前面，但这导致了可维护性的变差，即修改日志控制功能的代码就要修改三处，于是我们改成在另外一个地方写日志控制的功能，然后在原先的三个功能前面引用日志控制的代码，但这样也还是耦合在了一起，比如原先的 save(user)的代码 处变成了 日志控制的引用;save(user)的代码，AOP 就是把日志控制和 save(user) 视为一个切面，然后在配置文件中将两者结合在一块，从而不用修改 save(user) 而能够在运行时将两个功能的运行结合在一块。

# 3.2 AOP 的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring 通过动态代理技术动态地生成代理对象，代理对象方法执行时进行增强功能的介入，再去调用目标对象的方法，从而完成功能的增强。

常用动态代理技术：

JDK 代理：基于接口的动态代理技术
cglib 代理：基于父类的动态代理技术

目标对象是需要功能增强的对象，代理对象是功能增强后的对象。
JDK 动态代理中，目标接口的存在保证了代理对象和目标对象有着相同的方法。
cglib 动态代理中，看上去像继承，但实际上在运行时动态地生成代理对象，然后代理对象在调用目标对象的功能前做一下其他事情，从而实现功能增强。

# 3.3 JDK 的动态代理

PS：这两节的 JDK 动态代理和 cglib 动态代理的代码能够读懂即可，不需要会写，在 Spring 中已经给出了封装。

# 1）目标类接口

public interface TargetInterface {
	public void save();
}

1
2
3

# 2）目标类

public class Target implements TargetInterface {
	@Override
	public void save() {
		System.out.println("Target running....");
	}
}

1
2
3
4
5
6

# 3）动态代理代码

Target target = new Target(); //创建目标对象
//创建代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),  // 目标对象类加载器
    target.getClass().getInterfaces(),   // 目标对象相同的接口字节码对象数组
    new InvocationHandler() {
		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			System.out.println("前置增强代码..."); // 前置增强
			Object invoke = method.invoke(target, args);
			System.out.println("后置增强代码..."); // 后置增强
			return invoke;
		}
	}
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

调用代理对象的任何方法，实质执行的都是 invoke 方法。

# 4）测试：调用代理对象的方法

// 测试，当调用接口的任何方法时，代理对象的代码都无序修改
proxy.save();

1
2

# 3.4 cglib 的动态代理

这是第三方的实现，Spring 中的 spring-core 已经给导入了 cglib 的包。

# 1）目标类

public class Target {
	public void save() {
		System.out.println("Target running....");
	}
}

1
2
3
4
5

# 2）动态代理代码

Target target = new Target(); // 创建目标对象
Enhancer enhancer = new Enhancer(); // 创建增强器
enhancer.setSuperclass(Target.class); // 设置父类
enhancer.setCallback(new MethodInterceptor() { // 设置回调
	@Override
	public Object intercept(Object proxy, Method method, Object[] args,
                            MethodProxy methodProxy) throws Throwable {
		System.out.println("前置代码增强....");
		Object invoke = method.invoke(target, args);
		System.out.println("后置代码增强....");
		return invoke;
	}
});

Target proxy = (Target) enhancer.create(); //创建代理对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 3）测试：调用代理对象的方法

//测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.save();

1
2

# 3.5 AOP 相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

在理解 AOP 之前，必须先理解如下的相关术语：

Target（目标对象）：代理的目标对象
Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在 Spring 中，这些点指的是方法，因为 spring 只支持方法类型的连接点。所以也说可以被增强的方法是连接点。
Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。真正被增强的方法是切入点。

PS：类比于生活中，连接点类似于“公民”，切入点类似于“人大代表”。

Advice（通知/增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
Aspect（切面）：是切入点和通知（引介）的结合
Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程（或者说将切点和增强结合在一块的过程就是织入）。Spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

# 3.6 AOP 开发明确的事项

# 1）需要编写的内容

编写核心业务代码（目标类的目标方法）
编写切面类，切面类中有通知(增强功能方法)
在配置文件中，配置织入关系，也就是将哪些通知与哪些连接点进行结合

# 2）AOP 技术实现的内容

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

# 3）AOP 底层使用哪种代理方式

在 Spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

# 3.7 基于 XML 的 AOP 开发

导入 AOP 相关坐标
创建目标接口和目标类（内部有切点）
创建切面类（内部有增强方法）
将目标类和切面类的对象创建权交给 spring
在 applicationContext.xml 中配置织入关系
测试代码

# 1）导入 AOP 相关坐标

<!--导入spring的context坐标，context依赖aop-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

1
2
3
4
5
6
7
8
9
10
11
12

Spring 本来也有对 AOP 的实现，但另一个第三方实现 AOP 的 AspectJ 更加好用，因此官方也推荐使用 AspectJ 的 AOP 实现。

# 2）创建目标接口和目标类（内部有切点）

public interface TargetInterface {
	public void save();
}

public class Target implements TargetInterface {
	@Override
	public void save() {
		System.out.println("Target running....");
	}
}

1
2
3
4
5
6
7
8
9
10

# 3）创建切面类（内部有增强方法）

public class MyAspect {
	//前置增强方法
	public void before(){
		System.out.println("前置代码增强.....");
	}
}

1
2
3
4
5
6

# 4）将目标类和切面类的对象创建权交给 Spring

<!--配置目标类-->
<bean id="target" class="com.example.aop.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="com.example.aop.MyAspect"></bean>

1
2
3
4

# 5）在 applicationContext.xml 中配置织入关系

导入 AOP 命名空间：

⭐️ 配置切点表达式和前置增强的织入关系：

<aop:config>
	<!--引用myAspect的Bean为切面对象-->
	<aop:aspect ref="myAspect">
	<!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
	<aop:before method="before" pointcut="execution(public void com.itheima.aop.Target.save())"></aop:before>
	</aop:aspect>
</aop:config>

1
2
3
4
5
6
7

# 6）测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
	@Autowired
	private TargetInterface target;
    
	@Test
	public void test1(){
		target.save();
	}
}

1
2
3
4
5
6
7
8
9
10
11

# 3.8 XML 配置 AOP 详解

# 3.8.1 切点表达式的写法

表达式语法：

execution([修饰符] 返回值类型包名.类名.方法名(参数))

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用星号 * 代表任意
包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表

例如：

execution(public void com.itheima.aop.Target.method())
execution(void com.itheima.aop.Target.*(..))
execution(* com.itheima.aop.*.*(..))
execution(* com.itheima.aop..*.*(..))
execution(* *..*.*(..))

1
2
3
4
5

# 3.8.2 通知的类型

通知的配置语法：

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

名称	标签	说明
前置通知	`<aop:before>`	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	`<aop:after-returning>`	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	`<aop:around>`	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	`<aop:throwing>`	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	`<aop:after>`	用于配置最终通知。无论增强方式执行是否有异常都会执行

# 3.8.3 切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。

<aop:config>
	<!--引用myAspect的Bean为切面对象-->
	<aop:aspect ref="myAspect">
		<aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"/>
		<aop:before method="before" pointcut-ref="myPointcut"></aop:before>
	</aop:aspect>
</aop:config>

1
2
3
4
5
6
7

# 3.9 基于注解的 AOP 开发

创建目标接口和目标类（内部有切点）
创建切面类（内部有增强方法）
将目标类和切面类的对象创建权交给 Spring
在切面类中使用注解配置织入关系
在配置文件中开启组件扫描和 AOP 的自动代理
测试

# 1）创建目标接口和目标类（内部有切点）

public interface TargetInterface {
	public void method();
}

public class Target implements TargetInterface {
	@Override
	public void method() {
		System.out.println("Target running....");
	}
}

1
2
3
4
5
6
7
8
9
10

# 2）创建切面类（内部有增强方法）

public class MyAspect {
	//前置增强方法
	public void before(){
		System.out.println("前置代码增强.....");
	}
}

1
2
3
4
5
6

# 3）将目标类和切面类的对象创建权交给 Spring

@Component("target")
public class Target implements TargetInterface {
	@Override
	public void save() {
		System.out.println("Target running....");
	}
}

@Component("myAspect")
public class MyAspect {
	public void before() {
		System.out.println("前置代码增强.....");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 4）在切面类中使用注解配置织入关系

@Component("myAspect")
@Aspect
public class MyAspect {
	@Before("execution(* com.example.aoptest.*.*(..))")
	public void before(){
		System.out.println("前置代码增强.....");
	}
}

1
2
3
4
5
6
7
8

# 5）在配置文件中开启组件扫描和 AOP 的自动代理

<!--组件扫描-->
<context:component-scan base-package="com.example.aoptest"/>
<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

1
2
3
4

# 6）测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
	@Autowired
	private TargetInterface target;
    
	@Test
	public void test1(){
		target.method();
	}
}

1
2
3
4
5
6
7
8
9
10
11

# 3.10 注解配置 AOP 详解

# 3.10.1 注解通知的类型

通知的配置语法：@通知注解(“切点表达式")

名称	注解	说明
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	@Around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@AfterThrowing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	@After	用于配置最终通知。无论增强方式执行是否有异常都会执行

# 3.10.2 切点表达式的抽取

同 xml 配置 aop 一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut 注解定义切点表达式，然后在在增强注解中进行引用。具体如下：

@@Component("myAspect")
@Aspect
public class MyAspect {
	@Before("MyAspect.myPoint()")
	public void before(){
		System.out.println("前置代码增强.....");
	}
    
    // 定义切点表达式
	@Pointcut("execution(* com.example.aoptest.*.*(..))")
	public void myPoint(){}
}

1
2
3
4
5
6
7
8
9
10
11
12

编辑

上次更新: 2023/04/22, 08:56:42

← Spring MVC 入门 Spring 事务控制→

Spring 拦截器、异常处理与 AOP

# 1. Spring MVC 拦截器

# 1.1 拦截器快速入门

# 1）创建拦截器类实现 HandlerInterceptor 接口

# 2）配置拦截器

# 3）测试拦截器的拦截效果

# 1.2 拦截器方法说明

# 1.3 多拦截器操作

# 2. Spring MVC 异常处理机制

# 2.1 异常处理的思路

# 2.2 异常处理的两种方式

# 2.3 简单异常处理器 —— SimpleMappingExceptionResolver

# 2.4 自定义异常处理步骤

# 1）创建异常处理器类实现 HandlerExceptionResolver

# 2）配置异常处理器

# 3）编写异常页面

# 4）测试异常跳转

# 3. 面向切面编程 AOP

# 3.1 AOP 概述

# 3.2 AOP 的底层实现

# 3.3 JDK 的动态代理

# 1）目标类接口

# 2）目标类

# 3）动态代理代码

# 4）测试：调用代理对象的方法

# 3.4 cglib 的动态代理

# 1）目标类

# 2）动态代理代码

# 3）测试： 调用代理对象的方法

# 3.5 AOP 相关概念

# 3.6 AOP 开发明确的事项

# 1）需要编写的内容

# 2）AOP 技术实现的内容

# 3）AOP 底层使用哪种代理方式

# 3.7 基于 XML 的 AOP 开发

# 1）导入 AOP 相关坐标

# 2）创建目标接口和目标类（内部有切点）

# 3）创建切面类（内部有增强方法）

# 4）将目标类和切面类的对象创建权交给 Spring

# 5）在 applicationContext.xml 中配置织入关系

# 6）测试代码

# 3.8 XML 配置 AOP 详解

# 3.8.1 切点表达式的写法

# 3.8.2 通知的类型

# 3.8.3 切点表达式的抽取

# 3.9 基于注解的 AOP 开发

# 1）创建目标接口和目标类（内部有切点）

# 2）创建切面类（内部有增强方法）

# 3）将目标类和切面类的对象创建权交给 Spring

# 4）在切面类中使用注解配置织入关系

# 5）在配置文件中开启组件扫描和 AOP 的自动代理

# 6）测试代码

# 3.10 注解配置 AOP 详解

# 3.10.1 注解通知的类型

# 3.10.2 切点表达式的抽取

# 3）测试：调用代理对象的方法