上一篇: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 并没啥关系,它是一个面向切面编程的框架。
未完待续...