12月
02

Spring-AOP

发表于 • 字数统计:

面向切面编程(AOP)可以实现横切关注点与它们所影响对象之间的解耦，对业务逻辑没有任何侵入
使用场景有很多，如：日志、异常、声明式事物、安全、缓存等，包括但不限于这些场景
常见的AOP实现有Spring-AOP和AspectJ，Spring-AOP基于动态代理实现，主要总结一下Spring-AOP

概念

切面(Aspect)

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

通知(Advice)

切面的具体功能被称为通知，同时通知不仅定义了切面功能，还定义了切面何时使用，而根据使用时机可以分为5种类型的通知：

  • 前置通知(Before)：在目标方法被调用之前调用通知功能
  • 后置通知(After)：在目标方法完成之后调用通知，此时不会关心方法的输出是什么
  • 返回通知(After-returning)：在目标方法成功执行之后调用通知
  • 异常通知(After-throwing)：在目标方法抛出异常后调用通知
  • 环绕通知(Around)：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。环绕通知是最强大的通知类型

在 Spring-AOP 中的环绕通知必须有 ProceedingJoinPoint 这个对象参数，通过它的 proceed() 方法来调用被通知的方法

切点(Poincut)

通知定义了切面的 “什么” 和 “何时” ，切点则是定义了切面的 ”何处“

切点定义了通知被应用的具体位置(在哪些连接点)

连接点(Join point)

连接点是在应用执行过程中能够应用通知的 ”所有点“

连接点可以是调用方法时、抛出异常时、甚至修改一个字段时，但因为Spring-AOP基于动态代理，所以Spring只支持方法的连接点，而AspectJ和JBoss的AOP框架还提供了字段和构造器接入点。

但是方法拦截则满足了大部分的需求，如果需要方法拦截之外的连接点可以利用AspectJ来补充Spring-AOP的功能

引入(Introduction)

添加方法或字段到被通知的类

织入(Weaving)

织入是把切面应用到目标对象并创建新的代理对象的过程

织入可以在对象生命周期的多个点织入：

  • 编译期：切面在目标类编译期被织入。这种需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入
  • 类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器，可以在目标类被引入应用之前增强该目标类的字节码。AspectJ 5的加载时织入就支持这种方式织入
  • 运行期：切面在应用运行的某个时刻被织入。在织入时，AOP容器会为目标对象动态地创建一个代理对象。**Spring-AOP就是以这种方式织入切面的**

定义切点

切点用来定位使用通知的地方，在Spring-AOP中使用的是AspectJ的切点表达式语言来定义切点，但是Spring仅支持AspectJ切点指示器的一个子集

切点表达式

切点指示器

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

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

只有execution指示器是实际执行匹配的，而其他的指示器都是用来限制匹配的

操作符

支持and、or、not关系来连接指示器

在POJO中使用&&、||、!分别代表and、or、not关系

在XML中直接使用and、or、not来连接指示器

bean指示器

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

注解创建切面

AspectJ 5支持使用注解来创建切面，使用少量的注解就可以把任意类转变为切面

Spring同时支持AspectJ注解驱动的切面

AOP配置注解

@Aspect

表明该类不仅仅是个POJO，还是一个切面

通知注解

通知注解对应五种通知类型，来声明通知方法

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

@Pointcut注解可以在一个@AspectJ切面内定义可重用的切点

E.g.

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
@Aspect
public class Audience {

  @Pointcut("execution(** concert.Performance.perform(..))")
  public void performce() { }

  @Before("performce()")
  public void silenceCellPhones() {
    System.out.println("Silencing cell phones");
  }
  
  @Around("performce()")
  public void takeSeats(ProceedingJoinPoint joinPoint) {
	joinPoint.proceed(joinPoint.getArgs())
    System.out.println("Taking seats");
  }
  
  @AfterReturning("performce()")
  public void applause() {
    System.out.println("CLAP CLAP CLAP!!!");
  }
  
  @AfterThrowing("performce()")
  public void demandRefund() {
    System.out.println("Demanding a refund");
  }
}

通过在 performance() 方法上添加 @Pointcut 注解，这样就可以在任何的切点表达式中使用 performance() 了

performance() 方法的实际内容并不重要，在这里它实际上应该是空的。其实该方法本身只是一个标识，供 @Pointcut 注解依附。

通过注解引入新功能

类似Groovy不直接修改对象或类的定义就能为对象或类增加新的方法，虽然Java不是动态语言，但是通过AOP引用新的接口则可以实现其功能

但是当引入接口的方法被调用时，代理会把此调用委托给实现了新接口的某个其他对象。实际上，一个bean的实现被拆分到了多个类中

通过@DeclareParents注解可以将新的接口引入到bean中

定义新的接口:

1
2
3
4
5
package concert;

public interface Encoreable {
  void performEncore();
}

创建切面引入接口:

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

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;

@Aspect
public class EncodeableIntroducer {

  @DeclareParents(value="concert.Performce+",
                  defaultImpl=DefaultEncoreable.class)
  public static Encoreable encoreable;
}

@DeclareParents 注解由三部分组成：

  • value 属性指定了哪种类型的 bean 要引入该接口。在本例中，也就是所有实现 Performance 的类型。（标记符后面的加号表示是 Performance 的所有子类型，而不是 Performance 本身。）
  • defaultImpl 属性指定了为引入功能提供实现的类。在这里，我们指定的是 DefaultEncoreable 提供实现。
  • @DeclareParents 注解所标注的静态属性指明了要引入了接口。在这里，我们所引入的是 Encoreable 接口。

XML中声明切面

AOP配置元素

在 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:declare-parents> 以透明的方式为被通知的对象引入额外的接口
<aop:pointcut> 定义一个切点

E.g.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<aop:config>
  <aop:aspect ref="audience">
    <aop:pointcut
      id="performance"
      expressions="execution(** concert.Performance.perform(..))" />
  
    <aop:before
      pointcut-ref="performance"
      method="silenceCellPhones" />
    
    <aop:around
      pointcut-ref="performance"
      method="takeSeats" />
      
    <aop:after-returning 
      pointcut="execution(** concert.Performance.perform(..))"
      method="applause" />
      
    <aop:after-throwing
      pointcut-ref="performance"
      method="demandRefund" />
      
  </aop:aspect>
</aop:config>

通过切面引入新功能

使用 @DeclareParents 注解可以为被通知的方法引入新的方法，使用 Spring aop 命名空间中的 <aop:declare-parents> 元素，可以实现相同的功能

1
2
3
4
5
6
<aop:aspect>
  <aop:delate-parents
    types-matching="concert.Performance+"
    implement-interface="concert.Encoreable"
    default-impl="concert.DefaultEncoreable" />
</aop:aspect>
  • types-matching类型匹配，匹配为哪些bean引入接口
  • implement-interface指定新加的接口
  • default-impl用全限定类名来显式指定新加接口的实现
  • delegate-ref还支持引用了一个Spring bean作为引入接口的实现

启用AspectJ自动代理

无论是注解创建、还是XML声明切面，都需要启用自动代理，来创建切面的代理，否则切面不会生效

启用自动代理有两种方式：

  • 在JavaConfig中启用

    配置类的类级别上通过使用 @EnableAspectJAutoProxy 注解启用自动代理功能

  • 在XML中启用

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

注入AspectJ切面

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

AspectJ 可以织入到任意的Java应用程序中，而我们可以借助 Spring 的依赖注入把 bean 装配进 AspectJ 切面中，这样更为方便

用AspectJ实现切面

创建 AspectJ 的切面需要使用扩展的Java语言

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
package com.aspect.test;

public aspect AspectInject {
    public AspectInject() {
	}
	
    /**
     * Pointcut（切入点）：定义了相应Advice要发生的地方。
     * <p>
     * 定义切入点的常用的两种方式：
     * 1、使用正则表达式。
     * 2、使用AspectJ表达式（Https://www.iteye.com/blog/jinnianshilongnian-1415606）。
     */
    pointcut printInfo():execution(* xxx.xxx.xxx.xxx.printInfo(..));
    /**
     * 构造器切点
     */
    pointcut constructEntity():execution(xxx.xxx.xxx.xxx.User.new());
 
    /**
     * Advice定义了在Pointcut（切入点）具体要做的操作。
     * <p>
     * 切入点在AOP中有多种类型，但在Spring中只有方法类型。
     * <p>
     * before advice, 前置。
     * after return advice, 后置（出错不执行）。
     * after throwing advice, 后置（出错才执行）。
     * after(final) advice, 后置（怎么都执行）。
     * around advice, 环绕（前后都执行）。
     */
 
    before():printInfo(){
        System.out.println("------printInfo()方法的前置------");
    }
 
    after():printInfo(){
        System.out.println("------printInfo()的后置------");
    }
 
    before():constructEntity(){
        System.out.println("------new User()时候的前置------");
    }
 
    after():constructEntity(){
        System.out.println("-------new User()时候的后置------");
    }
}

使用aspectOf()方法注入

Spring bean 由 Spring 容器初始化，但是 AspectJ 切面是由 AspectJ 在运行期创建的。等到 Spring 有机会为 AspectJ 切面注入 bean 时，切面已经被实例化了。

所有的 AspectJ 切面都提供了一个静态的 aspectOf() 方法，该方法返回切面的一个单例。所以为了获得切面的实例，我们必须使用 factory-method 来调用 asepctOf() 方法

1
<bean class="com.aspect.test.AspectInject" factory-method="aspectOf"/>

参考文献

  • 《Spring 实战（第 4 版）》
分享到：