Aop的执行原理,我们应该基本都了解:通过编写切面类,我们可以在指定的切入点处插入我们额外的代码块,就好比代理模式中,我们可以在执行目标方法的前后干一些自己想干的事情。那么这是怎么样实现的呢?
我们自己写的类中的代码是硬编码写死的,要想改变一个已经写好的类,我们常见的操作就是动态代理了,没错,AOP的底层就是将切入点所在的类创建成了代理对象。
我们知道Spring中的一个主要功能就是管理所有的bean对象,在创建对象的时候,为我们提供了很多的扩展点,可以方便我们来干预对象的创建,那么Aop究竟是在哪一个扩展点的地方帮我们创建了代理对象呢?本文就来讲解下从Aop的前置准备到创建代理对象的整个流程。
一、@EnableAspectJAutoProxy
熟悉Spring开发的模式的话,我们都知道,开启一个新的功能的话,我们基本需要在配置类上加上一个@EnableXxx的注解,而这类@EnableXxx的注解多半是向Spring容器中注入了影响bean创建生命周期的bean信息,开启基于注解的Aop的@EnableAspectJAutoProxy注解同样于此,他为我们导入了AnnotationAwareAspectJAutoProxyCreator类的定义信息。我们来看下AnnotationAwareAspectJAutoProxyCreator的继承实现结构图:
AnnotationAwareAspectJAutoProxyCreator结构图.png在整个结构图中,能干预bean的生命周期的是左上角的BeanPostProcessor接口,那么整个AOP功能的具体实现就是在对于InstantiationAwareBeanPostProcessor的方法的具体实现中,就是AbstractAutoProxyCreator类中postProcessBeforeInstantiation方法和postProcessAfterInitialization方法,我们下面就关注它的具体实现:
二、Aop的前置准备
1、AOP基础准备工作
首先,我们来看AbstractAutoProxyCreator类中postProcessBeforeInstantiation方法的具体实现,他实现的接口是InstantiationAwareBeanPostProcessor,而InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation的触发时机是在Spring容器开始准备创建bean之前,Spring给我们提供了一个机会可以自己在这创建对象,而不走Spring的创建对象流程,但是AOP会在此就创建对象吗?我们继续往下看。
我们先看下前半部分代码:
Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {//advisedBeans已经分析过的组件,不是增强过的组件
return null;
}//所有增强了的组件会被缓存在advisedBeans中,如果是我们需要增强的bean,就放在缓存中
//isInfrastructureClass(beanClass):判断当前类是否有@Aspect注解,即当前类是否是切面;shouldSkip中解析了所有的切面类并封装了切面类中的切面方法
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {// shouldSkip:如果是切面类,则跳过处
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
这段代码中主要在管理advisedBeans这个集合,这个集合中key为bean的名称,value为boolean值,个人理解为这个集合的意义是,key表示处理过的beanName,而value值表示这个bean应不应该被增强【不代理】。那什么样的类是不需要增强的呢?这就需要关注if中的两个条件了,一个是isInfrastructureClass(beanClass),另一个是shouldSkip(beanClass, beanName),满足这两个条件之一的都会加入advisedBeans集合,并且标记为不增强;一起来看看这两个方法:
- isInfrastructureClass(beanClass):判断是不是AOP的基础设施类,如果是的话,就加入到advised集合中,并标记为不应该增强,那么究竟什么类是AOP的基础设施类呢?深入到代码里我们发现:分为两大块:一个是实现了Advice,Pointcut,Advisor,AopInfrastructureBean这四个接口的类属于AOP的基础设施类;另一个是这个类上面标注了@Aspect,即切面类
- shouldSkip(beanClass, beanName):这个方法是AOP准备过程中的一个重要点,因为这个方法中干了很多事情,为后面的AOP代理做好了铺垫;代码如下:
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
// TODO: Consider optimization by caching the list of the aspect names
List<Advisor> candidateAdvisors = findCandidateAdvisors();
for (Advisor advisor : candidateAdvisors) {
if (advisor instanceof AspectJPointcutAdvisor &&
((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
return true;
}
}
return super.shouldSkip(beanClass, beanName);
}
整个应不应该跳过的逻辑是:获取所有的Advisor集合,然后遍历Advisor集合,如果当前bean的名称和其中的一个AspectJPointcutAdvisor的aspectName相同,其实就是说明这个类是切面类,那么就会跳过。到这里,我相信有的小伙伴就会发出一个疑问了:前面不是处理过了吗?为什么此处还是需要处理呢?其实这里我也有点疑问,但是它干了更多的事情,那就是创建并缓存了所有的Advisor对象。
在findCandidateAdvisors方法的逻辑中首先是super执行了AbstractAdvisorAutoProxyCreator中的逻辑:找到所有的Advisor的实现类的bean名称,并进行getBean创建对象;其次时寻找@Aspect注解的类,然后为通知方法构建Advisor,整个的构建流程可以归纳如下:
- 拿到容器中所有的bean名称
- 循环遍历beanName,拿到beanType,判断是不是切面类(@Aspect)
- 是切面类的话,就拿到类中除去标有@Pointcut的方法。然后遍历方法:
- 把每个切面方法构建为Advisor【InstantiationModelAwarePointcutAdvisorImpl】
- 处理@DeclareParents属性注解,最终会构建DeclareParentsAdvisor【属于IntroductionAdvisor,类级别的切入】,其中对应的Advice为DelegatePerTargetObjectIntroductionInterceptor【属于IntroductionInterceptor,同样也是MethodInterceptor】
- 缓存进advisorsCache 【beanName--->List<Advisor>】
2、Advice的构建
其中,在构建InstantiationModelAwarePointcutAdvisorImpl中,会构建当前增强方法的Advice,也就是构造方法中的instantiateAdvice方法,最终会调用ReflectiveAspectJAdvisorFactory的getAdvice方法来构建相应的Advice,关键代码如下:
switch (aspectJAnnotation.getAnnotationType()) {
case AtPointcut:
if (logger.isDebugEnabled()) {
logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
}
return null;
case AtAround:
springAdvice = new AspectJAroundAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtBefore:
springAdvice = new AspectJMethodBeforeAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfter:
springAdvice = new AspectJAfterAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfterReturning:
springAdvice = new AspectJAfterReturningAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterReturningAnnotation.returning())) {
springAdvice.setReturningName(afterReturningAnnotation.returning());
}
break;
case AtAfterThrowing:
springAdvice = new AspectJAfterThrowingAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
}
break;
default:
throw new UnsupportedOperationException(
"Unsupported advice type on method: " + candidateAdviceMethod);
}
// Now to configure the advice...
springAdvice.setAspectName(aspectName);
springAdvice.setDeclarationOrder(declarationOrder);
String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
if (argNames != null) {
springAdvice.setArgumentNamesFromStringArray(argNames);
}
springAdvice.calculateArgumentBindings();
最终会把切面类beanName和其中的增强方法Advisor存放到advisorsCache缓存中,方便后面使用。
可以说准备阶段,Spring主要就干了两件事吧:第一件事是标记那些不需要代理的AOP基础设施类;第二件事就是寻找并创建容器中所有的Advisor,这一步也分为两小步:其一,去寻找并创建所有直接实现了Advisor接口的;其二,处理标注了@Aspect注解的类,并将其以aspectName及List<Advisor>的形式缓存到advisorsCache中。
3、Advisor & Advice
有必要介绍下AOP中的Advisor和Advice,这两个东西到底有什么区别和关系呢?Advice就是我们要干预正常代码而额外加的一部分代码逻辑,其实可以理解为拦截器,而Advisor可以说成是对Advice的一种封装吧,因为每个Advisor包含一个Advice,然后Advisor还应该包括Advice增强的增强表达式,即它应该什么时候进行增强,即增强条件吧;在Spring中,提供了两个Advisor的子接口,分别是IntroductionAdvisor和PointcutAdvisor,IntroductionAdvisor提供的getClassFilter()方法和PointcutAdvisor中提供的getPointcut()方法就是各自的增强条件(如下图),从增强条件我们也可以看出:IntroductionAdvisor是基于类级别的增强,而PointcutAdvisor是基于方法级别或者类级别的增强,显然后者方法级别的增强是更加细粒度的,也是我们常用的@Aspect注解的Advisor。如果这么说还是过于抽象的话,那我们拿我们常用的切面类@Aspect来进行来进行类比:
Advisor.png
@Component //切面也是容器中的组件
@Aspect //说明这是切面
public class LogAspect {
public LogAspect() {
System.out.println("LogAspect....");
}
@DeclareParents(value = "com.spring.aop.HelloService", defaultImpl = DeclareParentsTestImpl.class)
private DeclareParentsTest declareParentsTest;
//前置通知
@Before("execution(* com.spring.aop.HelloService.sayHello(..))")
public void logStart(JoinPoint joinPoint) {
String name = joinPoint.getSignature().getName();
System.out.println("logStart()===>" + name + "...【args:" + Arrays.asList(joinPoint.getArgs()) + "】");
}
//返回通知
@AfterReturning(value = "execution(* com.spring.aop.HelloService.sayHello(..))",returning = "result")
public void logReturn(JoinPoint joinPoint,Object result) {
String name = joinPoint.getSignature().getName();
System.out.println("logReturn()==>" + name + "...【args:"+ Arrays.asList(joinPoint.getArgs())+"】【result:"+result+"】");
}
//后置通知
@After("execution(* com.spring.aop.HelloService.sayHello(..))")
public void logEnd(JoinPoint joinPoint) {
String name = joinPoint.getSignature().getName();
System.out.println("logEnd()===>" + name + "...【args:" + Arrays.asList(joinPoint.getArgs()) + "】");
}
//异常通知
@AfterThrowing(value = "execution(* com.spring.aop.HelloService.sayHello(..))",throwing = "e")
public void logError(JoinPoint joinPoint,Exception e) {
String name = joinPoint.getSignature().getName();
System.out.println("logError()==>" + name + "...【args:"+ Arrays.asList(joinPoint.getArgs())+"】【result:"+e+"】");
}
}
像上面logStart,logReturn,logEnd,logError等就可以理解为一个Advice,而@Before,@AfterReturning,@After,@AfterThrowing中的表达式就会说一个Pointcut,然后方法加上注解中的表达式就构成了一个Advisor(PointcutAdvisor),相信这么说,大家应该都能明白了吧。
三、Aop生成代理
Spring提供了两个地方来生成Aop代理对象,下面我们来看看在哪两个地方可以生成Aop的代理对象:
1、Aop生成代理对象的第一个地方
第一个地方是在AbstractAutoProxyCreator的postProcessBeforeInstantiation方法中,Aop的准备工作做完后,就会查看有没有自定义的TargetSource,如果有符合的TargetSource的话就会在此处直接创建bean的代理对象,不会继续走Spring的创建bean的流程,但是,这个地方有个麻烦的点,就是我们需要干预到AnnotationAwareAspectJAutoProxyCreator的创建,需要修改其Bean的定义信息,将我们自定义的TargetSourceCreator赋值给AnnotationAwareAspectJAutoProxyCreator的customTargetSourceCreators属性,我们可以如下操作:
自定义的TargetSource:
public class MyTargetSource implements TargetSource {
private final Object target;
public MyTargetSource(Object target) {
this.target = target;
}
@Override
public Class<?> getTargetClass() {
return HelloService.class;
}
@Override
public boolean isStatic() {
return true;
}
@Override
public Object getTarget() throws Exception {
return target;
}
@Override
public void releaseTarget(Object target) throws Exception {
}
}
封装成TargetSourceCreator:
public class MyTargetSourceCreator implements TargetSourceCreator {
@Override
public TargetSource getTargetSource(Class<?> beanClass, String beanName) {
if (beanName.equals("helloService")) {
try {
return new MyTargetSource(ReflectionUtils.accessibleConstructor(HelloService.class).newInstance());
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
}
实现BeanFactoryPostProcessor修改AnnotationAwareAspectJAutoProxyCreator的bean定义信息:
@Component
public class TargetSourceCreatorBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
BeanDefinition bd = beanFactory.getBeanDefinition(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME); // AnnotationAwareAspectJAutoProxyCreator的beanName
bd.getPropertyValues().add("customTargetSourceCreators",new TargetSourceCreator[]{new MyTargetSourceCreator()});
}
}
如上述配置后,HelloService的对象创建就会在AOP准备工作做好后,通过如下代码,获取到自定义TargetSource后直接创建AOP代理对象,不走这个bean后面的生命周期了:
//创建个代理,如果为这个类指定了targetSource会在此就生成代理直接返回了,不走这个bean后面的生命周期了
TargetSource targetSource = getCustomTargetSource(beanClass, beanName); //
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
2、Aop生成代理对象的第二个地方
另一种情况是,当没有为对象指定自定义的TargetSource时,Spring会在bean的对象创建完成后的AbstractAutoProxyCreator的postProcessAfterInitialization方法中的wrapIfNecessary方法中创建Aop代理对象,代码如下:
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
Object proxy = createProxy(//创建代理对象,specificInterceptors所有的增强器
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
两处创建Aop代理对象的逻辑都是一样的,仅仅是时机不一样罢了,Spring默认使用的是CGLIB来创建代理对象的,具体的创建过程在此就不说了,后续有时间再补上,我们需要知道的是:当我们执行被AOP增强的类时,需要回调DynamicAdvisedInterceptor这个类中的intercept方法,这也是后面我们讲述AOP执行流程的入口。
网友评论