之前分别在Spring源码分析之IOC (二)和Spring源码分析之IOC (三)中分析了spring解析和注册自定义标签的代码，最终转化为BeanDefinition保存在IOC容器的beanDefinitionMap中，本篇接着 Spring源码分析之IOC (一)继续往下分析。
如上图注释：prepareBeanFactory是对Spring容器进行功能补充，设置classLoader、解析器、注册beanPostProcessor、环境设置等,没有其他的特殊逻辑。以下是该方法中对应的代码
/**
* Configure the factory's standard context characteristics,
* such as the context's ClassLoader and post-processors.
* @param beanFactory the BeanFactory to configure
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//设置beanFactory相关功能属性，调用父类AbstractBeanFactory的set方法，供所有继承的子类使用
//BeanClassLoader(类加载器)、BeanExpressionResolver(Spring EL表达式解析器)、PropertyEditorRegistrar(Spring扩展点，添加一个属性编辑器的注册器)
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 配置Aware的前置处理器ApplicationContextAwareProcessor，
// 同时设置ignoreDependencyInterface，在bean自动装配时就会被忽略这六个Aware接口
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
//设置依赖注入的值，保存到resolvableDependencies中，底层是Map结构，将
//BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext类型作为key,对应的beanFactory等作为value
//在自动注入的时候，如果遇到是BeanFactory等这些类型的就自动注入为当前映射的value值，如果不这么做，比如BeanFactory是有多个实现类的，
//spring在自动注入的时候是不知道该注入哪一个，就会抛出异常，同理，如果我们一个接口如果有多个实现类，在设置自动注入的时候，也是会报错
//这个时候就需要指明到底需要注入哪个实现类
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
//ApplicationListenerDetector实现了BeanPostProcessor，主要左右是在bean实例化时，如果bean属于ApplicationListener
//则将bean加入到IOC容器的applicationListeners变量中
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
//LoadTimeWeaverAwareProcessor用于AOP，也是dBeanPostProcessor，在bean实例化时设置LoadTimeWeaver属性
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
//设置默认的系统属性到IOC容器总，分别是environment、systemProperties、systemEnvironment
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}接着往下看，refresh()方法使用的是设计模式中的模板模式，而postProcessBeanFactory(beanFactory)方法就是留给子类去扩展的，设置一些自己特有的业务需求。
继续看invokeBeanFactoryPostProcessors(beanFactory)方法，该方法是执行已经提前注册的工厂处理器,进入invokeBeanFactoryPostProcessors中可以看到主要是委托给PostProcessorRegistrationDelegate去执行invokeBeanFactoryPostProcessors。
//实例化并调用所有注册的BeanFactoryPostProcessor，必须在单例实例化之前调用。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//PostProcessorRegistrationDelegate是AbstractApplicationContext委托执行post processors任务的工具类
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()));
}
}继续进入PostProcessorRegistrationDelegate的 invokeBeanFactoryPostProcessors方法中，注释很详细，没有对postProcessBeanDefinitionRegistry和postProcessBeanFactory进行深入研究，感兴趣的话可以一步一步debug看下，重点关注ConfigurationClassPostProcessor，该类扫描了应用中的所有可被注册的bean，并加载到容器中。
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
//processedBeans用于过滤执行过的BeanFactoryPostProcessor，已经执行过的都会添加到该集合中，来保证不会重复执行
Set<String> processedBeans = new HashSet<>();
//beanFactory为DefaultListableBeanFactory，是BeanDefinitionRegistry的子类，进入if代码块
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
//普通的BeanFactoryPostProcessor类集合
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
//BeanDefinitionRegistryPostProcessor类集合，BeanDefinitionRegistryPostProcessor继承BeanFactoryPostProcessor类
//比如后面ConfigurationClassPostProcessor会给Configuration类进行功能增强，如替换了Configuration类的class引用等
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
//如果BeanDefinitionRegistryPostProcessor，执行postProcessBeanDefinitionRegistry方法，主要是给registry增加功能类
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
//currentRegistryProcessors为实现了PriorityOrdered, Ordered接口的BeanDefinitionRegistryPostProcessor集合，会先执行实现PriorityOrdered，再执行实现Ordered的接口
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 首先，执行实现了PriorityOrdered的BeanDefinitionRegistryPostProcessors，此时只有一个ConfigurationClassPostProcessor；
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.addAll(currentRegistryProcessors);
//currentRegistryProcessors中此时只有ConfigurationClassPostProcessor类,开始执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法，
//即ConfigurationClassPostProcessor类的postProcessBeanDefinitionRegistry方法， 此类在spring中起着非常重要的角色
//主要是用来解析@PropertySource、@ComponentScans、@Import、@Bean等注解,将有@Service，@Component等注解的类全部解析成BeanDefine保存到beanFactory中
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清除实现了PriorityOrdered，开始保存实现Ordered的BeanDefinitionRegistryPostProcessor
currentRegistryProcessors.clear();
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);
//开始执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法，此时currentRegistryProcessors是个空集合
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
//最后执行所有剩余的BeanDefinitionRegistryPostProcessors接口
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//如果之前已经执行过，就过滤掉，默认是没有其他的BeanDefinitionRegistryPostProcessors可以执行了，但是如果接入了第三方，此时可能会执行第三方的BeanDefinitionRegistryPostProcessors
//比如接入了dubbo，就会执行DubboConfigAliasPostProcessor等
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();
}
//开始执行BeanFactoryPostProcessor的postProcessBeanFactory方法，比如ConfigurationClassPostProcessor会在这一步会通过ConfigurationClassEnhancer的enhance方法增强应用中的Configuration对象，替换class引用等
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
//上面是执行了BeanDefinitionRegistryPostProcessor的扩展方法，接下来执行BeanFactoryPostProcessor的扩展方法，
// 当然BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，所以会通过processedBeans去过滤掉
// 这里执行也是更上面一样，先执行先执行实现PriorityOrdered，再执行实现Ordered的接口，最后再执行没有实现该排序的BeanFactoryPostProcessor类
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(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement 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.
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();
}继续根据主流程往下看registerBeanPostProcessors(beanFactory)，往beanFacatory中注册BeanPostProcessor,在getBean的时候调用，属于spring的一个扩展，用来在创建bean的过程中对bean进行一些自定义设置，进入该方法，发现依然是交给PostProcessorRegistrationDelegate来处理。
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//委托给PostProcessorRegistrationDelegate处理
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}继续进入registerBeanPostProcessors方法中发现最终都是beanFactory.addBeanPostProcessor，且有顺序的add，保证后面创建bean的时候以此执行BeanPostProcessor的扩展方法。
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
//注册BeanPostProcessorChecker，在执行链最开始的位置，用来在执行整个链时打印日志
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
//同之前的invokeBeanFactoryPostProcessors一样，先注册实现了PriorityOrdered的BeanPostProcessor，接着是Ordered，最后是普通的BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先, 注册实现了PriorityOrdered的BeanPostProcessors
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 接着, 注册普通的BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 最后, 注册所有MergedBeanDefinitionPostProcessor处理器，在创建bean的时候放到最后执行
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 注册ApplicationListenerDetector
// moving it to the end of the processor chain (for picking up proxies etc). 放到执行链末尾执行
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}继续沿着主线走，initMessageSource()，顾名思义是初始化MessageSource,主要是通过配置，后面可以在容器中直接获取相应的资源信息，项目中很少用的，就不多说了。
紧接着是initApplicationEventMulticaster()，初始化事件广播器，spring有一套事件广播监听机制，这里就是先初始化下广播器，后面通过multicastEvent方法来发布事件，也不用多说。
然后onRefresh()也是需要子类去实现的，跳过。
接着就是registerListeners()，注册监听器，就是从刚刚初始化的事件广播器中添加Listeners，以下是根据debug展示的监听器
再接下来就是实例化所有已经在容器中解析的BeanDefinition.这个我们留到下一篇再分析。
2279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
