〇、AOP概念
Aspect：切面
给业务方法增加到功能，切面泛指交叉业务逻辑。上例中的事务处理、日志处理就可以理解为切面。常用的切面是通知（Advice）。实际就是对主业务逻辑的一种增强。
Pointcut：切入点
切入点指声明的一个或多个连接点的集合，通过切入点指定一组方法。被标记为 final 的方法是不能作为连接点与切入点的。因为最终的是不能被修改的，不能被增强的。
Advice：通知、增强
通知表示切面的执行时间，Advice也叫增强。换个角度来说，通知定义了增强代码切入到目标代码的时间点，是目标方法执行之前执行，还是之后执行等。通知类型不同，切入时间不同。
JoinPoint：连接点
连接切面的业务方法，连接点指可以被切面织入的具体方法。通常业务接口中的方法均为连接点。
Target：目标对象
目标对象指将要被增强的对象。即包含主业务逻辑的类的对象。
AOP中重要的三个要素：Aspect、Pointcut、Advice
意思是说：在Advice的时间、在Pointcut的位置，执行Aspect。
为了方便大家理解AOP中的相关概念，请见下图所示：
一、动态AOP的使用示例
当我们对某些类有横切性的逻辑时，为了不破坏目标类，我们则可以使用AOP的方式将增强逻辑注入到目标类上。为了更清晰的了解AOP的用法，下面我们通过一个使用案例，实现一下面向切面编程。
首先，我们创建一个普通的业务类MuseAop
public class MuseAop {
public void goToWork() {
System.out.println("Muse去上班");
}
}其次，创建Advisor，然后对MuseAop的goToWork()方法进行增强操作
@Aspect
public class MuseAspectJ {
@Pointcut("execution(* *.goToWork(..))")
public void goToWork() {}
@Before("goToWork()")
public void beforeGoToWork() {
System.out.println("@Before：起床、洗漱、穿衣");
}
@After("goToWork()")
public void afterGoToWork() {
System.out.println("@After：开始工作了");
}
@SneakyThrows
@Around("goToWork()")
public Object aroundGoToWork(ProceedingJoinPoint point) {
System.out.println("@Around-1：听一首摇滚歌曲提提神");
Object result = point.proceed();
System.out.println("@Around-2：听一首钢琴乐舒缓情绪");
return result;
}
}然后，在配置文件中添加bean，并且通过配置 <aop:aspectj-autoproxy /> 来开启aop动态代理
<aop:aspectj-autoproxy />
<bean id="museAop" class="com.muse.springbootdemo.entity.aop.MuseAop"/>
<bean class="com.muse.springbootdemo.entity.aop.MuseAspectJ"/>最后，编写测试类，查看测试结果
二、动态AOP自定义标签
根据上面我们使用AOP的示例，我们可以看到是通过配置<aop:aspectj-autoproxy>来开启动态代理的，因此我们可以将它为AOP源码分析的切入点。请见下图所示，我们在全项目中搜索了aspectj-autoproxy，然后发现注入了新的BeanDefinitionParser实现类—— AspectJAutoProxyBeanDefinitionParser
那么下面，我们来看一下AspectJAutoProxyBeanDefinitionParser类的具体实现，由于AspectJAutoProxyBeanDefinitionParser实现了BeanDefinitionParser接口，而BeanDefinitionParser只有一个方法，即：parse(element, parserContext)，所以，我们来看一下AspectJAutoProxyBeanDefinitionParser 类是如何实现parse方法的。
下面，我们先看一下AopNamespaceUtils类的registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element)方法的具体实现逻辑。
2.1> registerAspectJAnnotationAutoProxyCreatorIfNecessary方法解析
该方法是用于注册或者升级AnnotationAwareAspectJAutoProxyCreator类型的APC，对于AOP的实现，基本都是在AnnotationAwareAspectJAutoProxyCreator类中完成的，它可以根据@Point注解定义的切点来自动代理相匹配的bean。但是为了配置简便，Spring使用了自定义配置来帮助我们自动注册AnnotationAwareAspectJAutoProxyCreator，注册流程如下所示：
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}AUTO_PROXY_CREATOR_BEAN_NAME（“org.springframework.aop.config.internalAutoProxyCreator”）的作用是内部管理的自动代理创建器的bean名称。如果名称为“AUTO_PROXY_CREATOR_BEAN_NAME”的apc实例在容器中已经存在，则试图替换为该bean为AnnotationAwareAspectJAutoProxyCreator类型；否则，在容器中创建AnnotationAwareAspectJAutoProxyCreator类型的APC实例。
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
/** 步骤1：如果容器中已经存在apc实例，则试图替换为AnnotationAwareAspectJAutoProxyCreator类型 */
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) apcDefinition.setBeanClassName(cls.getName());
}
return null;
}
/** 步骤2：如果不存在，则向容器中创建AnnotationAwareAspectJAutoProxyCreator类型的apc实例对象 */
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}2.1.1> 关于APC优先级别的补充说明
APC的抽象类AbstractAdvisorAutoProxyCreator默认有4个实现类，如下所示：
我们可以通过AopConfigUtils.findPriorityForClass(...)方法来获得当前APC实现类的优先级别，数字越大，优先级别越高。这个优先级，其实就是ArrayList中存储的APC实现类的index序号。源码请见下图所示：
/** 默认初始化3个APC（AutoProxyCreator）实现类 */
private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<>(3);
static {
APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class); // 第0级别
APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class); // 第1级别
APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class); // 第2级别
}
/** 通过Class获得优先级别 */
private static int findPriorityForClass(Class<?> clazz) {
return APC_PRIORITY_LIST.indexOf(clazz);
}
/** 通过className获得优先级别 */
private static int findPriorityForClass(@Nullable String className) {
for (int i = 0; i < APC_PRIORITY_LIST.size(); i++) {
Class<?> clazz = APC_PRIORITY_LIST.get(i);
if (clazz.getName().equals(className)) return i;
}
}【第0级别】InfrastructureAdvisorAutoProxyCreator
【第1级别】AspectJAwareAdvisorAutoProxyCreator
【第2级别】AnnotationAwareAspectJAutoProxyCreator
2.2> useClassProxyingIfNecessary方法解析
步骤1：获得属性PROXY_TARGET_CLASS_ATTRIBUTE（“proxy-target-class”）
如果
proxy-target-class等于true，才会执行AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry)方法；
步骤2：属性EXPOSE_PROXY_ATTRIBUTE（“expose-proxy”）
如果
expose-proxy等于true，才会执行AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry)方法；
useClassProxyingIfNecessary()方法源码如下所示：
private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement {
if (sourceElement != null) {
// 设置参数proxy-target-class
boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
if (proxyTargetClass) AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
// 设置参数expose-proxy
boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
if (exposeProxy) AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}这两个方法逻辑基本一致的，就是首先判断是否存在名字为AUTO_PROXY_CREATOR_BEAN_NAME的BeanDefinition实例对象，如果存在的话，将该对象的属性proxyTargetClass或者属性exposeProxy赋值为true即可。
/** 将definition的proxyTargetClass属性设置为true */
public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
}
}
/** 将definition的exposeProxy属性设置为true */
public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
}
}proxyTargetClass属性的作用是什么？
<aop:config proxy-target-class="true"> ：配置为强制使用
CGLIB代理
<aop:aspectj-autoproxy proxy-target-class="true"/> ：配置为CGLIB代理+@AspectJ自动代理支持
exposeProxy属性的作用是什么？
<aop:aspectj-autoproxy export-proxy="true"/> ：支持通过
AopContext.currentProxy()来暴露当前代理类。
exposeProxy场景举例：
public interface AService {
public void a();
public void b();
}
@Service
public class AserviceImpl implements AService {
@Transactional(propagation = Propagation.REQUIRED)
public void a() {
this.b(); // 由于this指向target对象，所以不会执行b事务切面
((AService) AopContext.currentProxy()).b(); // 暴露了当前的代理类，所以可以执行b事务切面
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void b() {}
}三、创建AOP代理
通过上面的介绍，我们可以看到AOP在极力的创建AnnotationAwareAspectJAutoProxyCreator对象作为APC的bean实例：
既然是这样的，那我们就来看一下AnnotationAwareAspectJAutoProxyCreator类的继承结构，请见下图所示：
从上图中我们可以看到它实现了BeanPostProcessor接口，那么这个接口里有我们熟悉的postProcessAfterInitialization(...)方法，该方法是由AbstractAutoProxyCreator类实现的，源码请见如下所示：
下面真正执行对bean增强的方法就是wrapIfNecessary(...)了，在这里有如下几种情况是不需要增加的：
【情况1】targetSourcedBeans中保存的是已经处理过的bean，如果在其中，则不需要增强；
【情况2】advisedBeans中value值为false表示不需要增强；
【情况3】基础设施类（实现Advices、Pointcut、Advisors、AopInfrastructureBeans这四个接口的类），则不需要增强；
【情况4】如果是Original实例（以beanClass.getName()开头，并且以".ORIGINAL"结尾），则不需要增强；
在wrapIfNecessary(...)方法中，主要有两个重要的方法：getAdvicesAndAdvisorsForBean(...) 和 createProxy(...) ，后续我们会针对这两个方法进行解析。
根据上面的描述，我们可以知道getAdvicesAndAdvisorsForBean(...)方法就是用来获得增强器的方法了，这里通过调用findEligibleAdvisors(beanClass, beanName)方法来获得增强器列表，并进行结果返回；如果没有获得增强器，则返回DO_NOT_PROXY（其值为null），其源码如下所示：
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
/** 寻找增强列表 */
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) return DO_NOT_PROXY;
return advisors.toArray();
}Eligible的英文翻译是“符合条件的”，那么findEligibleAdvisors(...)方法的主要作用就是——找到符合条件的增强器，具体操作有如下两步：
【步骤1】通过调用
findCandidateAdvisors(...)方法，获取所有的增强；
【步骤2】通过调用findAdvisorsThatCanApply(...)方法，寻找所有增强中适用于bean的增强并进行应用；
相关源码，请见如下所示：
3.1> findCandidateAdvisors()获取所有增强器
在findCandidateAdvisors()方法中，我们可以获得所有增强器，此处一共执行了两个步骤来获得所有增强器：
【步骤1】获得xml中配置的AOP声明;
【步骤2】获得带有aspectj注释的AOP声明;
如下就是findCandidateAdvisors()方法的相关源码：
3.1.1> findCandidateAdvisors() 获得xml中配置的AOP声明
protected List<Advisor> findCandidateAdvisors() {
return this.advisorRetrievalHelper.findAdvisorBeans();
}在findAdvisorBeans()方法中我们可以看到，如下逻辑：
【步骤1】首先，尝试从缓存（
cachedAdvisorBeanNames）中获得Advisor类型的bean名称列表。
【步骤2】如果没有获得到，则试图去IOC容器中获得所有Advisor类型的bean名称列表。
【步骤3】如果都没有获得Advisor类型的bean名称列表，则直接返回空集合。
【步骤4】如果不为空，则通过beanFactory.getBean(name, Advisor.class)来获得Advisor实例集合，并进行返回。
如下就是findAdvisorBeans()方法的相关源码：
public List<Advisor> findAdvisorBeans() {
//【步骤1】获得所有被缓存的Advisor的bean名称列表
String[] advisorNames = this.cachedAdvisorBeanNames;
//【步骤2】如果缓存中没有，那么我们就从BeanFactoryUtils中获得Advisor的bean名称列表，然后作为已缓存的bean名称列表
if (advisorNames == null) {
//【官方注释】这里不要初始化FactoryBeans:我们需要保留所有未初始化的常规bean，以便让自动代理创建器应用于它们!
// 返回容器中所有Advisor类型的bean名称列表
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
this.cachedAdvisorBeanNames = advisorNames;
}
//【步骤3】如果缓存也没有并且从从BeanFactoryUtils中也没获得到，则直接返回空集合
if (advisorNames.length == 0) return new ArrayList<>();
//【步骤4】从IOC容器中获得Advisor对象实例集合，并返回
List<Advisor> advisors = new ArrayList<>();
for (String name : advisorNames) {
if (isEligibleBean(name)) {
if (this.beanFactory.isCurrentlyInCreation(name))
if (logger.isTraceEnabled()) logger.trace("Skipping currently created advisor '" + name + "'");
else {
try {
advisors.add(this.beanFactory.getBean(name, Advisor.class));
} catch (BeanCreationException ex) { ... ... }
}
}
}
return advisors;
}3.1.2> buildAspectJAdvisors() 获得带有aspectj注释的AOP声明
在buildAspectJAdvisors()方法中，主要逻辑有四个步骤：
【步骤1】获得Aspect的
beanName列表；
【步骤2】通过beanName来获得MetadataAwareAspectInstanceFactory实例，具体如下所示：如果per-clauses(aspect实例化模式) 类型等于SINGLETON，则创建BeanFactoryAspectInstanceFactory类型的factory；否则，则创建PrototypeAspectInstanceFactory类型的factory；
【步骤3】通过调用advisorFactory.getAdvisors(factory)来获得Advisor列表；
【步骤4】维护advisorsCache缓存或aspectFactoryCache缓存；如果beanName是单例的，则将beanName和Advisor列表维护到advisorsCache缓存中；否则，将beanName和factory维护到aspectFactoryCache缓存中；
在buildAspectJAdvisors()方法中，源码及注释如下所示：
public List<Advisor> buildAspectJAdvisors() {
// 获得已经解析过的Aspect的beanName列表
List<String> aspectNames = this.aspectBeanNames;
// 步骤1：如果aspectNames为空，则试图从IOC中解析出Aspect的beanName列表
if (aspectNames == null) {
synchronized (this) { // 加锁
aspectNames = this.aspectBeanNames; // double check
if (aspectNames == null) {
List<Advisor> advisors = new ArrayList<>();
aspectNames = new ArrayList<>();
// 获得IOC容器中所有的beanName
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
for (String beanName : beanNames) {
if (!isEligibleBean(beanName)) continue; // isEligibleBean方法默认返回true
// 官方注释：我们必须小心不要急切地实例化bean，因为在这种情况下，它们将被Spring容器缓存，但不会被织入
Class<?> beanType = this.beanFactory.getType(beanName, false);
if (beanType == null) continue;
// 一个类如果包含@Aspect注解并且不是被ajc编译的类，则返回true
if (this.advisorFactory.isAspect(beanType)) {
aspectNames.add(beanName);
AspectMetadata amd = new AspectMetadata(beanType, beanName);
if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
// 单例则创建BeanFactoryAspectInstanceFactory类型的factory
MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
if (this.beanFactory.isSingleton(beanName))
this.advisorsCache.put(beanName, classAdvisors); // 缓存Advisor
else
this.aspectFactoryCache.put(beanName, factory); // 缓存MetadataAwareAspectInstanceFactory
advisors.addAll(classAdvisors);
} else {
if (this.beanFactory.isSingleton(beanName)) {
throw new IllegalArgumentException("Bean with name '" + beanName +
"' is a singleton, but aspect instantiation model is not singleton");
}
// 非单例则创建PrototypeAspectInstanceFactory类型的factory
MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
this.aspectFactoryCache.put(beanName, factory); // 缓存MetadataAwareAspectInstanceFactory
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
}
this.aspectBeanNames = aspectNames;
return advisors; // 将解析好的Advisor列表执行返回操作
}
}
}
if (aspectNames.isEmpty()) return Collections.emptyList();
// 步骤2：如果没有“经历过”步骤1，则再次处解析Advisor列表
List<Advisor> advisors = new ArrayList<>();
for (String aspectName : aspectNames) {
List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
if (cachedAdvisors != null) // 情况1：如果在advisorsCache缓存中存在，则直接返回Advisor列表
advisors.addAll(cachedAdvisors);
else { // 情况2：如果在aspectFactoryCache缓存中存在，则需要调用factory的getAdvisors方法来获得Advisor列表
MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
return advisors;
}在上面的源码中，我们可以发现，其中通过advisorFactory.getAdvisors(factory) 来获得Advisor集合是非常核心的代码，因为只有它才能帮助我们获得Advisor列表，部分截取代码如下所示：
advisorFactory.getAdvisors(factory)方法的源码如下所示：
3.1.3> getAdvisor(...) 获得普通增强器
getAdvisor(...)方法的源码如下所示：
a> 步骤1：获得切点表达式的相关信息
下面我们来看一下步骤1中的获得切点表达式的相关信息的getPointcut(...)方法源码逻辑：
方法上的AspectJ相关注解（AspectJAnnotation），查找注解的顺序按照：@Pointcut——>@Around——>@Before——>@After——>@AfterReturning——>@AfterThrowing ，如果找到了某个注解，则直接返回AspectJAnnotation实例对象，不需要继续寻找了。
b> 步骤2：根据切点信息生成增强
我们可以看到，在步骤2中，是通过创建一个InstantiationModelAwarePointcutAdvisorImpl实例对象来生成切点的增强的，源码如下所示：
在getAdvice方法中，我们根据上面解析出的方法上面使用的AspectJ注解来生成相应的AbstractAspectJAdvice，代码如下所示：
public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder,
String aspectName) {
Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass(); // 获得切面类
validate(candidateAspectClass);
// 获得切面上的AspectJ相关注解
AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
if (aspectJAnnotation == null) return null; // 如果没有AspectJ相关注解，那么直接返回null即可
// 如果类上有@Aspect注解 并且 该类是被AspectJ编译的，则直接抛出异常
if (!isAspect(candidateAspectClass))
throw new AopConfigException("Advice must be declared inside an aspect type: Offending method '" +
candidateAdviceMethod + "' in class [" + candidateAspectClass.getName() + "]");
// 根据不同的AspectJ相关注解，生成对应不同的springAdvice的实例对象
AbstractAspectJAdvice springAdvice;
switch (aspectJAnnotation.getAnnotationType()) {
case AtPointcut: // @Pointcut
return null;
case AtAround: // @Around
springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtBefore: // @Before
springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfter: // @After
springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtAfterReturning: // @AfterReturning
springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
if (StringUtils.hasText(afterReturningAnnotation.returning()))
springAdvice.setReturningName(afterReturningAnnotation.returning());
break;
case AtAfterThrowing: // @AfterThrowing
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);
}
// 为springAdvice实例对象赋值
springAdvice.setAspectName(aspectName);
springAdvice.setDeclarationOrder(declarationOrder);
String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
if (argNames != null) springAdvice.setArgumentNamesFromStringArray(argNames);
springAdvice.calculateArgumentBindings();
return springAdvice;
}3.1.4> new SyntheticInstantiationAdvisor(...) 创建同步实例化增强器
如果寻找的增强器不为空而且又配置了增强延迟初始化，那么就需要在首位加入同步实例化增强器。同步实例化增强器SyntheticlnstantiationAdvisor源码如下所示：
3.1.5> getDeclareParentsAdvisor(field) 获得@DeclareParents配置的增强器
DeclareParents主要用于引介增强的注解形式的实现，如果属性上使用了@DeclareParents注解，那么我们就来创建DeclareParentsAdvisor类型的增强器，其中关于@DeclareParents注解的使用场景，请参照3.1.6部分即可，源码如下所示：
private Advisor getDeclareParentsAdvisor(Field introductionField) {
// 获得属性上使用了@DeclareParents注解的注解类
DeclareParents declareParents = introductionField.getAnnotation(DeclareParents.class);
if (declareParents == null) return null;
if (DeclareParents.class == declareParents.defaultImpl()) throw new IllegalStateException(...);
// 创建DeclareParentsAdvisor类型的增强器
return new DeclareParentsAdvisor(introductionField.getType(), declareParents.value(), declareParents.defaultImpl());
}3.1.6> @DeclareParents注解的使用
创建接口IPay和实现类OnlinePay
public interface IPay {
void pay();
}@Service
public class OnlinePay implements IPay {
@Override
public void pay() {
System.out.println("-------OnlinePay--------");
}
}创建接口IPayPlugin和实现类AlipayPlugin
public interface IPayPlugin {
void payPlugin();
}@Service
public class AlipayPlugin implements IPayPlugin {
@Override
public void payPlugin() {
System.out.println("-------Alipay--------");
}
}使用@DeclareParents注解配置切面。该注解的作用是：可以在代理目标类上增加新的行为（即：新增新的方法）。
@Aspect
@Component
public class PayAspectJ {
@DeclareParents(value = "com.muse.springbootdemo.entity.aop.IPay+",defaultImpl = AlipayPlugin.class)
public IPayPlugin alipayPlugin;
}创建配置类MuseConfig，开启AspectJ的自动代理，然后就会为使用@Aspect注解的bean创建一个代理类。
@Configuration
@ComponentScan
@EnableAspectJAutoProxy
public class MuseConfig {
}进行测试，我们发现从IOC中获得的bean实现了IPay和IPayPlugin这两个接口，并且会在后台输出“-------OnlinePay--------”和“-------Alipay-------”
3.2> findAdvisorsThatCanApply(...)寻找匹配的增强器
在3.1中，我们已经分析完获取所有增强器的方法findCandidateAdvisors()，那么本节我们将在获取的所有增强（candidateAdvisors）基础上，再去寻找匹配的增强器，即：findAdvisorsThatCanApply(...)方法，相关源码如下图所示：
在findAdvisorsThatCanApply(...)方法中，其主要功能是获得所有增强器candidateAdvisors中，适用于当前clazz的增强器列表。而由于针对引介增强和普通增强的处理是不同的， 所以采用分开处理的方式，请见下图所示：
那么，什么是引介增强呢？ 引介增强是一种特殊的增强，其它的增强是方法级别的增强，即只能在方法前或方法后添加增强。而引介增强则不是添加到方法上的增强， 而是添加到类级别的增强，即：可以为目标类动态实现某个接口，或者动态添加某些方法。具体实现请见下图所示：
那么，在上面的findAdvisorsThatCanApply(...)方法源码中，我们可以发现，canApply(...)方法是其中很重要的判断方法，那么它内部主要做了什么操作呢？在其方法内部，依然根据引介增强和普通增强两种增强形式分别进行的判断，其中，如果是引介增强的话，则判断该增强是否可以应用在targetClass上，如果可以则返回true，否则返回false。那么，如果是普通增强，则需要再调用canApply(...)方法继续进行逻辑判断，相关源码请见下图所示：
在canApply(...)方法中，主要是逻辑是获得 targetClass类（非代理类） 及 targetClass类的相关所有接口 中的所有方法去匹配，是否满足对targetClass类的增强，如果找到了，则返回false；如果找不到，则返回true；相关源码，请见下图所示：
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
// 如果Pointcut不能应用于targetClass类上，则直接返回false
if (!pc.getClassFilter().matches(targetClass)) return false;
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) return true;
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
if (methodMatcher instanceof IntroductionAwareMethodMatcher)
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
Set<Class<?>> classes = new LinkedHashSet<>();
if (!Proxy.isProxyClass(targetClass)) classes.add(ClassUtils.getUserClass(targetClass)); // 只添加非代理类
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass)); // 添加targetClass的所有接口类
// 遍历所有相关类的所有方法，只要有与targetClass匹配的方法，则返回ture
for (Class<?> clazz : classes) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
if (introductionAwareMethodMatcher != null ?
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
return false;
}3.3> createProxy(...) 创建AOP代理
在3.1和3.2章节中，我们介绍了如何获取bean所对应的Advisor增强器，那么，下面我们就该开始利用这些增强器去配合创建代理对象了，这部分工作由createProxy()方法负责，源码如下所示：
/** 为beanClass创建AOP代理 */
protected Object createProxy(Class<?> beanClass, String beanName, Object[] specificInterceptors,
TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory)
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory,
beanName, beanClass);
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this); // 将当前对象中的信息复制到proxyFactory实例中
// 调用proxyFactory.setProxyTargetClass(...)用于设置是否应该使用targetClass而不是它的接口代理
// 调用proxyFactory.addInterface(...)用于添加代理接口
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) proxyFactory.setProxyTargetClass(true);
else evaluateProxyInterfaces(beanClass, proxyFactory);
}
/** 3.3.1> 获得所有增强器 */
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors); // 添加增强器集合
proxyFactory.setTargetSource(targetSource); // 设置被代理的类
customizeProxyFactory(proxyFactory); // 定制代理（空方法）
proxyFactory.setFrozen(this.freezeProxy); // 默认false，表示代理被配置后，就不允许修改它的配置了
if (advisorsPreFiltered()) proxyFactory.setPreFiltered(true);
ClassLoader classLoader = getProxyClassLoader();
if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader())
classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
/** 3.3.2> 获得代理对象 */
return proxyFactory.getProxy(classLoader);
}
从上面的源码我们可以整理出
createProxy(...)方法的操作流程：
【步骤1】创建ProxyFactory实例对象，后续会对其各个参数进行初始化赋值，为最后调用proxyFactory的getProxy(...)方法做准备；
【步骤2】将当前对象（this）中的部分信息复制到proxyFactory实例中；
【步骤3】调用proxyFactory.setProxyTargetClass(...)用于设置是否应该使用targetClass而不是它的接口代理；
【步骤4】调用proxyFactory.addInterface(...)用于添加代理接口；
【步骤5】获得所有增强器Advisor并添加到proxyFactory中；
【步骤6】向proxyFactory中设置被代理的类；
【步骤7】可以对proxyFactory进行定制化操作，默认是空方法；
【步骤8】通过调用proxyFactory的setFrozen(...)方法，来控制代理工厂被配置之后，是否还允许修改通知；
【步骤9】调用proxyFactory的getProxy(...)方法获得代理对象。
3.3.1> buildAdvisors(...）获得所有增强器
在buildAdvisors(...)方法中，我们可以看到大致做了两个步骤：
【步骤1】获得所有拦截器（普通的+指定的）；
【步骤2】通过这些拦截器生成Advisor增强集合，
buildAdvisors(...)方法中的源码及注释如下所示：
收集拦截器的代码并不复杂，那么下面我们再来看wrap(...)方法是如何通过拦截器生成Advisor增强的，源码及注释请见下图所示：
public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
// 如果待封装的adviceObject本来就是Advisor类型，则直接返回即可
if (adviceObject instanceof Advisor) return (Advisor) adviceObject;
// 如果既不是Advisor类型也不是Advice类型，则直接抛出异常，无法执行包装操作
if (!(adviceObject instanceof Advice)) throw new UnknownAdviceTypeException(adviceObject);
Advice advice = (Advice) adviceObject;
// 如果adviceObject是MethodInterceptor类型，则包装成DefaultPointcutAdvisor实例对象
if (advice instanceof MethodInterceptor) return new DefaultPointcutAdvisor(advice);
// 遍历适配器列表adapters，如果也支持advice，则包装成DefaultPointcutAdvisor实例对象
for (AdvisorAdapter adapter : this.adapters)
if (adapter.supportsAdvice(advice)) return new DefaultPointcutAdvisor(advice);
throw new UnknownAdviceTypeException(advice);
}3.3.2>proxyFactory.getProxy(...) 获得代理对象
通过上面的操作，我们已经获得了增强Advisor列表了，并且也做好了对proxyFactory的赋值准备操作，下面就该到了获得代理对象的步骤了，具体逻辑代码在getProxy(...)方法中，源码如下所示：
a> createAopProxy() 创建AOP代理
创建aop代理的时候，首先激活所有的Listener，然后再去创建AOP代理，这部分代码很少，很好理解，请见如下所示：
在上面代码中，我们需要再继续分析红框内的createAopProxy(this)方法，
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (!NativeDetector.inNativeImage() &&
(config.isOptimize() || // 默认false
config.isProxyTargetClass() || // 默认false
hasNoUserSuppliedProxyInterfaces(config))) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) throw new AopConfigException(...);
// 如果是接口或者是代理类，则使用JDK动态代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass))
return new JdkDynamicAopProxy(config);
// 否则，使用CGlib代理
return new ObjenesisCglibAopProxy(config);
}
else return new JdkDynamicAopProxy(config); // 使用JDK动态代理
}isOptimize() ：用来控制通过CGLIB创建的代理是否使用激进的优化策略。除非完全了解AOP代理如何处理优化，否则不推荐用户使用这个设置。目前这个属性仅用于CGLIB代理，对于JDK动态代理（默认代理）无效。
isProxyTargetClass() ：这个属性为true时，目标类本身被代理而不是目标类的接口。如果这个属性值被设为true, CGLIB代理将被创建，设置方式为：<aop:aspectj-autoproxy-proxy-target-class＝"true"/>。
hasNoUserSuppliedProxyInterfaces(config) ：是否存在代理接口。
通过createAopProxy(config)方法，根据不同情况，会返回不同代理对象，在下面内容中，我们会分别分析不同代理对象的代理流程：
如果采用JDK动态代理，则返回
JdkDynamicAopProxy代理对象；
如果采用CGlib代理，则返回ObjenesisCglibAopProxy代理对象；
b> JdkDynamicAopProxy.getProxy(classLoader) 获得代理对象
我们先来看一下JdkDynamicAopProxy类对getProxy(...)方法的实现，我们发现，里面只调用了Proxy.newProxyInstance(...)方法，源码如下所示：
public Object getProxy(@Nullable ClassLoader classLoader) {
return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
}自己编写过JDK动态代理的朋友应该对getProxy(...)方法中的内容并不陌生，它的编写结构如下所示：
概括来说就是3点：
【第1点】要实现InvocationHandler接口；
【第2点】重写invoke方法；
【第3点】通过调用Proxy.newProxyInstance(...)获得代理对象；
那么我们再来看JdkDynamicAopProxy类，它也实现了InvocationHandler接口，即：满足了第1点；
那么就剩下第2点，即：重写invoke方法了，我们把目光注视到JdkDynamicAopProxy类的invoke方法，看看它是如何实现的：
将拦截器封装到ReflectiveMethodInvocation类中，并通过调用proceed方法逐一调用拦截器，下面是proceed源码内容：
public Object proceed() throws Throwable {
// 执行完所有增强后执行切点方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1)
return invokeJoinpoint();
// 获取下一个要执行的拦截器
Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
// 动态匹配
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments))
return dm.interceptor.invoke(this); // 调用拦截器
else
return proceed(); // 不匹配不调用拦截器
}
// 普通拦截器，直接调用拦截器即可
else return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); // 将this作为参数传递以保证当前实例中调用链的执行
}在
proceed方法中，或许代码逻辑并没有我们想象得那么复杂，ReflectiveMethodlnvocation中的主要职责是维护了链接调用的计数器，记录着当前调用链接的位置，以便链可以有序地进行下去，那么在这个方法中并没有我们之前设想的维护各种增强的顺序，而是将此工作委托给了各个增强器，使各个增强器在内部进行逻辑实现。
c> ObjenesisCglibAopProxy.getProxy(classLoader) 获得代理对象
上面介绍完JDK动态代理之后，我们下面来介绍Cglib动态代理是如果获得代理对象的。对于Cglib大家一定不会陌生，下面我们就手写一下通过Cglib获得代理对象的示例，请见如下代码所示：
public class CGlibTest {
public static void main(String[] args) {
// 创建增强器
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(CGlibTest.class);
enhancer.setCallback(new MyMethodInterceptor());
// 通过增强器，获得CGlib代理对象
CGlibTest test = (CGlibTest) enhancer.create();
test.play();
}
public void play() {
System.out.println("play game!");
}
}
/**
* 创建GClib拦截器
*/
class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("-----------------preExecutor-----------------");
Object result = methodProxy.invokeSuper(o, objects);
System.out.println("-----------------afterExecutor-----------------");
return result;
}
}
重温了cglib动态代理之后，我们来看Spring AOP是如何通过它来获得代理的，此处我们来看一下ObjenesisCglibAopProxy类的getProxy(...)方法是如何实现的：
public Object getProxy(@Nullable ClassLoader classLoader) {
try {
Class<?> rootClass = this.advised.getTargetClass();
Class<?> proxySuperClass = rootClass;
// 如果类名中包含"$$"
if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
proxySuperClass = rootClass.getSuperclass();
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
for (Class<?> additionalInterface : additionalInterfaces)
this.advised.addInterface(additionalInterface);
}
// 针对类进行验证操作
validateClassIfNecessary(proxySuperClass, classLoader);
// 创建Cglib的Enhancer并对其进行配置操作
Enhancer enhancer = createEnhancer();
if (classLoader != null) {
enhancer.setClassLoader(classLoader);
if (classLoader instanceof SmartClassLoader && ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass))
enhancer.setUseCache(false);
}
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
/** 设置拦截器 */
Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) types[x] = callbacks[x].getClass();
enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
// 生成代理类并创建代理实例对象
return createProxyClassAndInstance(enhancer, callbacks);
}
catch (CodeGenerationException | IllegalArgumentException ex) {...}
}
/** 创建代理对象 */
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
enhancer.setInterceptDuringConstruction(false);
enhancer.setCallbacks(callbacks);
return (this.constructorArgs != null && this.constructorArgTypes != null ?
enhancer.create(this.constructorArgTypes, this.constructorArgs) : // 采用有参构造函数创建实例对象
enhancer.create()); // 采用无参构造函数创建实例对象
}通过上面的代码，我们可以大致了解getProxy方法的处理逻辑分为3个步骤：
【步骤1】创建Enhancer实例对象，并对其进行初始化；
【步骤2】获得Callback拦截器，并赋值到Enhancer实例对象中；
【步骤3】通过Enhancer实例对象的create(...)方法来创建代理对象；
由于我们手工创建过Cglib动态代理了，所以对于上述步骤都会比较熟悉，但是对于第二步获得拦截器，我们还是比较陌生的，那么我们就来着重分析一下这个方法，其源码如下所示：
private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
// Parameters used for optimization choices...
boolean exposeProxy = this.advised.isExposeProxy();
boolean isFrozen = this.advised.isFrozen();
boolean isStatic = this.advised.getTargetSource().isStatic();
// 步骤1：创建aopInterceptor拦截器
Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
// 步骤2：创建targetInterceptor拦截器
Callback targetInterceptor;
if (exposeProxy) targetInterceptor = (isStatic ?
new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
else targetInterceptor = (isStatic ?
new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));
// 步骤3：创建targetDispatcher调度器
Callback targetDispatcher = (isStatic ?
new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());
// 步骤4：将不同的拦截器或调度器都保存到Callback数组中
Callback[] mainCallbacks = new Callback[] {
aopInterceptor, // 用于一般的增强器
targetInterceptor, // 如果被优化了，调用target而不考虑调用增强
new SerializableNoOp(), // 映射到this的方法不能重写
targetDispatcher,
this.advisedDispatcher,
new EqualsInterceptor(this.advised),
new HashCodeInterceptor(this.advised)
};
// 步骤5：如果目标是静态的并且Advice链是冻结的，那么我们可以通过使用该方法的固定链直接将AOP调用发送到目标来进行一些优化。
Callback[] callbacks;
if (isStatic && isFrozen) {
Method[] methods = rootClass.getMethods();
Callback[] fixedCallbacks = new Callback[methods.length];
this.fixedInterceptorMap = CollectionUtils.newHashMap(methods.length);
for (int x = 0; x < methods.length; x++) {
Method method = methods[x];
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
this.fixedInterceptorMap.put(method, x);
}
// callbacks = mainCallbacks + fixedCallbacks;
callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
this.fixedInterceptorOffset = mainCallbacks.length;
}
else
callbacks = mainCallbacks; // callbacks = mainCallbacks;
return callbacks;
}从上面我们自定义演示Cglib例子中可以看到，通过enhancer.setCallback(new MyMethodInterceptor())这段代码，可以将我们自定义的拦截器注入到增强中，那么，在上面源码中，我们在步骤1中将advised保存到DynamicAdvisedInterceptor中，并在下面的步骤里，将其保存到Callback数组中，那么，当执行Cglib代理调用的时候，就会调用DynamicAdvisedInterceptor类中的intercept(...)方法了，代码如下所示：
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Object target = null;
TargetSource targetSource = this.advised.getTargetSource();
try {
if (this.advised.exposeProxy) {
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
// 获取拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// 没有拦截链，直接调用原方法即可
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
}
else // 调用拦截链
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) targetSource.releaseTarget(target);
if (setProxyContext) AopContext.setCurrentProxy(oldProxy);
}
}今天的文章内容就这些了：
写作不易，笔者几个小时甚至数天完成的一篇文章，只愿换来您几秒钟的 点赞 & 分享 。
更多技术干货，欢迎大家关注公众号“爪哇缪斯” ~ \(^o^)/ ~ 「干货分享，每天更新」
