Spring源码分析(七) 启动过程源码跟踪
Spring的启动过程如下：
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class); applicationContext.getBean("people");
public AnnotationConfigApplicationContext(Class<?>... componentClasses) { // 1：初始化beand的读取器和扫描器 // 2：调用父类的 GenericApplicationContext的无参构造初始化一个BeanFactory DefaultListableBeanFactory // 3:注册Spring自带的bean五个后置处理器和注解相关的 this(); // 根据传入的BeanConfig注册了BeanConfig 业务Bean还没开始注册 // 利用reader把componentClasses 注册为一个BeanDefinition register(componentClasses); // 最重要的方法！！ Spring容器的创建,bean的注册实例化等操作 //调用AbstractApplicationContext的refresh方法 模板模式 会启动ApplicationContext refresh(); }
public AnnotationConfigApplicationContext() { /** 在执行这个构造方法之前，会先执行父类的构造方法，初始化beanFactory=new DefaultListableBeanFactory() * 生成并注册5个 BeanDefinition * 1: ConfigurationClassPostProcessor bean工厂的后置处理器，扫描注解的过程就是它完成的 * 2: AutowiredAnnotationBeanPostProcessor * 3: CommonAnnotationBeanPostProcessor * 4: EventListenerMethodProcessor * 5: DefaultEventListenerFactory */ // 设置当前容器的BeanDefinitionReader,参数传入注册器即当前对象，因为它是一个BeanFactory也是一个注册器 // 会直接通过registry注册到beanDefinitonMap五个和注解相关的后置处理器 //它可以让一个类封装成一个beanDefinition this.reader = new AnnotatedBeanDefinitionReader(this); // 注册默认的includeFilter this.scanner = new ClassPathBeanDefinitionScanner(this); }
@Override public void refresh() throws BeansException, IllegalStateException { //容器启动开始 ，加锁保证只有一个线程在进行初始化 synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. //初始化配置信息 prepareRefresh(); // Tell the subclass to refresh the internal bean factory. //获取刷新的beanFactory,得到一个空的BeanFactory //对于AnnotationConfigApplicationContext的作用来说 // 1：调用GenericApplicationContext.refreshBeanFactory 只是指定了serializationId // 2: 直接返回beanFactory（不用创建，容器中已存在） // 对于ClassPathXmlApplicationContext // 1：调用AbstractRefreshableApplicationContext.refreshBeanFactory // 如果存在beanFactory先销毁bean,关闭beanFactory再创建beanFactory // 2:注册传入的xml配置，注册到beanFactory // 3: 将beanFactory赋值给容器，返回beanFactory // 使用了模板方法 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. //准备beang工厂,指定类的加载器，添加后置处理器，注册缺省bean等 // beanFactory添加两个beanPostProcessor后置处理器ApplicationContextAwareProcessor,ApplicationListenerDetector(new)在 // AbstractBeanFactory.beanPostProcessors中 prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. //空方法， // 允许在上下文的子类中对beanFactory进行后处理 // 比如：AbstractRefreshableApplicationContext.postProcessBeanFactory // 子类可以对BeanFatcory进一步进行初始化 postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. //最关键的方法 //1：通过beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class)拿到 ConfigurationClassPostProcessor // 2:通过ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry注册所有注解配置的bean // 注册顺序： // @ComponentScan>实现ImportSelector>方法bean>@ImportSource>实现 ImportBeanDefinitionRegistrar(相对顺序，都在同一个配置类上) // 3：调用ConfigurationClassPostProcessor.postProcessBeanFactory增强@Configuration修饰的配置类 // AppConfig==>AppConfig$$EnhancerBySpringCGLIB // 可以处理内部方法bean之间的调用防止多例， // 添加了后置处理器ConfigurationClassPostProcessor.ImportAwareBeanPostProcess(new) // ========================================================================================== // BeanFactory 准备好之后，执行BeanFactoryPostProcessor 开始对BeanFactory进行处理 // 默认情况下： // 此时 BeanFactory的beanDefinitionMap中有6个BeanDefinition, 5个基础的BeanDefinition+AppConfig自定义的BeanDefinition // 里面只有 ConfigurationClassPostProcessor 是直接实现了BeanDefinitionRegistryPostProcessor 拥有BeanFactoryPostProcessor的方法 invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. // 从BeanFactory找出扫描到的BeanPostProcessor 实例化并进行注册到BeanFactory中 //注册拦截bean创建的后置处理器 //1：添加Spring自身的：BeanPostProcessorChecker以及注册了beanDefinitionn的两个 // CommonAnnotationBeanPostProcessor ,AutowiredAnnotationBeanPostProcessor // 重新添加ApplicationListenerDetector(new)删除旧的，移除到处理器链末尾 // 2：用户自定义的后置处理器 // 注册了beanDefinition的会通过beanFactory.getBean(ppName,BeanPostProcessor.class)获取后置处理器 registerBeanPostProcessors(beanFactory); // Initialize message source for this context. //初始化MessageSource 如果配置了一个名字叫"messageSource"的BeanDefinition 就会把这个bean创建出来 并赋值给ApplicationContext的messageSource属性 //这样ApplicationContext就可以使用国际化的功能了 initMessageSource(); // Initialize event multicaster for this context. //初始化事件多播器 设置ApplicationContext的applicationEventMulticaster initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. // //暂时是空方法 执行子类的onRefresh方法 onRefresh(); // Check for listener beans and register them. // 注册监听器 虽然上面 prepareBeanFactory方法和registerBeanPostProcessors 方法中都注册了 后置处理器 ApplicationListenerDetector 来检测监听器 // 但是这里注册监听器是一些其他情况 registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. // //实例化 所有剩余的（非懒加载）单例 finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. // 发布事件 finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... // resetCommonCaches(); } } }
在看扫描的源码之前，先补充一下知识点，正常Spring启动过程中的bean都会封装成一个BeanDefinition来进行实例化，而向Spring容器中注入 BeanDefinition可以通过如下几种方式：
1：注解,@Component @Service @Bean等等
2：@Import注解 这个注解可以让引入的类放入到spring容器中。
3：实现 BeanDefinitionRegistryPostProcessor 接口，可以在spring容器创建过程中向容器里面注册BeanDefinition。
4：上面这个接口是实现 BeanFactoryPostProcessor 这个接口，它是bean工厂的后置处理器，但是它是在容器创建完成之后执行的，在它这个实现类里面已经不能再向容器里注入BeanDefinition了。
启动过程中最重要的流程就是： invokeBeanFactoryPostProcessor方法。调用bean工厂的后置处理器。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { // getBeanFactoryPostProcessors() 拿到当前应用上下文beanFactoryPostProcessors 直接返回this.beanFactoryPostProcessors // invokeBeanFactoryPostProcessors: 实例化并调用所有已经注册的BeanFactoryPostProcessor ，包括其子接口BeanDefinitionRegistryPostProcessor // getBeanFactoryPostProcessors() 这个方法得到的是手动添加到容器中bean工厂后置处理器 /**AnnotationConfigApplicationContext applicationContextReg = new AnnotationConfigApplicationContext(); applicationContextReg.register(BeanConfig.class); applicationContextReg.addBeanFactoryPostProcessor(new BeanFactoryRegisterPostProcessro()); applicationContextReg.refresh(); getBeanFactoryPostProcessors() 这个方法得到就是上面那个 */ PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor) if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } }
执行bean工厂的后置处理器分为两种，一种是具有注册功能的后置处理器，一种是没有注册功能的后置处理器，会先执行有注册功能的后置处理器，再执行没有注册功能的后置处理器。
// beanFactoryPostProcessors 参数，集合中的对象有两类，一类就是 BeanFactoryPostProcessor 接口的实现类，一类是BeanDefinitionRegistryPostProcessor 接口的实现类 // BeanDefinitionRegistryPostProcessor是 BeanFactoryPostProcessor的子接口，子接口的实现类可以有父接口的功能 // 子接口具有注册beanDefinition的功能 会先执行 public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { // Invoke BeanDefinitionRegistryPostProcessors first, if any. Set<String> processedBeans = new HashSet<>(); //把后置处理器分成了两大类 // 具有注册BeanDefinition功能的后置处理器和没有注册功能的后置处理器 // 而且具有注册功能的后置处理器先执行 if (beanFactory instanceof BeanDefinitionRegistry) { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; // 普通的 BeanFactoryPostProcessor List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>(); // BeanDefinitionRegistryPostProcessor 具有注册功能的 List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>(); //调用beanFactory的后置处理器 BeanDefinitionRegistryPostProcessor //用户可以实现BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry 注册bean for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; // 执行那个具有注册功能的方法 registryProcessor.postProcessBeanDefinitionRegistry(registry); // 添加到集合中 后面会用到 registryProcessors.add(registryProcessor); } else { // 不具有注册功能的bean工厂后置处理器 regularPostProcessors.add(postProcessor); } } // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let the bean factory post-processors apply to them! // Separate between BeanDefinitionRegistryPostProcessors that implement // PriorityOrdered, Ordered, and the rest. // 保存本次要执行的BeanDefinitionRegistryPostProcessor List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>(); // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered. // 去容器中查询是否有实现了PriorityOrdered接口的 BeanDefinitionRegistryPostProcessor 根据类型去获取，上面已经把自己注入进去的BeanDefinitionRegistryPostProcessor 实现类执行了注册方法 // Spring可以通过三种方式实现排序 // 1:PriorityOrdered#getOrder 2:Orderd#getOrder 3: @Order 值越小优先级越高 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // 默认这里获取到ConfigurationClassPostProcessor 实现了BeanDefinitionRegistryPostProcessor // 默认的后置处理器会解析配置类，扫描注解 注入BeanDefinition 这个时候可能会扫描到我们以注解形式添加进来的 BeanDefinitionRegistryPostProcessor 实现类 ，会在下一步获取到 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); //执行过的添加到 processedBeans 集合中 后面会判断执行过不再执行 processedBeans.add(ppName); } } // 进行排序 sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); // 会调用 ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry // 解析注解 注册业务bean invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); // 清除 currentRegistryProcessors.clear(); // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered. // 获取实现Order的后置处理器 所以 PriorityOrdered的优先级高 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { 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); // 执行的注册的那个方法postProcessBeanDefinitionRegistry invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear. // 最后执行其他没有实现 PriorityOrdered Orderd 的接口 但是这里不是绝对的 因为在执行上面的 BeanDefinitionRegistryPostProcessors 实现类的时候 可能会手动注入的 BeanDefinitionRegistryPostProcessors 实现类 // 如果手动注入的实现类实现了 PriorityOrdered Orderd 也会在下面执行 boolean reiterate = true; // 之所以要循环执行 是因为 在执行的过程中可能会再注入 BeanDefinitionRegistryPostProcessor 所以一直循环执行 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(); } //=========================上面已经完成了 解析配置类（扫描 @Bean @Import） 手动注入的 接口方式注入的bean 的BeanDefinition注册================================================================================================================================= // Now, invoke the postProcessBeanFactory callback of all processors handled so far. // 调用ConfigurationClassPostProcessor#postProcessBeanFactory //增强@Configuration修饰的配置类 AppConfig-->AppConfig$$EnhancerBySpringCGLIB //增加了后置处理器 ConfigurationClassPostProcessor.ImportAwareBeanPostProcessor //调用用户自定义实现的 BeanDefinitionRegistryPostProcessors#postProcessBeanFactory // 具有注册功能的 后置处理器也有 postProcessBeanFactory 这个方法的 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); // 没有实现BeanDefinitionRegistryPostProcessor 接口的实现类调用 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); } else { // Invoke factory processors registered with the context instance. invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let the bean factory post-processors apply to them! // 这里又根据 BeanFactoryPostProcessor 类型获取一波 会得到所有的 bean工厂的后置处理器 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); // Separate between BeanFactoryPostProcessors that implement PriorityOrdered, // Ordered, and the rest. List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); List<String> orderedPostProcessorNames = new ArrayList<>(); List<String> 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); } } // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered. // 第一个执行的是 实现 BeanFactoryPostProcessors 和 PriorityOrdered 接口 sortPostProcessors(priorityOrderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); // Next, invoke the BeanFactoryPostProcessors that implement Ordered. // 第二个执行的是 实现 BeanFactoryPostProcessors 和 Ordered 接口 List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size()); for (String postProcessorName : orderedPostProcessorNames) { orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } sortPostProcessors(orderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); // Finally, invoke all other BeanFactoryPostProcessors. // 最后执行的是 普通的 BeanFactoryPostProcessors 实现类 List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size()); for (String postProcessorName : nonOrderedPostProcessorNames) { nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } 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(); }
第一步先走的是通过 getBeanFactoryPostProcessors() 方法得到后置处理器，而这个方法返回的是 this.beanFactoryPostProcessors 集合中的数据，这个里面的数据只有手动通过 applicationContextReg.addBeanFactoryPostProcessor(new BeanFactoryRegisterPostProcessro()); 添加才会到这个集合里面，所以首先执行的就是自己添加的bean工厂的后置处理器。
如果没有手动注册bean工厂后置处理器，就会执行spring自己添加的后置处理器: ConfigurationClassPostProcessor ，先执行 postProcessBeanDefinitionRegistry ，这个里面进行注解扫描得到所有注解相关的BeanDefinition，注意，只是扫描出来注册到容器中，并不会实例化。
第一次走到这里的时候，会把我们的配置封装成 ConfigurationClass 然后通过专门的解析器:ConfigurationClassParser 开始注解扫描。一生二，二生四......................
