## 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 { <> } class AspectJAwareAdvisorAutoProxyCreator class Aware { <> } class BeanClassLoaderAware { <> } class BeanFactoryAware { <> } class BeanPostProcessor { <> } class InstantiationAwareBeanPostProcessor { <> } class ProxyConfig class ProxyProcessorSupport class SmartInstantiationAwareBeanPostProcessor { <> } 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 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 findEligibleAdvisors(Class beanClass, String beanName) { // 查找候选Advisors List candidateAdvisors = findCandidateAdvisors(); // 查找可应用的Advisors List 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 findCandidateAdvisors() { // 添加根据超类规则找到的所有Spring顾问。 List 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 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 findAdvisorsThatCanApply( List 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 findAdvisorsThatCanApply(List candidateAdvisors, Class clazz) { // 如果候选顾问列表为空，则直接返回空列表 if (candidateAdvisors.isEmpty()) { return candidateAdvisors; } // 创建一个用于存储适用于给定类的顾问的列表 List 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 /** * 判断给定的顾问是否能够在指定的类上应用。 *

这是一个重要的测试，因为它可以用于优化掉一个类的顾问。 * 这个版本还考虑了引介（对于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 /** * 判断给定的切点是否能够在指定的类上应用。 *

这是一个重要的测试，因为它可以用于优化掉一个类的切点。 * @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> 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} 添加到通知链的开头。 *

在使用AspectJ切点表达式和AspectJ风格的建议时，需要添加此额外的建议。 * @Override * @param candidateAdvisors 候选的Advisors列表 */ @Override protected void extendAdvisors(List 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); } ```