简述今天重点分析ApplicationContext初始化时做的事情我们都只到spring是个IOC和AOP容器那再我们new一个ApplicationContextspring内部都做了什么怎么实现的IOC和AOP比如说下面这段代码Configuration ComponentScan(com.xxx.xxx) EnableAspectJAutoProxy public class MainApplication { public static void main(String[] args) { ApplicationContext context new AnnotationConfigApplicationContext(MainApplication.class); IUser user context.getBean(IUser.class); user.sayHi(); } }通过new一个AnnotationConfigApplicationContext我们就得到了这个bean容器还可以添加切面那再new的时候都做了什么呐?BeanFactory这篇文章的基础是懂得BeanFactory如果不懂可以做做功课或者翻翻之前的文章~Bean的生命周期和BeanPostProcessor再来简单总结一下BeanFactory。BeanFactory能干什么以最主要的DefaultListableBeanFactory为例注册bean定义通过bean定义生产bean并可以随时获取可以添加bean后置处理器(BeanPostProcessor)来调整bean的创建过程可以一次性创建所有非懒加载单例bean(preInstantiateSingletons)等等ApplicationContext有了BeanFactory为啥还要有ApplicationContext呐其实BeanFactory只是一个给图纸(bean定义)生产产品(bean)的工厂离我们太遥远了或者说用起来他麻烦了甚至依赖注入和AOP都不是BeanFactory实现的如果单纯使用BeanFactory需要给他添加依赖注入的后置处理器需要给他加AOP的后置处理器才能实现这些功能而使用ApplicationContext这些活它帮干了它还可以自动扫描包或者读取配置自动生成bean定义注册到BeanFactory当中还有一些事件的支持和国际化的支持。所以为什么有ApplicationContextApplicationContext就是把一些我们平时开发用到的功能封装好了我们开发时直接用就可以实现IOCAOP事件等功能它俩的关系就好比工厂和门店那有了工厂为啥还有有门店呐单一职责吗工厂的技术宅就能看懂图纸你跟他说中国话他听不懂所以就有了门店你简单和门店的人说一下你的需求门店的人帮你画图纸交给工厂生产整个过程你不需要和工厂接触后置处理器后置处理器分为BeanFactoryPostProcessor和BeanPostProcessorBeanPostProcessorbean后置处理器beanFactory可以添加BeanPostProcessor再生成bean的不同时期执行这些后置处理器简单来说通过设置后置处理器可以再bean的创建过程中植入一些自定义逻辑BeanFactoryPostProcessorBeanFactory后置处理器ApplicationContext可以添加BeanFactoryPostProcessor再初始化ApplicationContext时会调用这些BeanFactory后置处理器总结BeanPostProcessor和BeanFactoryPostProcessor都是钩子前者是存储于beanFactory再生产bean时候调用后者存储于ApplicationContext再初始化ApplicationContext时调用二者都有很多子类型以便再不同阶段调用使代码有很大的扩展性ApplicationContext接下来分析ApplicationContext的源码由于现在都很少用xml这种了所以我们找了个AnnotationConfigApplicationContext注解配置的ApplicationContext也就是现在当然springboot内部用的ApplicationContext那就开始跟宗AnnotationConfigApplicationContext的构造方法public AnnotationConfigApplicationContext(Class?... componentClasses) { this(); register(componentClasses); refresh(); }一共就三局一个一个跟this()调用无参构造方法首先要调用父类构造方法父类是GenericApplicationContext看看他的构造方法public GenericApplicationContext() { this.beanFactory new DefaultListableBeanFactory(); }这个简单内部初始化了一个DefaultListableBeanFactory这个好理解门店的背后肯定是有工厂的再来看当前类的无参构造方法public AnnotationConfigApplicationContext() { this.reader new AnnotatedBeanDefinitionReader(this); this.scanner new ClassPathBeanDefinitionScanner(this); }初始化了一个reader一个scanner先看看reader跟踪reader的构造方法会出现这么一条代码AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);这句话很重要这里的this.registry就是ApplicationContext在这里扮演一个bean定义注册器的角色进入这个方法查看~具体的代码就不贴了很长可以自己看看总结就是像这个bean定义注册器注册了很多个后置处理器类型的bean定义包括BeanFactoryPostProcessor类型和BeanPostProcessor类型主要有配置类解析后置处理器 ConfigurationClassPostProcessor(BeanFactoryPostProcessor)Autowired 注解的处理器 AutowiredAnnotation(BeanPostProcessor)Required属性的注解处理器 RequiredAnnotation(BeanPostProcessor)EventListener解析器 EventListenerMethodProcessor事件监听器工厂 DefaultEventListenerFactory注意上面讨论过两种后置处理器存放的位置而这时添加的后置处理器并没有存放到相应位置而是以bean的形式存放在bean容器中至于为什么在这时机添加后置处理器应该是这些后置处理器都属于读文件、读类的功能即reader。register(componentClasses)这里的componentClasses就是初始化时传入的唯一参数MainApplication.classregister都干了什么呐public void register(Class?... componentClasses) { Assert.notEmpty(componentClasses, At least one component class must be specified); this.reader.register(componentClasses); }调用刚才初始化的reader的register方法这里就要介绍reader的主要作用就是传入一个类把类转换为bean定义并注册到初始化时传入的bean定义注册器所以register方法就是把主配置类(MainApplication)解析为bean定义并完成注册refresh()这句就是初始化的核心方法了内部有很多子方法的调用// Prepare this context for refreshing. prepareRefresh(); // Tell the subclass to refresh the internal bean factory. ConfigurableListableBeanFactory beanFactory obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. registerBeanPostProcessors(beanFactory); // Initialize message source for this context. initMessageSource(); // Initialize event multicaster for this context. initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. onRefresh(); // Check for listener beans and register them. registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. finishRefresh(); }这么多方法一个一个来吧1.prepareRefresh这个先不管就是做一些准备工作吗比如记录一下程序开始的时间什么的2.beanFactory obtainFreshBeanFactory()因为refresh方法是再父类中执行的而beanFactory是在子类初始化的所以这句话就是父类管子类要beanFactory也就是刚才GenericApplicationContext无参构造中初始化的DefaultListableBeanFactory3.prepareBeanFactory拿到了beanFactory再给beanFactory做一次准备工作比如初始化属性什么的4.postProcessBeanFactory(beanFactory)Allows post-processing of the bean factory in context subclasses这句话相当于给子类一个机会做一些操作比如添加一些后置处理器进来(因为下一步就要执行后置处理器了再次之前给一个机会再添加一些后置处理)也是为了代码灵活查看子类并没有再这一步做什么操作5.invokeBeanFactoryPostProcessors(beanFactory);重点来了字面意思执行BeanFactory后置处理器看一下代码protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());这里相当于把工作交给一个类PostProcessorRegistrationDelegate处理我们先管他叫后置处理委托器spring使用这种委托模式来让代码规整也比较符合单一职责PostProcessorRegistrationDelegate把后置处理器相关的业务代码从ApplicationContext中抽离出来那么继续跟到PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors这个方法这个比较重要得贴下代码public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, ListBeanFactoryPostProcessor beanFactoryPostProcessors) { // Invoke BeanDefinitionRegistryPostProcessors first, if any. // 已执行的后置处理器(bean容器中)为防止重复执行 SetString processedBeans new HashSet(); // 如果bean工厂是bean定义注册器比如DefaultListableBeanFactory本身也是可以注册bean定义的注册器 if (beanFactory instanceof BeanDefinitionRegistry) { // bean定义注册器 BeanDefinitionRegistry registry (BeanDefinitionRegistry) beanFactory; // 基础型后置处理器集合 ListBeanFactoryPostProcessor regularPostProcessors new ArrayList(); // bean定义注册型后置处理器集合 ListBeanDefinitionRegistryPostProcessor registryProcessors new ArrayList(); // 循环后置[参数]后置处理器 for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { // 如果是bean定义注册型后置处理器直接执行postProcessBeanDefinitionRegistry并存入registryProcessors if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { BeanDefinitionRegistryPostProcessor registryProcessor (BeanDefinitionRegistryPostProcessor) postProcessor; registryProcessor.postProcessBeanDefinitionRegistry(registry); registryProcessors.add(registryProcessor); } // 如果是基础型后置处理器直接执行并存入regularPostProcessors else { regularPostProcessors.add(postProcessor); } } // 开始执行[bean容器中]后置处理器 // 当前bean定义注册型后置处理器集合为了按循序执行 ListBeanDefinitionRegistryPostProcessor currentRegistryProcessors new ArrayList(); // 首先从bean容器中获取带PriorityOrdered标识的bean定义注册型后置处理器 String[] postProcessorNames beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // 加入当前集合 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); // 标记已执行 processedBeans.add(ppName); } } // 排序 sortPostProcessors(currentRegistryProcessors, beanFactory); // 加入registryProcessors registryProcessors.addAll(currentRegistryProcessors); // 执行当前bean定义注册型后置处理器集合的postProcessBeanDefinitionRegistry方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); // 清空当前bean定义注册型后置处理器集合 currentRegistryProcessors.clear(); // 其次, 从bean容器中获取带Ordered标识的bean定义注册型后置处理器逻辑和上一步基本一样 postProcessorNames beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 多了一个!processedBeans.contains判断避免后置处理器被多次执行 if (!processedBeans.contains(ppName) beanFactory.isTypeMatch(ppName, Ordered.class)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); // 最后, 执行其他的bean定义注册型后置处理器知道容器中的所有都被执行过 boolean reiterate true; while (reiterate) { reiterate false; postProcessorNames beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); reiterate true; } } sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); } // 执行所有基础型后置处理器的postProcessBeanFactory方法bean定义注册型后置处理器也是基础型后置处理器的一种所以也要执行 // 这里的regularPostProcessors来源于[参数]后置处理器 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); } else { // 如果传入的beanFactory不是bean定义注册器只是简单的执行了[参数]后置处理器的postProcessBeanFactory方法 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } // 开始执行[bean容器中]普通后置处理器和执行[bean容器中]bean定义注册型后置处理器基本逻辑差不多都是按循序执行 String[] postProcessorNames beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); // 按PriorityOrdered, Ordered, 和无注解区分优先级 ListBeanFactoryPostProcessor priorityOrderedPostProcessors new ArrayList(); ListString orderedPostProcessorNames new ArrayList(); ListString nonOrderedPostProcessorNames new ArrayList(); for (String ppName : postProcessorNames) { if (processedBeans.contains(ppName)) { // skip - already processed in first phase above } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); } } // 首先执行带PriorityOrdered的. sortPostProcessors(priorityOrderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); // 其次, 执行带Ordered的. ListBeanFactoryPostProcessor orderedPostProcessors new ArrayList(orderedPostProcessorNames.size()); for (String postProcessorName : orderedPostProcessorNames) { orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } sortPostProcessors(orderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); // 最终, 执行其他的 ListBeanFactoryPostProcessor nonOrderedPostProcessors new ArrayList(nonOrderedPostProcessorNames.size()); for (String postProcessorName : nonOrderedPostProcessorNames) { nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } // 执行了[bean容器中]基础型后置处理器的postProcessBeanFactory方法 invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); // Clear cached merged bean definitions since the post-processors might have // modified the original metadata, e.g. replacing placeholders in values... beanFactory.clearMetadataCache(); }上面的代码还是比较多但总结起来也不复杂首先后置处理器主要有两种1).基础型后置处理器(BeanFactoryPostProcessor)基础型后置处理器只有一个方法postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)可以配置bean工厂比如bean工厂添加一些bean后置处理器2).bean定义注册型后置处理器(BeanDefinitionRegistryPostProcessor)bean定义注册型后置处理器继承BeanFactoryPostProcessor所以也属于基础型后置处理器的一种新增一个方法postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)增加功能可以注册一些bean定义其次执行后置处理器那么后置处理器在哪里从代码里就可以看出1).【参数】后置处理器之前ApplicationContext存储了一些BeanFactory后置处理器可以通过public的addBeanFactoryPostProcessor方法添加比如springboot启动时就添加了一些后置处理器这些后置处理器是用第二个参数getBeanFactoryPostProcessors()传给后置处理委托器的/** AbstractApplicationContext中 */ private final ListBeanFactoryPostProcessor beanFactoryPostProcessors new ArrayList();2).【bean容器中】的后置处理器ApplicationContext引用了DefaultListableBeanFactory这个BeanFactory中存放了很多的bean这些bean有些是后置处理器类型的(比如子类初始化reader时通过AnnotationConfigUtils.registerAnnotationConfigProcessors方法存入的bean)那么只要通过beanFactory调用getBeanNamesForType就可以获取这些后置处理器比如// 通过类型获取所有后置处理器的名字 String[] postProcessorNames beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 获取到后置处理器 beanFactory.getBean(ppName, BeanFactoryPostProcessor.class); } }存在两个地方的后置处理器分别通过BeanFactory和getBeanFactoryPostProcessors()传给后置处理委托器那么下一步后置处理委托器就是执行这两种来源的后置处理器执行过程就是上面代码比较有意思考虑到传入的参数DefaultListableBeanFactory本身就是BeanDefinitionRegistry所以执行逻辑如下执行[参数]后置处理器中的bean定义注册型后置处理器postProcessBeanDefinitionRegistry方法查找bean容器执行[bean容器中]后置处理器中的bean定义注册型后置处理器postProcessBeanDefinitionRegistry方法这个过程会按PriorityOrderedOrderedOther 顺序依次分批执行执行完一批会重新去bean容器获取一次直到获取不到为止这样非常巧妙如果某个bean定义注册型后置处理器有注册了一个该类型后置处理器该后置处理器就会在后续的查找中被找出并执行即可以用后置处理器添加后置处理器有点传销的意思执行上两步bean定义注册型后置处理器的postProcessBeanFactory方法执行[参数]后置处理器中基础型后置处理器的postProcessBeanFactory方法查找bean容器执行执行[bean容器中]后置处理器中的基础型后置处理器的postProcessBeanFactory方法依然是按PriorityOrderedOrderedOther批次进行执行但不会在这期间再次重新查找bean容器总结这一步完成了对两种来源的两种类型的beanFactory后置处理器的调用期间注册型后置处理器注册的新后置处理器也会被执行6.registerBeanPostProcessors(beanFactory);beanFactory后置处理器的添加和调用都结束了下一步就要开始弄bean后置处理了前面讲过bean后置处理器是存在beanFactory中的所以参数还是传了个beanFactoryprotected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this); }同样还是交给了后置处理委托器去处理上面reader初始化的时候往bean容器里加了一些beanFactory后置处理同时也有bean后置处理器以bean的形式存储那总得有人把这些后置处理器给摘出来放到beanFactory的bean后置处理列表里才能再创建时被调用因为beanFactory的后置处理器存储地点如下private final ListBeanPostProcessor beanPostProcessors new CopyOnWriteArrayList();但是上面reader却把后置处理器放到了bean容器中那肯定执行不了啊所以这一步就是把beanFactory中的bean后置处理器类型的bean定义生产出来放入beanPostProcessors中这些bean定义除了reader添加的几个还有大部分是上一步beanFactory后置处理器执行时加入到bean容器的总结这一步完成把以bean形式存储在beanFactory中的后置处理器摘出来放到beanFactory中专门存放后置处理器的地方以便后续创建bean时使用7.initMessageSource国际化的一些处理以后研究8.initApplicationEventMulticaster事件处理以后研究9.onRefresh也是一个钩子默认什么都不做子类可以覆盖去做点事10.registerListeners事件的处理以后研究11.finishBeanFactoryInitialization(beanFactory)这一步就很重要了看注释Instantiate all remaining (non-lazy-init) singletons实例化所有非懒加载的bean也就是调用beanFactory的preInstantiateSingletons方法创建所有单例bean(非懒加载的bean)12.finishRefresh结束后的一些操作比如发布初始化结束事件等总结到此refresh方法分析完了抛去一些事件国际化相关的辅助代码主要结合之前的流程总结如下配置主方法注入到bean容器添加一些beanFactory后置处理器和bean后置处理器还有一些其它的bean至bean定义注册器执行beanFactory后置处理器分BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor两种通过BeanFactoryPostProcessor可以配置bean工厂通过BeanDefinitionRegistryPostProcessor可以注册一些bean定义也配置bean工厂其间BeanDefinitionRegistryPostProcessor可以注册新的后置处理器也会再后续执行提取bean容器中bean后置处理器类型的bean添加到bean工厂的bean后置处理器列表中初始化所有单例非懒加载bean到此spring启动时所执行重点方法就分析完了其实按总结来看就那么几个重点步骤但是所谓的IOC和AOP到底如何实现的呐并没有相关代码啊其实这些功能都是通过后置处理器来实现的也就是spring定义了一套后置处理器执行的规则并把重点的工作都交给了内置的后置处理器来实现IOCspring是一个IOC容器能把我们写的ServiceControllerComponent的类的bean定义注册并生成bean加入容器但刚刚我们看了new ApplicationContext的流程代码发现用户写的类唯一被注册成bean定义就只有MainApplication.class那么其他的bean(ServiceControllerComponent修饰的)是合适注册为bean定义的其实这部分工作就是后置处理器ConfigurationClassPostProcessor完成的就是上文read构造时registerAnnotationConfigProcessors方法注册的后置处理器ConfigurationClassPostProcessor翻译过来就是配置类后置处理器就是专门处理配置类的它继承了BeanDefinitionRegistryPostProcessor因此拥有注册bean定义的能力ConfigurationClassPostProcessor那么重点看一下它的postProcessBeanDefinitionRegistry方法Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { // 省略 processConfigBeanDefinitions(registry); }进入processConfigBeanDefinitions只捡主要代码贴可自行对照public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { // 创建一个解析器解析Configuration注解的类 ConfigurationClassParser parser new ConfigurationClassParser( this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry); // 开始解析这个candidates就是我们传入的MainApplication parser.parse(candidates); // 获取解析到的类 SetConfigurationClass configClasses new LinkedHashSet(parser.getConfigurationClasses()); // 初始化一个reader this.reader new ConfigurationClassBeanDefinitionReader( registry, this.sourceExtractor, this.resourceLoader, this.environment, this.importBeanNameGenerator, parser.getImportRegistry()); // 把上面解析到的类转化为bean定义并注册到bean定义注册器(registry) this.reader.loadBeanDefinitions(configClasses); }使用ConfigurationClassParser.parse进行配置类解析而这个方法就包含了解析ComponentScanImport等注解ComponentScan就是我们制定的扫描包路径会扫描路径下Component注解的类(包括子注解ConfigurationService等)注册成bean定义同时会继续递归parse解析扫描到的ConfigurationClass(一般只带有Configuration注解)直到把我们指定的所有bean加入bean容器这里的源码分析可查看文章:spring如何扫描解析bean(注册bean的多种方式)依赖注入依赖注入是通过BeanPostProcessor实现的即AutowiredAnnotationBeanPostProcessor依然是上文read构造时registerAnnotationConfigProcessors方法注册的后置处理器它修改了bean生命周期中填充属性的过程查询带有Autowired属性通过属性的type在bean容器中使用getBeanByType方式查找要注入的bean反射给属性赋值细节可以参照文章Spring之Autowired依赖注入探究AOPConfigurationClassParser.parse的时候还会扫描Import注解如果Import的类继承了ImportBeanDefinitionRegistrar就可以自定义注册一些bean(参照spring如何扫描解析bean(注册bean的多种方式))。AOP就是使用这种ImportImportBeanDefinitionRegistrar的方式完成AOP功能可配置的---注解EnableAspectJAutoProxy有则可以AOP没有则不能AOPEnableAspectJAutoProxyTarget(ElementType.TYPE) Retention(RetentionPolicy.RUNTIME) Documented Import(AspectJAutoProxyRegistrar.class) public interface EnableAspectJAutoProxy { // 省略 }其中引入了AspectJAutoProxyRegistrar而AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar那么这个注解通过这种方式注册了什么bean呐答案就是bean后置处理器AnnotationAwareAspectJAutoProxyCreator用来再bean创建过程中实现动态代理。public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary( BeanDefinitionRegistry registry, Nullable Object source) { // 注册AnnotationAwareAspectJAutoProxyCreator return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source); }而AnnotationAwareAspectJAutoProxyCreator继承了AbstractAutoProxyCreator继而继承BeanPostProcessor创建代理的代码就写在AbstractAutoProxyCreator.wrapIfNecessary方法里对其刚兴趣可以参考我之前的AOP系列文章