Note/Spring实战/6

最新推荐文章于 2023-03-25 08:00:58 发布

月下泛舟

最新推荐文章于 2023-03-25 08:00:58 发布

阅读量196

点赞数

分类专栏： Spring 框架文章标签： spring AOP spring spring实战（第4版）

本文链接：https://blog.csdn.net/zhou520yue520/article/details/81608730

版权

Spring 同时被 2 个专栏收录

10 篇文章 3 订阅

订阅专栏

框架

7 篇文章 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相关的术语

（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方法之前，会执行切面逻辑。

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

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

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

在上述指示器中，只有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、...）声明类中方法为切面的通知。

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

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 类型参数也会传递到通知中去。

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

5.7 术语 “引入” 再次解析

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

未完待续...

6. 在XML中声明切面

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

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

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

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 并没啥关系，它是一个面向切面编程的框架。

未完待续...

月下泛舟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Note/Spring实战/6

上一篇：Note5【前言】在上一篇讲了 Spring 装配 bean 的一些更高级的技巧，包括：Spring profile、条件化的 bean 声明、自动装配与歧义性、bean 的作用域、Spring 表达式语言，再结合 Note4 中讲的 Spring 装配的基本方法，我们对 Spring 的 bean 装配算是已经有了足够的了解了。依赖注入能够将组件及其协作的其他组件解耦，与之...
复制链接

扫一扫

专栏目录