Spring系列之面向切面编程

面向切面编程(AOP)是 Spring 的另外一大核心,但 Spring 容器与 AOP 却不耦合,这意味着如果不需要 AOP,就不需要引入相关依赖。

Spring 中引入 AOP 主要用于两个方面:

  • 提供声明式企业级服务,比如声明式事务管理
  • 让 Spring 的用户可以在面向对象编程中(OOP)使用面向切面编程(AOP)

通过下面这张图就可以表现 AOP 的核心之处。正常的逻辑代码都是从上往下写的,是纵向的。而 AOP 则是在这些纵向的代码中插入一个切面,在这个切面里面假如一些逻辑,这些代码是横向的,这样就不会影响现有的逻辑。

AOP 的基本概念

在第一篇文章里面,简单介绍了一些 AOP 的相关概念。这里使用日志这个例子,来详细的说明 AOP 的概念。

看下面这段代码,现在有一个 Soldier 类,类中有一个 fight 方法,这个类就是上图中的黄色部分,正常的逻辑代码,现在有一个需求,要记录下 fight 过程,正常来说,当然也可以在 fight 中使用 Logger 来记录日志,带上这样就需要修改原有的代码,而且代码中会充斥着各种记录日志的代码。

这个问题可以使用 AOP 来解决,FightLog 就是上图中的紫色部分,这些代码不会影响到原有的逻辑,却可以完成记录 fight 日志的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class Soldier {
private Weapon weapon;

public void Soldier(Weapon weapon) {
this.weapon = weapon;
}

public void fight() {
weapon.attack();
}
}
@Aspect
@Component
public class FightLog {

@Pointcut("execution(* cn.rayjun.spring5demo.container.Soldier.fight(..))")
public void pointcut() {}

@Before("pointcut()")
public static void fightLogBefore(JoinPoint j) {
System.out.println(j);
System.out.println("FightBefore");
}

@After("pointcut()")
public static void fightLogAfter() {
System.out.println("FightAfter");
}

@AfterReturning("pointcut()")
public static void fightLogReturn() {
System.out.println("FightReturn");
}

@AfterThrowing("pointcut()")
public static void fightLogThrowing() {
System.out.println("FightThrowing");
}


@Around("pointcut()")
public static void fightAround(ProceedingJoinPoint pr) {
try {
System.out.println("FightAroundBefore");
pr.proceed();
System.out.println("FightAroundAfter");
} catch (Throwable throwable) {
throwable.printStackTrace();
System.out.println("FightAroundThrowing");
}
System.out.println("FightAround");
}
}

在上面的 FightLog 中,有 @Aspect,@Before,@After 这些注解都代表中特定的概念。

AOP 中的关键概念如下:

  • 切面(Aspect)
  • 连接点(Join point)
  • 切点(Pointcut)
  • 通知(Advice)
  • 引入(Introduction)
  • 织入(Weaving)

如果只看上面这些概念绝对让人很头疼,但是实际上,这些概念并不难,需要重点理解的也就切面、切点、通知三个。下面来详细看一下每个概念。

切面 切面其实很简单,就是上面图中的紫色部分,代表着一个单独的类,使用 @Aspect 注解(当然也可以使用 xml 配置)来定义。在这个类中可以定义一系列操作,这些操作就是由切点和通知组成,新加的这些操作不会影响原有的代码。

连接点和切点 其实连接点和切点表达的是同样的东西。如下图:

在正常的逻辑代码中调用方法,修改属性的操作都可以作为一个连接点,这个连接点可以作为切面切点。现在明白了,被切面所切入的连接点就叫做切点。

在使用 AOP 的过程中,可以在切点上获取连接点的所有信息,包括方法名称,参数等等。

通知 通知更好理解,通知就是在切点中进行的操作,通知有如下的种类:

  • @Before: 前置通知,在进入切点之前执行
  • @AfterReturning: 返回通知,在切点正常返回后执行
  • @AfterThrowing: 异常通知,在切点抛出异常后执行
  • @After: 后置通知,在正常执行或者抛出异常后都会执行
  • @Around: 环绕通知,这个比较特殊,这个通知方法会影响正常逻辑代码的执行,如果要使用这个通知,就必须要调用 ProceedingJoinPoint 的 proceed 方法才不影响正常的逻辑代码的执行。

引入和织入

这两个概念了解一下就可以,引入是指可以向现有的类添加新方法或者属性,织入则是把切面应用到目标方法并创建新的代理对象的过程。

这亮光概念涉及到 AOP 底层的实现,后续再详细说明。

Spring AOP 默认是使用 JDK 的动态代理来实现,如果有必要,也款已换成 CGLIB 代理来实现。

AOP 的配置及使用

Spring 容器默认是不启用 AOP 的,使用 AOP 需要引入额外的依赖,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.2.2</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.5</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.2</version>
</dependency>

同样,AOP 可以通过 xml 配置和 Java 配置。

XML 配置如下,只需要加上 <aop:aspectj-autoproxy/> 这个配置即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://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/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">

<context:component-scan base-package="cn.rayjun.spring5demo" />
<aop:aspectj-autoproxy/>
</beans>

Java 配置更加简单,只需要加上 @EnableAspectJAutoProxy 注解就可以了。

1
2
3
4
5
6
@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = "cn.rayjun.spring5demo")
public class SoldierConfig {

}

配置完成之后就可以定义切面,任意一个类,被 @Aspect 注解之后就可以作为一个切面了。

1
2
3
4
@Aspect
@Component
public class FightLog {
}

在定义好了切面之后,就可以定义切点来实现自定义的功能了,从上面我们知道了切点就是被选择的连接点,定义一个切点的方式如下:

1
execution(* cn.rayjun.spring5demo.container.Soldier.fight(..))

  • excution 表示这个切点的操作在连接点方法执行时触发。
  • * 表示返回任意的类型,就是对这个连接点方法的返回值没有要求
  • 中间就是连接点的全路径
  • .. 表示的是对输入参数也没有要求,可以接受任意参数

这样一来,方法名称是 fight,以及这个方法的多个重载方法都可以被该切点切入。

切点定义好了之后就需要给这个切点自定义操作:

1
2
3
4
@Before("execution(* cn.rayjun.spring5demo.container.Soldier.fight(..))")
public static void fightLogBefore() {
System.out.println("FightBefore");
}

假如说这个切点要在多个通知上被使用,可以用如下的定义:

1
2
3
4
5
6
7
8
9
10
11
12
@Pointcut("execution(* cn.rayjun.spring5demo.container.Soldier.fight(..))")
public void pointcut() {}

@Before("pointcut()")
public static void fightLogBefore() {
System.out.println("FightBefore");
}

@After("pointcut()")
public static void fightLogAfter() {
System.out.println("FightAfter");
}

上面说到了切点就是被选择的连接点,假如说现在需要在切点中获取连接点的一些信息和状态,直接就可以在切点中加上一个 JoinPoint 的参数,这个就表示连接点,通过这个连接点就可以做一些有意义的操作,根据当前连接点的状态来做一些操作,比如记日志,做统计

1
2
3
4
5
@Before("pointcut()")
public static void fightLogBefore(JoinPoint j) {
System.out.println(j);
System.out.println("FightBefore");
}

最后还需要说明的是环绕通知,这个比较特殊,这个通知的囊括了之前说的所有的通知,在这个通知中如果不调用 ProceedingJoinPoint 的 procceed 方法,原有的正常逻辑就无法执行,但是它的强大之处在于可以在这里自由的实现上述的各种通知,如下:

1
2
3
4
5
6
7
8
9
10
11
12
@Around("pointcut()")
public static void fightAround(ProceedingJoinPoint pr) {
try {
System.out.println("FightAroundBefore");
pr.proceed();
System.out.println("FightAroundAfter");
} catch (Throwable throwable) {
throwable.printStackTrace();
System.out.println("FightAroundThrowing");
}
System.out.println("FightAround");
}

AOP 是 Spring 重要的组成部分,除了生僻的概念比较多,其他的也不是很复杂。

© 2020 Rayjun    PowerBy Hexo