spring-reading./spring-aop/spring-aop-annotationAwareAspectJAutoProxyCreator/README.md

## AnnotationAwareAspectJAutoProxyCreator

- [AnnotationAwareAspectJAutoProxyCreator](#annotationawareaspectjautoproxycreator)
  - [一、基本信息](#一基本信息)
  - [二、基本描述](#二基本描述)
  - [三、主要功能](#三主要功能)
  - [四、类关系图](#四类关系图)
  - [五、最佳实践](#五最佳实践)
  - [六、时序图](#六时序图)
  - [七、源码分析](#七源码分析)

### 一、基本信息

✒️ **作者** - Lex 📝 **博客** - [掘金](https://juejin.cn/user/4251135018533068/posts) 📚 **源码地址** - [github](https://github.com/xuchengsheng/spring-reading)

### 二、基本描述

`AnnotationAwareAspectJAutoProxyCreator`是Spring AOP中的关键类，负责自动检测标记有`@Aspect`注解的切面类，并将其代理到Spring应用程序的bean中，实现切面逻辑的自动织入，从而支持注解驱动的面向切面编程。

### 三、主要功能

1. **自动代理创建** 

   + 检测应用程序上下文中被`@Aspect`注解标记的切面类，并自动创建代理对象，使切面逻辑能够在目标bean的方法调用中被织入。

2. **切面逻辑织入** 

   + 将切面逻辑织入到目标bean的方法调用中，实现例如在方法执行前后、异常抛出时等的切面操作，以实现各种横切关注点的功能。

3. **支持注解驱动的切面编程** 

   + 提供了基于注解的切面编程的支持，通过`@Aspect`等注解，开发者能够更便捷地定义切面类和切面逻辑。

4. **灵活的切面配置** 

   + 允许我们通过注解方式配置切面，而不需要在XML配置文件中显式声明，从而使切面的配置更加灵活和便捷。
   
5. **AOP功能整合** 

   + 将AspectJ切面功能整合到Spring框架中，使得我们能够在Spring应用程序中使用AspectJ风格的切面编程，从而更好地实现横切关注点的模块化和重用。

### 四、类关系图

~~~mermaid
classDiagram
direction BT
class AbstractAdvisorAutoProxyCreator
class AbstractAutoProxyCreator
class AnnotationAwareAspectJAutoProxyCreator
class AopInfrastructureBean {
<<Interface>>

}
class AspectJAwareAdvisorAutoProxyCreator
class Aware {
<<Interface>>

}
class BeanClassLoaderAware {
<<Interface>>

}
class BeanFactoryAware {
<<Interface>>

}
class BeanPostProcessor {
<<Interface>>

}
class InstantiationAwareBeanPostProcessor {
<<Interface>>

}
class ProxyConfig
class ProxyProcessorSupport
class SmartInstantiationAwareBeanPostProcessor {
<<Interface>>

}

AbstractAdvisorAutoProxyCreator  -->  AbstractAutoProxyCreator 
AbstractAutoProxyCreator  ..>  BeanFactoryAware 
AbstractAutoProxyCreator  -->  ProxyProcessorSupport 
AbstractAutoProxyCreator  ..>  SmartInstantiationAwareBeanPostProcessor 
AnnotationAwareAspectJAutoProxyCreator  -->  AspectJAwareAdvisorAutoProxyCreator 
AspectJAwareAdvisorAutoProxyCreator  -->  AbstractAdvisorAutoProxyCreator 
BeanClassLoaderAware  -->  Aware 
BeanFactoryAware  -->  Aware 
InstantiationAwareBeanPostProcessor  -->  BeanPostProcessor 
ProxyProcessorSupport  ..>  AopInfrastructureBean 
ProxyProcessorSupport  ..>  BeanClassLoaderAware 
ProxyProcessorSupport  -->  ProxyConfig 
SmartInstantiationAwareBeanPostProcessor  -->  InstantiationAwareBeanPostProcessor 
~~~

### 五、最佳实践

使用`EnableAspectJAutoProxy`
注解和Spring的基于注解的应用上下文来启用AspectJ自动代理功能。在程序中，首先创建了一个基于注解的应用上下文，然后通过该上下文获取了`MyService`
bean，并调用了其方法。

```java
public class EnableAspectJAutoProxyDemo {

    public static void main(String[] args) {
        // 创建基于注解的应用上下文
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // 从应用上下文中获取MyService bean
        MyService myService = context.getBean(MyService.class);
        // 调用MyService的方法
        myService.foo();
    }
}
```

`AppConfig` 类是一个使用 `@Configuration` 注解标记的配置类，通过 `@EnableAspectJAutoProxy` 开启了 AspectJ
自动代理功能，并通过 `@ComponentScan` 启用了组件扫描，用于自动发现和注册 Spring 组件。

```java

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class AppConfig {

}
```

`MyService` 类是一个使用 `@Service` 注解标记的服务类，提供了一个名为 `foo()` 的方法，该方法在调用时会打印消息 "foo..."。

```java

@Service
public class MyService {

    public void foo() {
        System.out.println("foo...");
    }
}
```

`MyAspect`是一个使用了`@Aspect`注解的Java类，表示它是一个切面。在这个类中，定义了一个名为`advice`的方法，并使用了`@Before`
注解来指定在目标方法执行之前执行的通知。

```java

@Aspect
@Component
public class MyAspect {

    @Before("execution(* com.xcs.spring.MyService+.*(..))")
    public void before() {
        System.out.println("Before method execution");
    }
}
```

运行结果，调用 `MyService` 类的 `foo()` 方法之前，成功地执行了一个切面通知，输出了 "Before method execution"
的消息，然后执行了 `foo()` 方法，输出了 "foo..." 的消息。

```java
Before method
execution
foo...
```

### 六、时序图

~~~mermaid
sequenceDiagram
autonumber
BeanFactory->>AbstractAutoProxyCreator:postProcessAfterInitialization()
Note over BeanFactory,AbstractAutoProxyCreator: BeanFactory调用初始化后处理方法
AbstractAutoProxyCreator->>AbstractAutoProxyCreator:wrapIfNecessary()
Note over AbstractAutoProxyCreator,AbstractAutoProxyCreator: 条件判断与代理创建
AbstractAutoProxyCreator->>AbstractAdvisorAutoProxyCreator:getAdvicesAndAdvisorsForBean()
Note over AbstractAutoProxyCreator,AbstractAdvisorAutoProxyCreator: 获取并返回适用的Advisors数组
AbstractAdvisorAutoProxyCreator->>AbstractAdvisorAutoProxyCreator:findEligibleAdvisors()
Note over AbstractAdvisorAutoProxyCreator,AbstractAdvisorAutoProxyCreator: 查找并扩展可应用的Advisors列表
AbstractAdvisorAutoProxyCreator->>AnnotationAwareAspectJAutoProxyCreator:findCandidateAdvisors()
Note over AbstractAdvisorAutoProxyCreator,AnnotationAwareAspectJAutoProxyCreator: 添加Spring和AspectJ，合并为候选Advisors列表
AnnotationAwareAspectJAutoProxyCreator->>AbstractAdvisorAutoProxyCreator:super.findCandidateAdvisors()
Note over AnnotationAwareAspectJAutoProxyCreator,AbstractAdvisorAutoProxyCreator: 获取自动代理的候选Advisors列表
AbstractAdvisorAutoProxyCreator->>BeanFactoryAdvisorRetrievalHelper:findAdvisorBeans()
Note over AbstractAdvisorAutoProxyCreator,BeanFactoryAdvisorRetrievalHelper: 获取当前bean工厂中所有合格的Advisor beans
AnnotationAwareAspectJAutoProxyCreator->>BeanFactoryAspectJAdvisorsBuilder:buildAspectJAdvisors()
Note over AnnotationAwareAspectJAutoProxyCreator,BeanFactoryAspectJAdvisorsBuilder: 获取AspectJ注解的切面并创建Advisor
AnnotationAwareAspectJAutoProxyCreator->>AbstractAdvisorAutoProxyCreator:返回Advisors
AbstractAdvisorAutoProxyCreator->>AbstractAdvisorAutoProxyCreator:findAdvisorsThatCanApply()
Note over AbstractAdvisorAutoProxyCreator,AbstractAdvisorAutoProxyCreator: 查找适用的候选顾问并设置代理
AbstractAdvisorAutoProxyCreator->>AopUtils:findAdvisorsThatCanApply()
Note over AbstractAdvisorAutoProxyCreator,AopUtils: 筛选适用的顾问并添加到列表。
AopUtils->>AopUtils:canApply(advisor,targetClass,hasIntroductions)
Note over AopUtils,AopUtils: 判断顾问是否适用于目标类。
AopUtils->>AopUtils:canApply(pc,targetClass,hasIntroductions)
Note over AopUtils,AopUtils: 判断切点是否适用于目标类。
AbstractAdvisorAutoProxyCreator->>AspectJAwareAdvisorAutoProxyCreator:extendAdvisors()
Note over AbstractAdvisorAutoProxyCreator,AspectJAwareAdvisorAutoProxyCreator: 添加AspectJ支持到Advisor链。
AspectJAwareAdvisorAutoProxyCreator->>AspectJProxyUtils:makeAdvisorChainAspectJCapableIfNecessary()
Note over AspectJAwareAdvisorAutoProxyCreator,AspectJProxyUtils: 在Advisor链中添加AspectJ支持。
AbstractAdvisorAutoProxyCreator->>AbstractAutoProxyCreator:返回拦截器
AbstractAutoProxyCreator->>AbstractAutoProxyCreator:createProxy()
Note over AbstractAutoProxyCreator,AbstractAutoProxyCreator: 创建 AOP 代理对象的过程。
AbstractAutoProxyCreator->>ProxyFactory:new ProxyFactory()
ProxyFactory->>AbstractAutoProxyCreator:返回proxyFactory
AbstractAutoProxyCreator->>ProxyFactory:getProxy()
ProxyFactory->>AbstractAutoProxyCreator:返回代理对象
AbstractAutoProxyCreator->>BeanFactory:返回代理对象
~~~

### 七、源码分析

在`org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization`方法中，用于在初始化后对bean进行后置处理。它的作用是检查是否需要对bean创建代理，并在需要时使用配置的拦截器创建代理对象，以实现AOP功能。

```java
/**
 * 如果子类确定要将该bean标识为需要代理的bean，则使用配置的拦截器创建代理。
 * @see #getAdvicesAndAdvisorsForBean
 */
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 获取缓存键
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 如果早期代理引用集合中存在该bean，并且不是同一引用，则进行包装
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    // 返回bean
    return bean;
}
```

在`org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary`方法中，首先检查bean的名称是否存在且是否属于目标源bean，如果是，则直接返回原始bean实例；然后检查缓存中是否存在已标记为不需要代理的bean，如果是，则同样直接返回原始bean实例；接着检查bean的类是否为基础结构类或者是否应该跳过该bean，如果是，则将其标记为不需要代理并返回原始bean实例；最后，如果存在通知（拦截器），则创建代理对象并返回，否则同样将其标记为不需要代理并返回原始bean实例。

```java
/**
 * 如果需要，对给定的bean进行包装，即如果它符合被代理的条件。
 * @param bean 原始的bean实例
 * @param beanName bean的名称
 * @param cacheKey 元数据访问的缓存键
 * @return 包装了bean的代理，或者原始的bean实例
 */
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 如果beanName非空，并且该bean已经被目标源bean包含，则直接返回原始的bean实例
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    // 如果缓存中已经存在该bean的标记为不需要代理，则直接返回原始的bean实例
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    // 如果bean的类为基础结构类，或者应该跳过该bean的类，则直接返回原始的bean实例
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 如果存在通知，则创建代理
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    // 没有通知，将bean标记为不需要代理
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}
```

在`org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean`方法中，首先调用`findEligibleAdvisors`方法查找适用于该bean的Advisors，然后将其转换为数组并返回。如果没有找到适用的Advisors，则返回一个特定的标记值`DO_NOT_PROXY`。

```java
/**
 * 获取适用于给定bean的Advisors。
 * @param beanClass bean的类
 * @param beanName bean的名称
 * @param targetSource 目标源
 * @return 包含Advisors的数组，如果没有找到适用的Advisors，则返回DO_NOT_PROXY
 */
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
        Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

    // 查找适用于bean的Advisors
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    // 如果没有找到适用的Advisors，则返回DO_NOT_PROXY
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    // 返回Advisors的数组
    return advisors.toArray();
}
```

在`org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findEligibleAdvisors`方法中，主要用于查找适用于自动代理给定类的所有合适的 Advisors。它首先调用 findCandidateAdvisors 方法来查找候选的 Advisors，然后通过 findAdvisorsThatCanApply 方法筛选出可以应用于当前类的 Advisors。接着，它调用 extendAdvisors 方法来扩展 Advisors 列表，以确保适当的拦截器和通知已被应用。最后，如果有适用的 Advisors，则对 Advisors 列表进行排序并返回；如果没有适用的 Advisors，则返回一个空列表。

```java
/**
 * 查找适用于自动代理该类的所有合格Advisors。
 * @param beanClass 要查找Advisors的类
 * @param beanName 当前代理的bean的名称
 * @return 空列表，非null，如果没有切点或拦截器
 * @see #findCandidateAdvisors
 * @see #sortAdvisors
 * @see #extendAdvisors
 */
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // 查找候选Advisors
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // 查找可应用的Advisors
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    // 扩展Advisors
    extendAdvisors(eligibleAdvisors);
    // 如果有可应用的Advisors，则对Advisors进行排序
    if (!eligibleAdvisors.isEmpty()) {
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}
```

在`org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors`方法中，重写了父类方法 `findCandidateAdvisors()`，首先调用了父类方法以获取所有Spring Advisors，然后利用 `aspectJAdvisorsBuilder` 构建了所有AspectJ切面对应的Advisors，并将其添加到`advisors`列表中返回。

[BeanFactoryAspectJAdvisorsBuilder源码分析](../spring-aop-beanFactoryAspectJAdvisorsBuilder/README.md)

```java
@Override
protected List<Advisor> findCandidateAdvisors() {
    // 添加根据超类规则找到的所有Spring顾问。
    List<Advisor> advisors = super.findCandidateAdvisors();
    // 为bean工厂中的所有AspectJ切面构建顾问。
    if (this.aspectJAdvisorsBuilder != null) {
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    }
    return advisors;
}
```

在`org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findCandidateAdvisors`方法中，调用`BeanFactoryAdvisorRetrievalHelper.findAdvisorBeans()` 方法来获取候选的Advisors列表。

[BeanFactoryAdvisorRetrievalHelper源码分析](../spring-aop-beanFactoryAdvisorRetrievalHelper/README.md)

```java
/**
 * 查找用于自动代理的所有候选Advisors。
 * @return 候选Advisors的列表
 */
protected List<Advisor> findCandidateAdvisors() {
    Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
    return this.advisorRetrievalHelper.findAdvisorBeans();
}
```

在`org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findAdvisorsThatCanApply`方法中，搜索给定的候选 Advisors，以找到所有能够应用于指定 bean 的 Advisors。它设置当前被代理的 bean 名称，并尝试查找所有适用于指定 bean 的 Advisors。在查找完成后，它会清除当前被代理的 bean 名称。

```java
/**
 * 搜索给定的候选顾问，找到所有适用于指定bean的顾问。
 * @param candidateAdvisors 候选顾问列表
 * @param beanClass 目标bean的类
 * @param beanName 目标bean的名称
 * @return 适用的顾问列表
 * @see ProxyCreationContext#getCurrentProxiedBeanName()
 */
protected List<Advisor> findAdvisorsThatCanApply(
        List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
    
    // 设置当前代理的bean名称
    ProxyCreationContext.setCurrentProxiedBeanName(beanName);
    try {
        // 查找适用于指定bean的顾问
        return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
    }
    finally {
        // 清除当前代理的bean名称
        ProxyCreationContext.setCurrentProxiedBeanName(null);
    }
}
```

在`org.springframework.aop.support.AopUtils#findAdvisorsThatCanApply`方法中，用于确定适用于给定类的候选Advisors子列表。它遍历给定的Advisors列表，首先将能够应用于指定类的引介Advisors添加到结果列表中。然后，它检查是否已经存在引介Advisors，如果存在，则跳过；如果不存在，则继续遍历Advisors列表，并将能够应用于指定类的其他Advisors添加到结果列表中。最终返回这个子列表，其中包含可以应用于给定类的所有Advisors。

```java
/**
 * 确定 {@code candidateAdvisors} 列表中适用于给定类的子列表。
 * @param candidateAdvisors 要评估的顾问列表
 * @param clazz 目标类
 * @return 可应用于给定类的顾问子列表
 * （可能是原始列表）
 */
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
    // 如果候选顾问列表为空，则直接返回空列表
    if (candidateAdvisors.isEmpty()) {
       return candidateAdvisors;
    }
    // 创建一个用于存储适用于给定类的顾问的列表
    List<Advisor> eligibleAdvisors = new ArrayList<>();
    // 遍历候选顾问列表
    for (Advisor candidate : candidateAdvisors) {
       // 如果候选顾问是引介顾问，并且可以应用于给定类，则将其添加到结果列表中
       if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
          eligibleAdvisors.add(candidate);
       }
    }
    // 检查是否存在引介顾问
    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    // 继续遍历候选顾问列表
    for (Advisor candidate : candidateAdvisors) {
       // 如果候选顾问是引介顾问，则跳过
       if (candidate instanceof IntroductionAdvisor) {
          // 已经处理过
          continue;
       }
       // 如果候选顾问可以应用于给定类，则将其添加到结果列表中
       if (canApply(candidate, clazz, hasIntroductions)) {
          eligibleAdvisors.add(candidate);
       }
    }
    return eligibleAdvisors;
}
```

在`org.springframework.aop.support.AopUtils#canApply(org.springframework.aop.Advisor, java.lang.Class<?>, boolean)`方法中，判断给定的顾问是否能够在指定的类上应用。它首先检查顾问是否是引介顾问，如果是，则通过类过滤器来判断是否可以应用于目标类。如果顾问不是引介顾问，而是切点顾问，则通过切点来判断是否可以应用于目标类。如果顾问既不是引介顾问也不是切点顾问，则假设它适用于目标类。

```java
/**
 * 判断给定的顾问是否能够在指定的类上应用。
 * <p>这是一个重要的测试，因为它可以用于优化掉一个类的顾问。
 * 这个版本还考虑了引介（对于IntroductionAwareMethodMatchers）。
 * @param advisor 要检查的顾问
 * @param targetClass 我们正在测试的类
 * @param hasIntroductions 顾问链中是否包含任何引介
 * @return 切点是否能够应用于任何方法
 */
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
    // 如果顾问是引介顾问，则通过类过滤器来判断是否可以应用于目标类
    if (advisor instanceof IntroductionAdvisor) {
       return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
    }
    // 如果顾问是切点顾问，则通过切点来判断是否可以应用于目标类
    else if (advisor instanceof PointcutAdvisor) {
       PointcutAdvisor pca = (PointcutAdvisor) advisor;
       return canApply(pca.getPointcut(), targetClass, hasIntroductions);
    }
    // 否则，假设它适用于目标类
    else {
       // 它没有切点，因此我们假设它适用。
       return true;
    }
}
```

在`org.springframework.aop.support.AopUtils#canApply(org.springframework.aop.Pointcut, java.lang.Class<?>, boolean)`方法中，确定给定的切点是否能够在指定的类上应用。首先，它检查切点的类过滤器是否与目标类匹配。如果不匹配，则返回 false。如果类过滤器匹配目标类，它会检查方法匹配器是否为 MethodMatcher.TRUE，如果是，则表示切点适用于目标类的任何方法，直接返回 true。如果方法匹配器不是 MethodMatcher.TRUE，则遍历目标类及其所有接口，并检查每个类中的方法是否与切点匹配。如果找到匹配的方法，则返回 true；如果没有找到匹配的方法，则返回 false。

```java
/**
 * 判断给定的切点是否能够在指定的类上应用。
 * <p>这是一个重要的测试，因为它可以用于优化掉一个类的切点。
 * @param pc 要检查的静态或动态切点
 * @param targetClass 要测试的类
 * @param hasIntroductions 顾问链中是否包含任何引介
 * @return 切点是否能够应用于任何方法
 */
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
	Assert.notNull(pc, "Pointcut must not be null");
    // 首先检查类过滤器是否匹配目标类
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }

    MethodMatcher methodMatcher = pc.getMethodMatcher();
    // 如果方法匹配器是 MethodMatcher.TRUE，则不需要遍历方法，直接返回true
    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));

    // 遍历类集合
    for (Class<?> clazz : classes) {
        // 获取类中声明的所有方法
        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        // 遍历方法
        for (Method method : methods) {
            // 如果存在引介感知的方法匹配器，并且方法匹配，则返回true；
            // 否则，如果方法匹配器匹配方法，则返回true
            if (introductionAwareMethodMatcher != null ?
                    introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                    methodMatcher.matches(method, targetClass)) {
                return true;
            }
        }
    }

    return false;
}
```

在`org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator#extendAdvisors`方法中，将 `ExposeInvocationInterceptor` 添加到通知链的开头。这是必要的额外处理，特别是在使用 AspectJ 切点表达式和 AspectJ 风格的建议时。

```java
/**
 * 将 {@link ExposeInvocationInterceptor} 添加到通知链的开头。
 * <p>在使用AspectJ切点表达式和AspectJ风格的建议时，需要添加此额外的建议。
 * @Override
 * @param candidateAdvisors 候选的Advisors列表
 */
@Override
protected void extendAdvisors(List<Advisor> candidateAdvisors) {
    // 如果需要，使Advisor链支持AspectJ
    AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors);
}
```

在`org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#createProxy`方法中，首先检查`BeanFactory`是否是`ConfigurableListableBeanFactory`类型的，如果是，则调用`AutoProxyUtils.exposeTargetClass`方法来暴露目标类。然后创建一个`ProxyFactory`实例，并根据当前的代理配置进行设置。根据是否启用了代理目标类的标志，决定是否将代理目标类设置为true或false。接着构建适用于该bean的所有顾问，将它们添加到`ProxyFactory`中，并设置目标源为预先配置好的`TargetSource`。最后，根据当前的代理配置和代理类加载器，使用`ProxyFactory`获取代理实例并返回。

```java
/**
 * 为给定的 bean 创建一个 AOP 代理。
 * @param beanClass bean 的类
 * @param beanName bean 的名称
 * @param specificInterceptors 适用于此 bean 的拦截器集合（可能为空，但不为 null）
 * @param targetSource 代理的 TargetSource，已预先配置以访问该 bean
 * @return bean 的 AOP 代理
 * @see #buildAdvisors
 */
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
                              @Nullable Object[] specificInterceptors, TargetSource targetSource) {

    // 如果 beanFactory 是 ConfigurableListableBeanFactory 类型的，则暴露目标类
    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }

    // 创建 ProxyFactory 实例
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    // 如果需要使用代理目标类，则设置为 true
    if (proxyFactory.isProxyTargetClass()) {
        // 对 JDK 代理目标进行显式处理（用于介绍建议场景）
        if (Proxy.isProxyClass(beanClass)) {
            // 必须允许引入；不能只设置接口为代理的接口。
            for (Class<?> ifc : beanClass.getInterfaces()) {
                proxyFactory.addInterface(ifc);
            }
        }
    } else {
        // 未强制代理目标类标志，让我们应用默认检查...
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        } else {
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }

    // 构建顾问数组
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    // 将顾问添加到 ProxyFactory
    proxyFactory.addAdvisors(advisors);
    proxyFactory.setTargetSource(targetSource);
    // 自定义 ProxyFactory
    customizeProxyFactory(proxyFactory);

    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }

    // 如果 bean 类没有在重写类加载器中本地加载，则使用原始 ClassLoader
    ClassLoader classLoader = getProxyClassLoader();
    if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
        classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
    }
    // 获取代理实例
    return proxyFactory.getProxy(classLoader);
}
```