一个Bean对象的创建流程 & IOC容器创建流程

一个Bean的创建

一、根据location生成并注册BeanDefinition

具体过程看这里

二、根据BeanDefinition创建Bean

• *如果是在容器初始化阶段，那么只会实例化 非延迟加载的、单例对象（通过遍历已注册的BeanDefinition）

• beanName再获取（transformedBeanName）

  • 如果beanName是加了&前缀的，说明是希望获取factorybean的，但是实际的factorybean在三级缓存里的存储是不带&前缀的，因此需要去掉&
  • 别名(alias)的替换

• 如果是单例对象的创建的话，那么尝试从多级缓存里获取Bean（getSingleton）

  • 只有单例对象通过setter方法进行注入的时候才会去尝试从三级缓存里获取bean，因为三级缓存存在的目的就是为了解决循环依赖的问题，因此，也只有是通过setter注入的单例子对象，才可以允许循环依赖的出现，其他情况的循环依赖都会抛异常.（例如构造器注入，或是setter注入的prototype类型）

• a. 如果获取到了的话，就尝试判断一下是否是factorybean，如果不是的话就直接返回bean对象，如果是的话，就调用getObject来返回Bean对象.

• b. 如果没获取到的话，就说明是prototype或者是singleton但还尚未创建，那么记下来就需要去创建Bean.

• 检查当前容器内是否存在需要创建的Bean的BeanDefinition，如果不存在的话就委托给父容器去创建，一层层的递归下去，直到ROOT。 如果存在的话，那么就继续.

• 检查是否存在depends-on的环依赖

• 根据scope不同类型以不同的策略去创建

  • singleton的情况，就直接去创建了
  • prototype的情况，需要在创建前调用一个回调函数，把当前要创建的Bean存到一个prototypeInCreation的集合里，用户之后出现环依赖时的检测…（因为singleton没这一步，所以集合里一定不会找到singleton的bean，也就不会抛异常, 而对于构造方法注入的singleton，好像是调用了不同的doCreateBean方法，其不会走三级缓存，所以依然不能支持循环依赖）
  • 其他情况，就是web领域的情况了，委托给web组件去实现.

• 处理 lookup-method 和 replace-method 配置，检查是否存在循环依赖，并完成 override method

• 回调实例化之前需要调用的后置处理器（实现了InstantiationAwareBeanPostProcessor接口的对象）

  • 如果在这个对象实例化了Bean对象的话，那么这个Bean对象可以作为结果返回！并且在返回前还要调用一下”实例化之后需要调用的接口方法“。
  • postProcessAfterInitialization 和 postProcessBeforeInitialization

• 如果执行完“初始化前需要执行的回调方法”之后，bean依然也没被创建，那么接下来就是正式的bean创建了。

• 创建主要分为：

  • 实例化
  • 填充(populate)
  • 回调

• 获取Class对象，然后根据其具体信息来选择实例化方法，例如是工厂方法，还是带有参数的构造器方法，还是无参构造方法。

• 实例化完对象之后，会调用回调方法，即实例化完之后需要回调的方法 postProcessAfterInitialization

• 然后进行数据的填充操作，例如AutoWired，Value等这种初始化的填充工作在这里进行。在填充时，如果需要填充的bean还没创建，就去创建. 实际上是用getBean去创建的，如果是prototype的情况，那么之前已经被放入prototypeInCreation集合里了，因此再递归回去的话，如果在集合中发现了，就说明出现了循环依赖，然后报错。 对于setter注入的单例情况，在递归的去getBean之前，会把当前正在创建的bean放到第三级缓存里，当因为循环依赖第二次访问到自己的时候，会在第三级缓存里hit到，就不会进入到下一次的循环递归里了，直接就返回了.

• popluate结束之后，就说明填充完了，然后进行一次回调

  • 先调用：Aware的processor，进行Aware接口放啊的回调
  • 然后调用：BeanPostProcessor的 在初始化之前需要调用的方法
  • 再调用：初始化方法init-method
  • 最后调用：BeanPostProcessor在初始化之后需要调用的方法

至此，Bean的创建就ok了…

---

IOC高级容器创建流程

以注解的方式为例子（与XML一些不同的地方会尽量标记出来）

• 调用父类构造方法，得到Reader和Scanner，以及DefaultListableBeanFactory.
• 对扫描输入的类的注解进行解析，然后生成BeanDefinition，并进行注册…
• 调用refresh：
  • sync加锁
  • prepareRefresh:
    • 做一些准备工作，准备工作包括设置启动时间，是否激活标识位
  • ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    • 是个抽象方法！
      • 一、在XML中：
        • 返回强大的DefaultListableBeanFactroy
        • 完成location -> Resource([]) -> <BeanName, BeanDefinition> -> 注册到容器中
        • 注册到容器中就是把<BeanName, BeanDefinition>信息添加到DefaultListableBeanFactroy里维护
          的一系列容器中，例如：BeanDefinitionMap
      • 二、在Annotation中：
        • 在之前已经完成了BeanFactory的生成，BeanDefinition流程的注册，
        • 所以这里只是进行一个序列化Id的填写… 几乎没做什么事情
  • prepareBeanFactory(beanFactory)
    • 主要就是注册了两个关键的后置处理器：

      • ApplicationContextAwareProcessor

        • 这个作用就不说了…不会的看这儿.

      • ApplicationListenerDetector:

        • 主要检查是否实现了ApplicationListener接口，如果实现了就加入当前的applicationContext的applicationListeners列表

      • 做了一些其他的事：

        • 例如给BeanFactory设置高级ApplicaitonContext的classloader这样beanfactory就能使用其功能了；
        • 例如设置了默认Autowired的类，使得在给ResourceLoader.class，ApplicationEventPublisher.class, ApplicationContext.class自动填装的时候，都是自动填装当前这个高级ApplicaitonContext；
        • 例如：对一些字节码进行织入…
        • 等等…
  • invokeBeanFactoryPostProcessors(beanFactory)
    • 做的主要事情就是：
      • 对BeanDefinitionRegistryPostProcessors和BeanFactoryPostProcessor
      • 进行排序，执行！根据PriorityOrdered, Ordered, 其他进行排序，同类的则根据优先级来排序…
      • 顺序详见

  public static void invokeBeanFactoryPostProcessors(
  		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  
  	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
  	Set<String> processedBeans = new HashSet<>();
  
  	// 因为ApplicationContext接口实现了 BeanDefinitionRegistry ，
  	// 所以肯定可以进入这个if
  	if (beanFactory instanceof BeanDefinitionRegistry) {
  		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  
  		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
  		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
  
  		// 自定义的beanFactoryPostProcessors
  		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
  			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
  				BeanDefinitionRegistryPostProcessor registryProcessor =
  						(BeanDefinitionRegistryPostProcessor) postProcessor;
  				registryProcessor.postProcessBeanDefinitionRegistry(registry);
  				registryProcessors.add(registryProcessor);
  			}
  			else {//BeanDefinitionRegistryPostProcessor  BeanfactoryPostProcessor
  				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.
  		// 这里不要去初始化FactoryBeans: 我们要在regular beans初始化之前，去调用factory-bean-post-processor
  		// 同时，在还要保证调用顺序：
  		// 		1. PriorityOrdered
  		//		2. Ordered
  		//	 	3. 其他
  
  
  		// 这个currentRegistryProcessors 放的是spring内部自己实现了BeanDefinitionRegistryPostProcessor接口的对象
  		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
  
  		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
  		// 一、先搞 BeanDefinitionRegistryPostProcessors
  
  		// 1.1 先搞实现了PriorityOrdered接口的那些BeanDefinitionRegistryPostProcessors
  		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);
  			}
  		}
  		//排序。因为PriorityOrdered里也是有有优先级的
  		sortPostProcessors(currentRegistryProcessors, beanFactory);
  		//合并
  		registryProcessors.addAll(currentRegistryProcessors);
  		//执行所有BeanDefinitionRegistryPostProcessor
  		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  		//执行完成了所有BeanDefinitionRegistryPostProcessor
  		//这个list只是一个临时变量，故而要清除
  		currentRegistryProcessors.clear();
  
  		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
  		// 1.2 再搞实现了Ordered接口的那些BeanDefinitionRegistryPostProcessors
  		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);
  			}
  		}
  		//排序。因为Ordered里也是有有优先级的
  		sortPostProcessors(currentRegistryProcessors, beanFactory);
  		// 合并
  		registryProcessors.addAll(currentRegistryProcessors);
  		// 执行
  		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  		// 清空临时变量
  		currentRegistryProcessors.clear();
  
  		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
  		// 1.3 最后调用剩余的BeanDefinitionRegistryPostProcessors
  		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();
  		}
  
  		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
  		// 其实就是挨个调用BeanFactoryPostProcessor的接口方法——postProcessBeanFactory
  		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
  		//自定义BeanFactoryPostProcessor
  		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
  	}
  
  	else {
  		// Invoke factory processors registered with the context instance.
  		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
  	}
  
  
  	// ====到目前为止，已经执行完了BeanDefinitionRegistryPostProcessors的回调====
  
  	// ====接下来该执行BeanFactoryPostProcessor的回调了！！====
  
  	// ====其逻辑和上面的类似，就不多赘述了====
  
  	// Do not initialize FactoryBeans here: We need to leave all regular beans
  	// uninitialized to let the bean factory post-processors apply to them!
  	//ConfigurationClassPostProcessor
  	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<>();
  	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<>();
  	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)

    • 用上面同样的排序方式，来注册BeanPostProcessor，用于日后回调

  • initMessageSource

    • 一些国际化配置，在不同地区的不同实现

  • initApplicationEventMulticaster

    • 初始化应用事件广播器（ApplicationEventMulticaster）
      • 如果已经存在事件监听器（EventMulticaster），那么就直接使用
      • 如果不存在，就手动创建. SimpleApplicationEventMulticaster. (它实现了ApplicationEventMulticaster接口)

  • registerListeners

    • Add beans that implement ApplicationListener as listeners.

  • finishBeanFactoryInitialization

    • 对非懒加载的单例Bean进行创建，也就上上面分析的一大通。（当然，实际实现细节更加复杂，上面只是简单分析了一下主要流程。。。

  • finishRefresh();

    • 缓存的清楚，发布一些相应的event，例如刷新结束的event…