代码

    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // 获取spring bean工厂
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            // 这个方法执行完成, spring的bean单例容器中会存在三个bean,
            // 分别是systemEnvironment, environment, systemProperties
            // 同时会添加ApplicationContextAwareProcessor的后置处理器, 这个处理器没有走
            // spring的bean初始化, 是在内部直接new出来的, 该处理器是用来处理实现了
            // ApplicationContextAware接口的bean, 调用重写的set方法, 所以可以利用
            // 这种方法获取spring的上下文对象
            prepareBeanFactory(beanFactory);

            try {
                // 该方法没有做任何事, 内部无任何逻辑
                postProcessBeanFactory(beanFactory);

                // 调用后置处理器, 此方法太重要了, 在后续的源码解读系列中会解析它
                // 先大致总结下它做了什么事
                // 1. 处理手动添加的BeanFactoryPostProcessor
                //   1.1 调用手动添加的BeanDefinitionRegistryPostProcessor, 并添加到存储它的集合中,
                //       该集合名字为: registryProcessors
                //   1.2 存储手动添加的BeanFactoryPostProcessor,
                //       该集合名字为: regularPostProcessors
                //   注意: 上面这个步骤是if else逻辑, 存了一个另外一个就不会存了
                // 2. 执行BeanDefinitionRegistryPostProcessor类型且实现了PriorityOrdered接
                //    口的后置处理器. 默认执行spring内置BeanDefinitionRegistryPostProcessor
                //    后置处理器(ConfigurationClassPostProcessor), 这个后置处理器执行完之后,
                //    所有能被扫描出来的bean都以BeanDefinition的方式注册到bean工厂了
                // 3. 执行BeanDefinitionRegistryPostProcessor类型且实现了
                //    Ordered接口的后置处理器
                // 4. 执行以@Component方式添加的BeanDefinitionRegistryPostProcessor类型没实现
                //    Ordered和PriorityOrdered接口的后置处理器
                // 5. 执行regularPostProcessors和registryProcessors数据结构中
                //    BeanFactoryPostProcessor类型的后置处理器(在此处执行
                //    ConfigurationClassPostProcessor类的postProcessBeanFactory方法, 主要是
                //    为全配置类生成了cglib代理类的Class对象, 并修改它的beanDefinition信息为代
                //    理类的信息
                // 6. 执行以@Component形式添加并实现了PriorityOrdered接口的BeanFactoryPost
                //    Processor后置处理器
                // 7. 执行以@Component形式添加并实现了Ordered接口的BeanFactoryPost
                //    Processor后置处理器
                // 8. 执行以@Component形式添加并未实现PriorityOrdered和Ordered接口的Bean
                //    FactoryPostProcessor后置处理器
                invokeBeanFactoryPostProcessors(beanFactory);

                // 注册spring bean工厂的BeanPostProcessor
                // 其中包括spring内置的、扫描出来的(eg: 使用ImportBeanDefinitionRegistrar, AOP的实现方式)、
                // 自己手动添加的(手动添加BeanDefinitionRegistryPostProcessor,
                // 并在其中注册一个BeanPostProcessor的bean)
                //
                // 默认情况下, spring内置的3个BeanPostProcessor分别为:
                //   org.springframework.context.annotation.internalAutowiredAnnotationProcessor   => 处理@Autowired注解的
                //   org.springframework.context.annotation.internalRequiredAnnotationProcessor  => 处理@Required注解的
                //   org.springframework.context.annotation.internalCommonAnnotationProcessor  => 处理Common注解的后置处理器
                // 以及各种实现了PriorityOrdered接口、Ordered接口的BeanPostProcessor处理
                // 最主要的就是把这些bean通过spring bean工厂创建出来, 并添加到一个存放BeanPostProcessor的list中, 再利用广播
                // 机制调用
                // 我觉得这里用list而不用set的原因有两个
                // 1. list是有序的, 因为有些BeanPostProcessor会实现PriorityOrdered接口、Ordered接口, 所以要按照一定的顺序执行
                // 2. 广播机制时要遍历集合, list遍历速度快一些
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                // 国际化
                initMessageSource();

                // Initialize event multicaster for this context.
                // 初始化spring事件驱动模型的执行者
                initApplicationEventMulticaster();

                // 该方法没有做任何事, 内部无任何逻辑
                onRefresh();

                // 注册自己手动添加的监听器和spring扫描出来的监听器
                // 手动添加的监听器: 调用spring上下文的addApplicationListener方法, eg: AnnotationConfigApplicationContext上下文的方法
                // spring扫描出来的监听器: 有@Component注解标识的监听器
                // 这里有人会问: 万一我一个监听器同时加了@Component注解也手动调用了addApplicationListener添加呢？
                // 没关系, 那就执行两次呗, 因为spring处理手动添加的和扫描出来的监听器是不一样的, 手动添加的是一个java 对象, 而spring扫描出来
                // 的监听器是一个bean, 所以这两个监听器是同一类型的不同对象
                // 但要注意的是, 手动添加的监听器是一个java object, 而spring扫描出来的是一个bean
                registerListeners();

                // 开始创建非抽象、非原型、非懒加载的bean 以及处理bean的自动装配
                finishBeanFactoryInitialization(beanFactory);

                // 完成刷新, 发布相应的事件
                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();
            }
        }
    }
    

invokeBeanFactoryPostProcessors

AbstractApplicationContext#invokeBeanFactoryPostProcessors
	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		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()));
		}
	}

invokeBeanFactoryPostProcessors

	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// 如果有的话，首先调用 BeanDefinitionRegistryPostProcessors。
		Set<String> processedBeans = new HashSet<>();

		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
//存储手动添加的BeanFactoryPostProcessor
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
//手动添加的BeanFactoryPostProcessor
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
					new LinkedList<>();
//一开始这个beanFactoryPostProcessors是空的，所以直接下面这个for循环不会走了
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
					registryPostProcessors.add(registryPostProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}
//不要在此处初始化 FactoryBeans：我们需要保留所有常规 bean 未初始化，
//以便让 bean 工厂后处理器应用于它们！将实现 PriorityOrdered、Ordered 和其余部分的 BeanDefinitionRegistryPostProcessor 分开。
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

			// new了一个给后置处理器排序的一个list
			List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
			registryPostProcessors.addAll(priorityOrderedPostProcessors);
			invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<>();
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(beanFactory, orderedPostProcessors);
			registryPostProcessors.addAll(orderedPostProcessors);
			invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
						registryPostProcessors.add(pp);
						processedBeans.add(ppName);
						pp.postProcessBeanDefinitionRegistry(registry);
						reiterate = true;
					}
				}
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			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!
		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.
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(beanFactory, orderedPostProcessors);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		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();
	}