Spring源码解析之初始化

public abstract class AbstractApplicationContext.java

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 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();
			}

			catch (BeansException ex) {
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}
		}
	}

②invokeBeanFactoryPostProcessors(beanFactory);

<pre name="code" class="java">/**
 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
 * respecting explicit order if given.
 * <p>Must be called before singleton instantiation.
 */
rotected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
	Set<String> processedBeans = new HashSet<String>();
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;</span>
		// 创建BeanFactoryPostProcessor类型的list，存放普通后处理器
		List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
		// 创建list，存放存放实现了BeanDefinitionRegistryPostProcessor的后处理器（MapperScannerConfiger）
		List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
				new LinkedList<BeanDefinitionRegistryPostProcessor>();
		// getBeanFactoryPostProcessors()拿到的是空
		for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryPostProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
				registryPostProcessors.add(registryPostProcessor);
			}
			else {
				regularPostProcessors.add(postProcessor);
			}
		}
		// 获取所有BeanDefinitionRegistryPostProcessor类型的bean后处理器
		Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
				beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
		/ 获取到上面后处理器的所有实例
		List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =
				new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());
		// 将后处理器实例排序
		OrderComparator.sort(registryPostProcessorBeans);
		// 执行所有BeanDefinitionRegistryPostProcessor类型后处理器的方法
		// eg. MapperScannerConfiger的postProcessBeanDefinitionRegistry()方法用来扫描Mybatis的mapper和对应dao接口
		for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
			postProcessor.postProcessBeanDefinitionRegistry(registry);
		}
		// 调用上面list的postProcessBeanFactory()方法（此方法继承自BeanFactoryPostProcessor)
		invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);</span>
		// BeanDefinitionRegistryPostProcessor类型的bean的名字加入到processedBeans
		processedBeans.addAll(beanMap.keySet());
	}
	else {
		// Invoke factory processors registered with the context instance.
		invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
	}

	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!</span>
	// 获取所有BeanFactoryPostProcessor类型的后处理器
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.</span>
	// 存放实现了PriorityOrdered、Ordered和两个都没的BeanFactoryPostProcessor
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
	List<String> orderedPostProcessorNames = new ArrayList<String>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
	for (String ppName : postProcessorNames) {
		if (processedBeans.contains(ppName)) {
			// skip - already processed in first phase above	
						// 已经在上面处理过的类型，不再做处理
		}
		else if (isTypeMatch(ppName, PriorityOrdered.class)) {
			// 添加到priorityOrderedPostProcessors
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		else if (isTypeMatch(ppName, Ordered.class)) {
			// 添加到orderedPostProcessorNames
			orderedPostProcessorNames.add(ppName);
		}
		else {
			// 添加到nonOrderedPostProcessorNames
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.</span>
	// 排序后执行postProcessBeanFactory（）方法
	OrderComparator.sort(priorityOrderedPostProcessors);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.</span>
	// 排序后执行postProcessBeanFactory（）方法</span>
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	OrderComparator.sort(orderedPostProcessors);
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	// Finally, invoke all other BeanFactoryPostProcessors.</span>
	// 排序后执行postProcessBeanFactory（）方法</span>
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}

③registerBeanPostProcessors(beanFactory);

/**
 * Instantiate and invoke all registered BeanPostProcessor beans,
 * 实例化并且调用所有已注册的bean后处理器，如果处理器有定义order则按照给定的顺序执行BeanPostProcessor
 * respecting explicit order if given.
 * <p>Must be called before any instantiation of application beans.
 */
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {</span>
	// 获取所有BeanPostProcessor类型的bean名称
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	// Register BeanPostProcessorChecker that logs an info message when
	// a bean is created during BeanPostProcessor instantiation, i.e. when
	// a bean is not eligible for getting processed by all BeanPostProcessors.</span>
	// 注册BeanPostProcessorChecker，它可以打印BeanPostProcessor实例化过程中创建bean的日志信息
	// 计算已注册的bean + 1 +上面获取到的bean的数量，1是即将创建的BeanPostProcessorChecker
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// Separate between BeanPostProcessors that implement PriorityOrdered,Ordered, and the rest.
	// 按照优先的、排序的、无排序的进行分组排序，其中优先bean多了MergedBeanDefinitionPostProcessor类型(merged bean definition)
	List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
	List<String> orderedPostProcessorNames = new ArrayList<String>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
	for (String ppName : postProcessorNames) {
		if (isTypeMatch(ppName, PriorityOrdered.class)) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		else if (isTypeMatch(ppName, Ordered.class)) {
		// ③-1
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// First, register the BeanPostProcessors that implement PriorityOrdered.
	// </span>注册优先Order的后处理器
	OrderComparator.sort(priorityOrderedPostProcessors);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// Next, register the BeanPostProcessors that implement Ordered.</span>
	// 注册实现Ordered的后处理器，这里有个疑问，为什么不在③-1直接调用beanFactory.getBean并且判断MergedBeanDefinitionPostProcessor？
	List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
	for (String ppName : orderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		orderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	OrderComparator.sort(orderedPostProcessors);
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);

	// Now, register all regular BeanPostProcessors.</span>
	// 注册常规后处理器
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

	// Finally, re-register all internal BeanPostProcessors.</span>
	// 最后注册MergedBeanDefinitionPostProcessor类型的后处理器
	OrderComparator.sort(internalPostProcessors);
	registerBeanPostProcessors(beanFactory, internalPostProcessors);
	// 注册BeanPostProcessor：ApplicationListenerDetector，这个是AbstractApplicationContext的内部类
	// 实现了MergedBeanDefinitionPostProcessor接口，这个类只是暂时知道是在处理ApplicationListener
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());
}