Note/Spring实战/6

落日映苍穹つ 2022-05-17 13:40 41阅读 0赞

上一篇：[Note5][]

**【前言】**

在上一篇讲了 Spring 装配 bean 的一些更高级的技巧，包括：Spring profile、条件化的 bean 声明、自动装配与歧义性、bean 的作用域、Spring 表达式语言，再结合 [Note4][] 中讲的 Spring 装配的基本方法，我们对 Spring 的 bean 装配算是已经有了足够的了解了。

依赖注入能够将组件及其协作的其他组件解耦， 与之类似， AOP有助于将应用组件与跨多个组件的任务进行解耦。 在这一篇文章中， 我们将会深入学习在 Spring 中如何创建和使用切面。

这一节的主要内容包括：

> 面向切面编程的基本原理

> 通过POJO创建切面

> 使用@AspectJ注解

> 为AspectJ切面注入依赖

本篇展示了 Spring 对切面的支持， 包括如何把普通类声明为一个切面和如何使用注解创建切面。 除此之外， 我们还会看到AspectJ——另一种流行的AOP实现——如何补充Spring AOP框架的功能。

### 1. AOP主要用来解决什么问题？ ###

在软件开发中，散布于应用中多处的功能（如日志、 安全、事务管理、缓存等）被称为横切关注点（crosscutting concern） 。通常来讲，这些横切关注点从概念上是与应用的业务逻辑相分离的（但是往往会直接嵌入到应用的业务逻辑之中）。把这些横切关注点与业务逻辑相分离（即，实现横切关注点与它们所影响的对象之间的解耦）正是面向切面编程（AOP）所要解决的问题。

### 2. AOP相关的术语 ###

![70][]

（1）通知（Advice）

通知定义了切面是什么以及何时使用。 即，通知除了要描述切面要完成的工作之外，还决定了何时去执行这个工作。

Spring 切面可以应用5种类型的通知：

> 前置通知（Before） ： 在目标方法被调用之前调用通知功能；

> 后置通知（After） ： 在目标方法完成之后调用通知， 此时不会关心方法的输出是什么；

> 返回通知（After-returning） ： 在目标方法成功执行之后调用通知；

> 异常通知（After-throwing） ： 在目标方法抛出异常后调用通知；

> 环绕通知（Around） ： 通知包裹了被通知的方法， 在被通知的方法调用之前和调用之后执行自定义的行为。

（2）连接点（Join point）

连接点是在应用执行过程中能够插入切面的一个点（或称为：时机）。 这个点可以是调用方法时、 抛出异常时、 甚至修改一个字段时。 切面代码可以利用这些点插入到应用的正常流程之中， 并添加新的行为。

连接点是程序执行过程中能够应用通知的所有点，但具体是那些点则由切点来决定。

（3）切点（Poincut）

一个切面并不需要通知应用的所有连接点。 切点有助于缩小切面所通知的连接点的范围。如果说通知定义了切面的“什么”和“何时”的话， 那么切点就定义了“何处”。

切点的定义会匹配通知所要织入的一个或多个连接点。 我们通常使用明确的类和方法名称， 或是利用正则表达式定义所匹配的  
类和方法名称来指定这些切点。

（4）切面（Aspect）

切面是**通知**和**切点**的结合。 通知和切点共同定义了切面的全部内容——它是什么， 在何时和何处完成其功能。

（5）引入（Introduction）

切点所在的类引入了通知类的方法和属性，从而达到在不修改现有的类的情况下， 让它具有新的行为和状态。这就是引入的概念。“引入”的概念会在下面的5.7中详细的介绍。

（6）织入（Weaving）

织入是把切面应用到目标对象并创建新的代理对象的过程。 切面在指定的连接点被织入到目标对象中。

在目标对象的生命周期里有多个点可以进行织入：

> 编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的

> 类加载期： 切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ 5的加载时织入（load-time weaving，LTW） 就支持以这种方式织入切面。

> 运行期： 切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。Spring AOP就是以这种方式织入切面的。

### 3. Spring对AOP的支持 ###

Spring提供了4种类型的AOP支持：

基于代理的经典Spring AOP（非常笨重和过于复杂，不再介绍）；

纯POJO切面；【对应本文第 6 节】

@AspectJ注解驱动的切面；【对应本文第 5 节】

注入式AspectJ切面（适用于Spring各版本）。【对应本文第 7 节】

前三种都是Spring AOP实现的变体， Spring AOP构建在动态代理基础之上， 因此， Spring对AOP的支持局限于方法拦截。

但AspectJ支持构造器和属性拦截。所以，如果需要方法拦截之外的连接点拦截功能， 那么我们可以利用Aspect来补充Spring AOP的功能

**3.1 纯POJO切面**

借助Spring的aop命名空间， 我们可以将纯POJO转换为切面。实际上是在这些纯POJO中定义好一些方法，当满足了切点条件时调用这些方法。但如何定义切点条件和调用方法之间的关系呢？这时就需要用到XML配置了。所以这种AOP支持需要依赖于XML配置。

**3.2 @AspectJ注解驱动的切面**

Spring借鉴了AspectJ的切面， 以提供注解驱动的AOP。 本质上， 它依然是Spring基于代理的AOP。这种AOP风格的好处在于能够不使用XML来完成功能。

**3.3 注入式AspectJ切面**

前面说到过，Spring对AOP的支持局限于方法拦截。如果你的AOP需求超过了简单的方法调用（如构造器或属性拦截） ，那么你需要考虑使用AspectJ来实现切面。

### 4. Spring在运行时通知对象 ###

通过在代理类中包裹切面， Spring在**运行期**把切面**织入**到Spring管理的bean中。如图下图所示， 代理类封装了目标类， 并拦截被通知方法的调用， 再把调用转发给真正的目标bean。 当代理拦截到方法调用时，在调用目标bean方法之前， 会执行切面逻辑。

![70 1][]

直到应用需要被代理的bean时， Spring才创建代理对象。 如果使用的是ApplicationContext的话， 在ApplicationContext从BeanFactory中加载所有bean的时候， Spring才会创建被代理的对象。 因为Spring运行时才创建代理对象， 所以我们不需要特殊的编译器来织入Spring AOP的切面。

**4.1 Spring AOP所支持的AspectJ切点指示器**

<table> 
 <tbody> 
  <tr> 
   <td>AspectJ指示器</td> 
   <td>描 述</td> 
  </tr> 
  <tr> 
   <td>arg()</td> 
   <td>限制连接点匹配参数为指定类型的执行方法</td> 
  </tr> 
  <tr> 
   <td>@args()</td> 
   <td>限制连接点匹配参数由指定注解标注的执行方法</td> 
  </tr> 
  <tr> 
   <td>execution()</td> 
   <td>用于匹配是连接点的执行方法</td> 
  </tr> 
  <tr> 
   <td>this()</td> 
   <td>限制连接点匹配AOP代理的bean引用为指定类型的类</td> 
  </tr> 
  <tr> 
   <td>target</td> 
   <td>限制连接点匹配目标对象为指定类型的类</td> 
  </tr> 
  <tr> 
   <td>@target()</td> 
   <td>限制连接点匹配特定的执行对象， 这些对象对应的类要具有指定类<br> 型的注解</td> 
  </tr> 
  <tr> 
   <td>within()</td> 
   <td>限制连接点匹配指定的类型</td> 
  </tr> 
  <tr> 
   <td>@within()</td> 
   <td>限制连接点匹配指定注解所标注的类型（当使用Spring AOP时， 方<br> 法定义在由指定的注解所标注的类里）</td> 
  </tr> 
  <tr> 
   <td>@annotation</td> 
   <td> <p>限定匹配带有指定注解的连接点&nbsp;</p> </td> 
  </tr> 
 </tbody> 
</table>

在上述指示器中，只有execution指示器是实际执行匹配的， 而其他的指示器都是用来限制匹配的。 这说明execution指示器是我们在编写切点定义时最主要使用的指示器。 在此基础上， 我们使用其他指示器来限制所匹配的切点。

**4.2 指示器示例与解析**

这里以一个XML方法的切面配置作为指示器的示例。

//通知类
    public class PrintSomeThing{
    	public void printBefore(){
    		System.out.print("I will do something");
    	}
    	public void printAfter(){
    		System.out.print("I finish the thing");
    	}
    }
     
    //连接点
    public class Atest implement Test{
        private DoThing doThing;
     
        public Atest(DoThing doThing,PrintSomeThing printSomeThing){
            this.doThing = doThing;
        }
     
        public void test(){
            doThing.do();
        }
    }

切面配置：

<?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:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">
     
        <bean id="atest" class="com.test.Atest">
            <constructor-arg ref="doThing" />
        </bean>
        <bean id="doThing" class="com.dothing.DoBthing">
        <bean id="printSomeThing" class="com.print.PrintSomeThing">
        <aop:config>
            <aop:aspect ref="printSomeThing">
    	    <aop:pointcut id="test" expression="execution(* *.test(..))"/>
    	    <aop:before pointcut-ref="test" method="printBefore"/>
    	    <aop:after pointcut-ref="test" method="printAfter"/>
    	</aop:aspect>		
        </aop:config>
    </beans>

切面配置解析：

在 Atest 的 test() 方法中调用 DoThing 的 do() 方法，但在调用 do() 方法前后需要进行相应的操作 ---- 在调用 do() 方法前调用 PrintSomeThing 的 printBefore() 方法，在调用 do() 方法后调用 PrintSomeThing 的 printAfter() 方法。

**AspectJ切点表达式解析：**

execution(* com.test.Atest.test(..))

表达式含义：当 com.test.Atest 类中的 test 方法执行时触发通知类（换种说法：切面的通知会被织入到所有 com.test.Atest 对象中）。

\[ execution \]  在方法（后面括号中的表达式匹配到的方法）执行时触发通知

\[ \*  \]  不限制方法返回的类型

\[ com.test.Atest \]  方法所属的类（全限定名：包名+类名）

\[ test \]  方法名

\[ (..) \]  参数不限

**其他指示器：**

1. 操作符：&&（等价于 and）、||（等价于 or）、!（等价于 not）

2. within()指示器示例

execution(* com.test.Atest.test(..)) && within(my.*)

表达式含义： 当 com.test.Atest 类（但该类必须要在my包下）中的 test 方法执行时触发通知类

3. bean()指示器示例

除上表所列的指示器外， Spring还引入了一个新的bean()指示器， 它允许我们在切点表达式中使用bean的ID来标识bean。bean()使用bean ID或bean名称作为参数来限制切点只匹配特定的bean。

execution(* com.test.Atest.test(..)) and !bean('aTest')

表达式含义：切面的通知会被织入到所有 com.test.Atest 类（但不包括bean的ID为'aTest'的bean）对象中

### 5. 使用注解声明切面 ###

要使用 @AspectJ 相关注解，需要先引入相关jar包：

<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <scope>runtime</scope>
    </dependency>

使用注解来创建切面是AspectJ 5所引入的关键特性，AspectJ面向注解的模型可以非常简便地通过少量注解把任意类转变为切面。

**5.1 使用注解来声明切面和通知**

以上面（4.2）的示例为例：

//定义切面
    @Aspect
    public class PrintSomeThing{
        @Before("execution(* com.test.Atest.test(..))")
        public void printBefore(){
            System.out.print("I will do something");
        }
    
        @After("execution(** com.test.Atest.test(..))")
        public void printAfter(){
            System.out.print("I finish the thing");
        }
    }

解析：

使用 @AspectJ 注解声明该 POJO 类是一个切面（但该类还是一个纯POJO的本质并没有改变），使用通知注解（@Before、@After、...）声明类中方法为切面的通知。

<table> 
 <tbody> 
  <tr> 
   <td>注 解</td> 
   <td>通 知</td> 
  </tr> 
  <tr> 
   <td>@After</td> 
   <td>通知方法会在目标方法返回或抛出异常后调用</td> 
  </tr> 
  <tr> 
   <td>@AfterReturning</td> 
   <td>通知方法会在目标方法返回后调用</td> 
  </tr> 
  <tr> 
   <td>@AfterThrowing</td> 
   <td>通知方法会在目标方法抛出异常后调用</td> 
  </tr> 
  <tr> 
   <td>@Around</td> 
   <td>通知方法会将目标方法封装起来</td> 
  </tr> 
  <tr> 
   <td>@Before</td> 
   <td>通知方法会在目标方法调用之前执行</td> 
  </tr> 
 </tbody> 
</table>

**5.2 使用注解声明切点**

可以看到上面的 @Before 注解和 @After 注解的切点表达式重复了，要知道这样是很蠢的，所以还有一个 @Pointcut 注解用来定义切点，并且定义好后可以在其他地方直接引用。

改造上面的切面：

//定义切面
    @Aspect
    public class PrintSomeThing{
        @Pointcut("execution(* com.test.Atest.test(..))")
        public void test(){}
    
        @Before("test()")
        public void printBefore(){
            System.out.print("I will do something");
        }
    
        @After("test()")
        public void printAfter(){
            System.out.print("I finish the thing");
        }
    }

上述代码中 test() 方法实际内容并不重要，该方法本身只是一个标识， 供 @Pointcut 注解依附，所以它是空的。

**5.3 启用自动代理功能**

上面已经定义好了一个切面，但现在还没用，@AspectJ 注解还不会被解析。因为还少了一个启用自动代理的配置。

（1）启动自动代理（JavaConfig配置方式）

@Configuration
    @EnableAspectJAutoProxy    //启动自动代理
    public class TestConfig{
        @Bean
        public PrintSomeThing printSomeThing(){
            return new PrintSomeThing();
        }
    }

（2）启用自动代理（XML配置方式）

需要使用使用 Spring aop 命名空间中的 <aop:aspectj-autoproxy> 元素。

<?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/aop
            http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    
        <aop:aspectj-autoproxy />
    
        <bean class="test.PrintSomeThing" />
    </beans>

开启自动代理功能后，AspectJ自动代理都会为使用@Aspect注解的bean创建一个代理， 这个代理会围绕着所有该切面的切点所匹配的bean。

**5.4 如何发挥出 AspectJ 的全部能力**

Spring的AspectJ自动代理仅仅使用@AspectJ作为创建切面的指导， 切面依然是基于代理的。 在本质上， 它依然是Spring基于代理的切面。 这一点非常重要， 因为这意味着尽管使用的是@AspectJ注解， 但我们仍然限于代理方法的调用。 如果想利用AspectJ的所有能力， 我们必须在运行时使用AspectJ并且不依赖Spring来创建基于代理的切面。

具体怎么搞后面在说。

**5.5 环绕通知**

基于环绕通知的特殊性，在这里单独来说一下环绕通知。

其实环绕通知等价于前置通知+后置通知。

@Aspect
    public class PrintSomeThing{
        @Pointcut("execution(* com.test.Atest.test(..))")
        public void test(){}
    
        @Around("test()")
        public void doSomeThings(ProceedingJoinPoint jp){
            try{
                System.out.print("I will do thing");
                jp.proceed();
                System.out.print("I finish the thing");
            }catch(Throwable e){
                ...
            }
        }
    }

参数 ProceedingJoinPoint 对象是必须要有的， 因为要在通知中通过它来调用被通知的方法（即，Atest 的 test() 方法）。

**【扩展】实现重试逻辑**

如果在环绕通知中不调用 ProceedingJoinPoint 的 proceed() 方法的话，则会阻塞对被通知方法的调用。但反过来，当对被通知方法调用失败后，按照一定的逻辑再次对被通知方法进行调用，就实现了重试逻辑。

**5.6 如何获取调用被通知方法时传入的参数**

前面的几个例子中，被通知方法 test() 本身没有任何参数。但是，如果被通知方法 test(String xxx)有参数，调用时传入了参数；而通知方法 printAfter() 希望拿到这个参数，再加以利用该怎么办呢？

@Aspect
    public class PrintSomeThing{
        @Pointcut("execution(* com.test.Atest.test(String)) && args(aaa)")
        public void test(String aaa){}
    
        //通知方法
        @After("test(bbb)")
        public void printAfter(String bbb){
            System.out.print(bbb + " finish the thing");
        }
    }
    
    public class Atest implement Test{
        //被通知方法
        public void test(String name){
       	    System.out.println("My name is " + name);
        }
    }

解析：

切点表达式中的 args(aaa) 限定符，表明传递给 test() 方法的 String 类型参数也会传递到通知中去。

![70 2][]

这样配置后，当调用 Atest 的 test() 方法时，传入的参数(name) ，就可以被通知方法 printAfter() 获取到了。

**5.7 术语 “引入” 再次解析**

在本篇一开始介绍AOP相关术语的时候，简单的介绍了一下 “引入” 的概念，这里再详细介绍一下。

未完待续...

### 6. 在XML中声明切面 ###

面向注解的切面声明有一个明显的劣势：你必须能够为通知类添加注解。为了做到这一点，必须要有源码。如果你没有源码的话，或者不想将AspectJ注解放到你的代码之中，Spring为切面提供了另外一种可选方案：在XML配置文件中声明切面。

在Spring的aop命名空间中，提供了多个元素用来在XML中声明切面：

<table> 
 <tbody> 
  <tr> 
   <td>AOP配置元素</td> 
   <td>用 途</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:advisor&gt;</td> 
   <td>定义AOP通知器</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:after&gt;</td> 
   <td>定义AOP后置通知（不管被通知的方法是否执行成功）</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:after<br> returning&gt;</td> 
   <td>定义AOP返回通知</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:after<br> throwing&gt;</td> 
   <td>定义AOP异常通知</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:around&gt;</td> 
   <td>定义AOP环绕通知</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:aspect&gt;</td> 
   <td>定义一个切面</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:aspectj<br> autoproxy&gt;</td> 
   <td>启用@AspectJ注解驱动的切面（即启用自动代理）</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:before&gt;</td> 
   <td>定义一个AOP前置通知</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:config&gt;</td> 
   <td>顶层的AOP配置元素。 大多数的&lt;aop:*&gt;元素必须包含<br> 在&lt;aop:config&gt;元素内</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:declare<br> parents&gt;</td> 
   <td>以透明的方式为被通知的对象引入额外的接口</td> 
  </tr> 
  <tr> 
   <td>&lt;aop:pointcut&gt;</td> 
   <td>定义一个切点</td> 
  </tr> 
 </tbody> 
</table>

**6.1 声明前置和后置通知**

将要被声明为切面的POJO：

public class PrintSomeThing{
        public void printBefore(){
            System.out.print("I will do something");
        }
    
        public void printAfter(){
            System.out.print("I finish the thing");
        }
    }

切点不单独拎出来定义时：

<aop:config>
        <aop:aspect ref="printSomeThing">
            <aop:before
                pointcut="execution(* com.test.Atest.test(..))"
                method="printBefore"/>
            <aop:after
                pointcut="execution(* com.test.Atest.test(..))"
                method="printAfter"/>
    	</aop:aspect>		
    </aop:config>

切点单独拎出来定义时：

<aop:config>
        <aop:aspect ref="printSomeThing">
            <aop:pointcut
                id="test"
                expression="execution(* com.test.Atest.test(..))" />
    
            <aop:before
                pointcut-ref="test"
                method="printBefore" />
            <aop:after
                pointcut-ref="test"
                method="printAfter" />
    	</aop:aspect>		
    </aop:config>

在 <aop:config> 元素内， 我们可以声明一个或多个 通知器（<aop:advisor>）、 切面（<aop:aspect>）、切点（<aop:pointcut>）。

如果想让定义的切点能够在多个切面使用， 我们可以把 <aop:pointcut> 元素放在 <aop:config> 元素的范围内。

**6.2 声明环绕通知**

前置通知和后置通知有一些限制。比如,如果不使用成员变量存储信息的话，在前置通知和后置通知之间共享信息非常麻烦。而环绕通知在这点上有明显的优势。

将要被声明为切面的POJO：

public class PrintSomeThing{
        public void doSomeThings(ProceedingJoinPoint jp){
            try{
                System.out.print("I will do thing");
                jp.proceed();
                System.out.print("I finish the thing");
            }catch(Throwable e){
                //与其他通知方法不同的是，环绕通知方法还要负责自身的异常处理
                ...
            }
        }
    }

声明环绕通知：

<aop:config>
        <aop:aspect ref="printSomeThing">
            <aop:pointcut
                id="test"
                expression="execution(* com.test.Atest.test(..))" />
    
            <aop:around
                pointcut-ref="test"
                method="doSomeThings" />
    	</aop:aspect>		
    </aop:config>

**6.3 如何获取调用被通知方法时传入的参数（XML版）**

【可以参考 5.6 的注解版进行对比】

需求重述：被通知方法 test(String xxx) 有参数，调用时穿入了参数；而通知方法 printAfter() 希望拿到这个参数，再加以利用该怎么办呢？

通知方法和被通知方法：

public class PrintSomeThing{
        //通知方法
        public void printAfter(String bbb){
            System.out.print(bbb + " finish the thing");
        }
    }
    
    public class Atest implement Test{
        //被通知方法
        public void test(String name){
       	    System.out.println("My name is " + name);
        }
    }

XML版配置：

<aop:config>
        <aop:aspect ref="printSomeThing">
            <aop:pointcut
                id="test"
                expression="execution(* com.test.Atest.test(String)) and args(name)" />
    
            <aop:after
                pointcut-ref="test"
                method="printAfter" />
    	</aop:aspect>		
    </aop:config>

在注解版和XML版配置中，切点表达式的配置几乎是相同的。 唯一的差别在于这里使用 and 关键字而不是 “&&”（因为在XML中， “&” 符号会被解析为实体的开始）。

**6.4 术语 “引入” 再次解析（XML版）**

未完待续...

### 7. 注入 AspectJ 切面 ###

虽然Spring AOP能够满足许多应用的切面需求， 但是与AspectJ相比，Spring AOP 是一个功能比较弱的AOP解决方案。 AspectJ提供了SpringAOP所不能支持的许多类型的切点。

实际上 AspectJ 和 Spring 并没啥关系，它是一个面向切面编程的框架。

未完待续...

[Note5]: https://blog.csdn.net/zhou520yue520/article/details/81351054
[Note4]: https://blog.csdn.net/zhou520yue520/article/details/80836344
[70]: /images/20220517/91942c1f61a8489e859bb095cd1599a1.png
[70 1]: /images/20220517/07418db6483440219102b03947c9220d.png
[70 2]: /images/20220517/08325357cf084734acf8a47372c86e8d.png