在软件开发中,散布于应用中多处的功能被称为横切关注点(crosscutting concern)。通常来讲,这些横切关注点从概念上是与应用的业务逻辑相分离的(但是往往会直接嵌入到应用的业务逻辑之中)。把这些横切关注点与业务逻辑相分离正是面向切面编程(AOP)所要解决的问题
面向切面编程
下图展现了一个被划分为模块的典型应用。每个模块的核心功能都是为特定业务领域提供服务,但是这些模块都需要类似的辅助功能,例如安全和事务管理
切面提供了取代继承和委托的方案,且在很多场景下更清晰简洁。使用面向切面编程时,仍然在一个地方定义通用功能,但是可以通过声明的方式定义这个功能要以何种方式在何处应用,而无需修改受影响的类。横切关注点可以被模块化为特殊的类,这些类被称为切面(aspect)
这样做有两个好处:首先,现在每个关注点都集中于一个地方,而不是分散到多处代码中;其次,服务模块更简洁,因为它们只包含主要关注点(或核心功能)的代码,而次要关注点的代码被转移到切面中
定义AOP术语
描述切面的常用术语有通知(advice)、切点(pointcut)和连接点(join point)。下图展示了这些概念的关联方式
通知(Advice)
切面的工作被称为通知。通知定义了切面是什么以及何时使用
Spring切面可以应用5种类型的通知:
前置通知(Before):在目标方法被调用之前调用通知功能
后置通知(After):在目标方法完成之后调用通知,此时不会关心方法的输出是什么
返回通知(After-returning):在目标方法成功执行之后调用通知
异常通知(After-throwing):在目标方法抛出异常后调用通知
环绕通知(Around):通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为
连接点(Join point)
连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中,并添加新的行为
切点(Poincut)
通知定义了切面的“什么”和“何时”的话,切点定义了“何处”。切点的定义会匹配通知所要织入的一个或多个连接点
通常使用明确的类和方法名称,或是利用正则表达式定义所匹配的类和方法名称来指定这些切点。有些AOP框架允许创建动态的切点,可以根据运行时的决策(比如方法的参数值)来决定是否应用通知
切面(Aspect)
切面是通知和切点的结合。通知和切点共同定义了切面的全部内容——它是什么,在何时和何处完成其功能
引入(Introduction)
引入允许我们向现有的类添加新方法或属性。例如,我们可以创建一个Auditable通知类,该类记录了对象最后一次修改时的状态。这很简单,只需一个方法,setLastModified(Date),和一个实例变量来保存这个状态。然后,这个新方法和实例变量就可以被引入到现有的类中,从而可以在无需修改这些现有的类的情况下,让它们具有新的行为和状态
织入(Weaving)
织入是把切面应用到目标对象并创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中。在目标对象的生命周期里有多个点可以进行织入:
编译期:切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的
类加载期:切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器(ClassLoader),它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ 5的加载时织入(load-time weaving,LTW)就支持以这种方式织入切面
运行期:切面在应用运行的某个时刻被织入。一般情况下,在织入切面时,AOP容器会为目标对象动态地创建一个代理对象。Spring AOP就是以这种方式织入切面的
Spring对AOP的支持
Spring提供了4种类型的AOP支持:
基于代理的经典Spring AOP
纯POJO切面
@AspectJ注解驱动的切面
注入式AspectJ切面(适用于Spring各版本)
Spring通知是Java编写的
Spring所创建的通知都是用标准的Java类编写的。而且,定义通知所应用的切点通常会使用注解或在Spring配置文件里采用XML来编写
AspectJ与之相反。虽然AspectJ现在支持基于注解的切面,但AspectJ最初是以Java语言扩展的方式实现的。这种方式有优点也有缺点。通过特有的AOP语言,我们可以获得更强大和细粒度的控制,以及更丰富的AOP工具集,但是我们需要额外学习新的工具和语法
Spring在运行时通知对象
通过在代理类中包裹切面,Spring在运行期把切面织入到Spring管理的bean中。如图所示,代理类封装了目标类,并拦截被通知方法的调用,再把调用转发给真正的目标bean。当代理拦截到方法调用时,在调用目标bean方法之前,会执行切面逻辑
Spring的切面由包裹了目标对象的代理类实现。代理类处理方法的调用,执行额外的切面逻辑,并调用目标方法
直到应用需要被代理的bean时,Spring才创建代理对象。如果使用的是ApplicationContext的话,在ApplicationContext从BeanFactory中加载所有bean的时候,Spring才会创建被代理的对象。因为Spring运行时才创建代理对象,所以我们不需要特殊的编译器来织入Spring AOP的切面
Spring只支持方法级别的连接点
通过使用各种AOP方案可以支持多种连接点模型。因为Spring基于动态代理,所以Spring只支持方法连接点。Spring缺少对字段连接点的支持,无法让我们创建细粒度的通知,例如拦截对象字段的修改。而且它不支持构造器连接点,我们就无法在bean创建时应用通知。但是方法拦截可以满足绝大部分的需求。如果需要方法拦截之外的连接点拦截功能,那么可以利用Aspect来补充Spring AOP的功能
通过切点来选择连接点
关于Spring AOP的AspectJ切点,Spring仅支持AspectJ切点指示器(pointcut designator)的一个子集。下表列出了Spring AOP所支持的AspectJ切点指示器:
AspectJ指示器 | 描 述 |
---|---|
arg() | 限制连接点匹配参数为指定类型的执行方法 |
@args() | 限制连接点匹配参数由指定注解标注的执行方法 |
execution() | 用于匹配是连接点的执行方法 |
this() | 限制连接点匹配AOP代理的bean引用为指定类型的类 |
target | 限制连接点匹配目标对象为指定类型的类 |
@target() | 限制连接点匹配特定的执行对象,这些对象对应的类要具有指定类型的注解 |
within() | 限制连接点匹配指定的类型 |
@within() | 限制连接点匹配指定注解所标注的类型(当使用Spring AOP时,方法定义在由指定的注解所标注的类里) |
@annotation | 限定匹配带有指定注解的连接点 |
在Spring中尝试使用AspectJ其他指示器时,将会抛出IllegalArgument-Exception异常
注:只有execution指示器是实际执行匹配的,而其他的指示器都是用来限制匹配的。说明execution指示器是在编写切点定义时最主要使用的指示器
编写切点
package concert;
public interface Performance
{
public void perform();
}
Performance可以代表任何类型的现场表演,如舞台剧、电影或音乐会。设想编写Performance的perform()方法触发的通知。下图展现了一个切点表达式,这个表达式能够设置当perform()方法执行时触发通知的调用
使用AspectJ切点表达式来选择Performance的perform()方法:
使用execution()指示器选择Performance的perform()方法。方法表达式以“*”号开始,表明了不关心方法返回值的类型。然后指定全限定类名和方法名。对于方法参数列表,使用两个点号(..)表明切点要选择任意的perform()方法,无论该方法的入参是什么
设现需配置的切点仅匹配concert包。在此场景下,可以使用within()指示器限制切点范围:
and代替“&&”,or代替“||”,not代替“!”
在切点中选择bean
Spring引入新的bean()指示器,它允许在切点表达式中使用bean的ID来标识bean。bean()使用bean ID或bean名称作为参数来限制切点只匹配特定的bean
执行Performance的perform()方法时应用通知,但限定bean的ID为woodstock:
execution(* concert.Performance.perform()) and bean('woodstock')
使用非操作为除了特定ID以外的其他bean应用通知:
execution(* concert.Performance.perform()) and !bean('woodstock')
使用注解创建切面
定义切面
//Audience类:观看演出的切面
package concert;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class Audience
{
@Before("execution(** concert.Performance.perform(..))") // 表演之前
public void silenceCellPhones()
{
System.out.println("Silencing cell phones");
}
@Before("execution(** concert.Performance.perform(..))") // 表演之前
public void takeSeats()
{
System.out.println("Taking seats");
}
@AfterReturning("execution(** concert.Performance.perform(..))") // 表演之后
public void applause()
{
System.out.println("CLAP CLAP CLAP!!!");
}
@AfterThrowing("execution(** concert.Performance.perform(..))") // 表演失败之后
public void demandRefound()
{
System.out.println("Demanding a refund");
}
}
Audience类使用@AspectJ注解进行了标注。该注解表明Audience不仅仅是一个POJO,还是一个切面。Audience类中的方法都使用注解来定义切面的具体行为
Spring使用AspectJ注解来声明通知方法:
注 解 | 通 知 |
---|---|
@After | 通知方法会在目标方法返回或抛出异常后调用 |
@AfterReturning | 通知方法会在目标方法返回后调用 |
@AfterThrowing | 通知方法会在目标方法抛出异常后调用 |
@Around | 通知方法会将目标方法封装起来 |
@Before | 通知方法会在目标方法调用之前执行 |
为@Pointcut注解设置的值是一个切点表达式,就像之前在通知注解上所设置的那样。通过在performance()方法上添加@Pointcut注解,实际上扩展了切点表达式语言,这样就可以在任何的切点表达式中使用performance()了,如果不这样做的话,需要在这些地方使用那个更长的切点表达式
现在把所有通知注解中的长表达式都替换成了performance(),该方法的实际内容并不重要,在这里实际上是空的。其实该方法本身只是一个标识,供@Pointcut注解依附
// 通过@Pointcut注解声明频繁使用的切点表达式
package concert;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class Audience
{
@Pointcut("execution(** concert.Performance.perform(..))") //定义命名的切点
public void performance(){}
@Before("performance()")
public void silenceCellPhones()
{
System.out.println("Silencing cell phones");
}
@Before("execution(** concert.Performance.perform(..))") // 表演之前
public void takeSeats()
{
System.out.println("Taking seats");
}
@AfterReturning("performance()") // 表演之后
public void applause()
{
System.out.println("CLAP CLAP CLAP!!!");
}
@AfterThrowing("performance()") // 表演失败之后
public void demandRefound()
{
System.out.println("Demanding a refund");
}
}
像其他的Java类一样,它可以装配为Spring中的bean:
@Bean
public Audience audience()
{
return new Audience();
}
通过上述操作,Audience只会是Spring容器中的一个bean。即便使用了AspectJ注解,但它并不会被视为切面,这些注解不会解析,也不会创建将其转换为切面的代理
使用JavaConfig可以在配置类的类级别上通过使用EnableAspectJ-AutoProxy注解启用自动代理功能:
package concert;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
// 启动AspectJ自动代理
@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class ConcertConfig
{
@Bean
public Audience audience()
{
return new Audience();
}
}
使用XML来装配bean需要使用Springaop命名空间中的<aop:aspectj-autoproxy>元素
// 在XML中,通过Spring的aop命名空间启用AspectJ自动代理
<?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" // 声明Spring的aop命名空间
xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<context:component-scan base-package = "concert" />
<aop:aspectj-autoproxy /> // 启动AspectJ自动代理
<bean class= "concert.Audience" /> // 声明Audience bean
</beans>
JavaConfig和XML配置,AspectJ自动代理都会为使用@Aspect注解的bean创建一个代理,这个代理会围绕着所有该切面的切点所匹配的bean。在这种情况下,将会为Concert bean创建一个代理,Audience类中的通知方法将会在perform()调用前后执行
Spring的AspectJ自动代理仅仅使用@AspectJ作为创建切面的指导,切面依然是基于代理的。在本质上,它依然是
Spring基于代理的切面。这一点非常重要,因为这意味着尽管使用的是@AspectJ注解,但我们仍然限于代理方法的调用。如果想利用AspectJ的所有能力,我们必须在运行时使用AspectJ并且不依赖Spring来创建基于代理的切面
创建环绕通知
环绕通知是最为强大的通知类型。能够让所编写的逻辑被通知的目标方法完全包装起来。实际上就像在一个通知方法中同时编写前置通知和后置通知
// 使用环绕通知重新实现Audience切面
package concert;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class Audience
{
@Pointcut("execution(** concert.Performance.perform(..))") //定义命名的切点
public void performance(){}
@Around("performance()")
public void watchPerformance(ProceedingJoinPoint jp)
{
try{
System.out.println("Silencing cell phones");
System.out.println("Taking seats");
jp.proceed();
System.out.println("CLAP CLAP CLAP!!!");
} catch(Throwable e){
System.out.println("Demanding a refund");
}
}
}
@Around注解表明watchPerformance()方法会作为performance()切点的环绕通知。首先接受ProceedingJoinPoint作为参数。这个对象是必须要有的,因为在通知中需要通过它来调用被通知的方法。通知方法中可以做任何的事情,当要将控制权交给被通知的方法时,它需要调用ProceedingJoinPoint的proceed()方法
注:调用proceed()方法。如不调该方法,那么通知实际上会阻塞对被通知方法的调用;若不调用proceed()方法,会阻塞对被通知方法的访问,与之类似,也可以在通知中对它进行多次调用
处理通知中的参数
创建TrackCounter类,用来记录每个磁道所播放的次数,是通知playTrack()方法的一个切面。下面的程序清单展示了这个切面:
// 使用参数化的通知来记录磁道播放的次数
package soundsystem;
import java.util.HashMap;
import java.util.Map;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class TrackCounter
{
private Map<Integer, Integer> TrackCounts = new HashMap<Integer, Integer>();
// 通知playTrack()方法
@Pointcut(
"execution(* soundsystem.CompactDisc.playTrack(int))" +
"&& args(trackNumber)" )
public void trackPlayed(int trackNumber){}
@Before("trackPlayed(trackNumber)") // 在播放前,为该磁道计数
public void countTrack(int trackNumber)
{
int currentCount = getPlayCount(trackNumber);
trackCounts.put(trackNumber, currentCount + 1);
}
public int getPlayCount(int trackNumber)
{
return trackCounts.containsKey(trackNumber) ? trackCounts.get(trackNumber) : 0;
}
}
在切点表达式中声明参数,这个参数传入到通知方法中:
切点表达式中的args(trackNumber)限定符。表明传递给playTrack()方法的int类型参数也会传递到通知中去。参数的名称trackNumber也与切点方法签名中的参数相匹配
这个参数会传递到通知方法中,这个通知方法是通过@Before注解和命名切点trackPlayed(trackNumber)定义的。切点定义中的参数与切点方法中的参数名称是一样的,这样就完成了从命名切点到通知方法的参数转移
// 配置TrackCount记录每个磁道播放的次数
package soundsystem;
import java.util.ArrayList;
import java.List;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@EnableAspectJAutoProxy // 启用AspectJ自动代理
public class TrackCounterConfig
{
@Bean
public CompactDisc sgtPeppers() // CompactDisc bean
{
BlankDisc cd = new BlankDisc();
cd.setTitle("Sgt. Pepper's Lonely Hearts Club Band");
cd.setArtist("The Beales");
List<String> tracks = new ArrayList<String>();
tracks.add("Sgt. Pepper's Lonely Hearts Club Band");
tracks.add("With a Little Help from My Friends");
tracks.add("Lucy in the Sky with Diamonds");
tracks.add("Getting Better");
tracks.add("Fixing a Hole");
// ...other tracks omitted for brevity...
cd.setTracks(tracks);
return cd;
}
@Bean
public TrackCounter trackCounter() // TrackCounter bean
{
return new TrackCounter();
}
}
通过注解引入新功能
使用Spring AOP,我们可以为bean引入新的方法。代理拦截调用并委托给实现该方法的其他对象
为示例中的所有的Performance实现引入下面的Encoreable接口:
package concert;
public interface Encoreable
{
void performEncore();
}
借助于AOP的引入功能,不必在设计上妥协或者侵入性地改变现有的实现。为了实现该功能,创建一个新
的切面:
package concert;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
@Aspect
public class EncoreableIntroducer
{
@DeclareParents(value = "concert.Performance+", defaultImpl = DefaultEncoreable.class)
public static Encoreable encoreable;
}
EncoreableIntroducer是一个切面。但是它与之前所创建的切面不同,并没有提供前置、后置或环绕通知,而是
通过@DeclareParents注解,将Encoreable接口引入到Performance bean中
@DeclareParents注解由三部分组成:
value属性指定了哪种类型的bean要引入该接口。在本例中,也就是所有实现Performance的类型。(标记符后面的加号表示是Performance的所有子类型,而不是Performance本身。)
defaultImpl属性指定了为引入功能提供实现的类。这里指定的是DefaultEncoreable提供实现
@DeclareParents注解所标注的静态属性指明了要引入了接口。这里所引入的是Encoreable接口
和其他的切面一样,需要在Spring应用中将EncoreableIntroducer声明为一个bean:
<bean class = "concert.EncoreableIntroducer" />
Spring的自动代理机制将会获取到它的声明,当Spring发现一个bean使用了@Aspect注解时,Spring就会创建一个代理,然后将调用委托给被代理的bean或被引入的实现,这取决于调用的方法属于被代理的bean还是属于被引入的接口
注入AspectJ切面
为演出创建一个新切面。具体来讲,以切面的方式创建一个评论员的角色,他会观看演出并且会在演出之后提供一些批评意见
// 使用AspectJ实现表演的评论员
package concert;
public aspect CriticAspect{
public CriticAspect(){}
pointcut performance() : execution(* perform(..));
afterReturning() : performance()
{
System.out.println(criticismEngine.getCriticism());
}
private CriticismEngine criticismEngine;
public void setCriticismEngine(CriticismEngine criticismEngine) // 注入CriticismEngine
{
this.criticismEngine = criticismEngine;
}
}
上述程序中的performance()切点匹配perform()方法。当它与afterReturning()通知一起配合使用时,可以让该切面在表演结束时起作用
实际上,CriticAspect与一个CriticismEngine对象相协作,在表演结束时,调用该对象的getCriticism()方法来发表一个苛刻的评论。为了避免CriticAspect和CriticismEngine之间产生不必要的耦合,我们通过Setter依赖注入为CriticAspect设置CriticismEngine。此关系如下图所示:
切面也需要注入。像其他的bean一样,Spring可以为AspectJ切面注入依赖
\\ 要注入到CriticAspect中的CriticismEngine实现
package com.springinaction.springidol;
public class CriticismEngineImpl implements CriticismEngine
{
public CriticismEngineImpl(){}
public String getCriticism()
{
int i = (int) (Math.random() * criticismPool.length)
return criticismPool[i];
}
// injected
private String[] criticismPool;
public void setCriticismPool(String[] criticismPool)
{
this.criticismPool = criticismPool;
}
}
CriticismEngineImpl实现了CriticismEngine接口,通过从注入的评论池中随机选择一个苛刻的评论
使用XML声明Spring bean:
<bean id = "criticismEngine"
class = "com.springinaction.springidol.CriticismEngineImpl">
<property name = "criticisms">
<list>
<value>Worst performance ever!</value>
<value>I laughed, I cried, then I realized I was at the wrong show.</value>
<value>A must see show!</value>
</list>
</property>
</bean>
现在有了一个要赋予CriticAspect的Criticism-Engine实现。剩下的就是为CriticAspect装配CriticismEngineImple。在展示如何实现注入之前,必须清楚AspectJ切面根本不需要Spring就可以织入到我们的应用中。如果想使用Spring的依赖注入为AspectJ切面注入协作者,那我们就需要在Spring配置中把切面声明为一个Spring配置中的<bean>。如下的<bean>声明会把criticismEnginebean注入到CriticAspect中:
<bean class= "com.springinaction.springidol.CriticAspect"
factory-method = "aspectOf">
<property name = "criticismEngine" ref = "criticismEngine" />
</bean>
Spring需要通过aspectOf()工厂方法获得切面的引用,然后像<bean>元素规定的那样在该对象上执行依赖注入
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。