Spring refresh - finishBeanFactoryInitialization

博文目录

---

生产 Bean 的流程

遍历 BeanName, 筛选符合条件的走 getBean 流程

refresh 的 finishBeanFactoryInitialization 方法开始生产所有的单例 Bean

• 遍历 beanDefinitionNames, 拿到对应的 BeanDefinition
• 逐一判断该 BeanDefinition 是否满足生产条件(非抽象&单例&非懒加载)
• 判断是不是 FactoryBean
  • 是, 先获取该 FactoryBean 实例 (getBean(&beanName)), 再看是不是需要使用该 FactoryBean 来获取 Bean (getBean(beanName))
  • 否, 获取 Bean (getBean(beanName))

doGetBean 流程

AbstractBeanFactory 的 getBean 方法开始获取某个单例 Bean

• 调用 doGetBean 方法
• 先调用 getSingleton 尝试从一级缓存中取 Bean, 有的话直接返回
• 没有的话, 尝试调用 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法, 看该 Bean 是否能走短路创建
• 不行的话, 调用 doCreateBean 走真正的生产 Bean 的流程

deCreateBean 流程

AbstractAutowireCapableBeanFactory 的 doCreateBean 方法开始真正生产 Bean

• 实例化: 就是通过工厂(@Bean)或反射(无参反射, 有参构造函数反射)等完成 Bean 从无到有的第一步. ObjectBean 是不是在这里生效?
• 填充属性: Bean 如果有 @Autowired / @Value 注解标注的属性, 则需要做自动填充, 主要由 AutowiredAnnotationBeanPostProcessor 来完成
• 初始化
  • 调用 BeanNameAware, BeanClassLoaderAware, BeanFactoryAware 的 set 方法
  • 调用所有 BeanPostProcessor 的 postProcessBeforeInitialization 方法
    • 其中有一个 ApplicationContextAwareProcessor, 会调用 EnvironmentAware, EmbeddedValueResolverAware, ResourceLoaderAware, ApplicationEventPublisherAware, MessageSourceAware, ApplicationContextAware 的 set 方法
    • 其中有一个 CommonAnnotationBeanPostProcessor, 会处理 @PostConstruct 注解, 会调用被该注解标注的方法
  • 调用 InitializingBean 的 afterPropertiesSet, 自定义的 init-method 方法
  • 调用所有 BeanPostProcessor 的 postProcessAfterInitialization 方法, AOP 动态代理就是在这里处理的

将 Bean 添加到一级缓存中

将成品 Bean 添加到一级缓存(单例池)中, 从二三级缓存中移除, 然后添加到保存已经处理过的 Bean 的 registeredSingletons 中

详细流程说明

类跳转

• org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization
  • org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
    • org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)
    • org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
      • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String)
      • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory<?>)
        • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
          • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation
          • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
            • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance
            • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
            • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
      • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingleton

AbstractApplicationContext#finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	
	// ...

	// Allow for caching all bean definition metadata, not expecting further changes.
	// 冻结所有 BeanDefinition, 将一个标记置为 true, 表示要开始生产 Bean 了
	beanFactory.freezeConfiguration();

	// Instantiate all remaining (non-lazy-init) singletons.
	// 实例化剩余的单例 Bean
	beanFactory.preInstantiateSingletons();
}

DefaultListableBeanFactory#preInstantiateSingletons

• 拿到所有的 BeanDefinition 的名字来遍历 BeanDefinition
• 如果这个 BeanDefinition 所代表的 Bean 不是抽象的, 是单例的, 不是懒加载的, 则走流程
  • 如果这个 BeanDefinition 所代表的 Bean 是 FactoryBean, 则判断是否需要提前初始化, 需要的话就走流程 getBean
  • 如果这个 BeanDefinition 所代表的 Bean 不是 FactoryBean, 就走流程 getBean

@Override
public void preInstantiateSingletons() throws BeansException {
	
	// ...

	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
	// 获取到所有的 BeanDefinition 的名字
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// Trigger initialization of all non-lazy singleton beans...
	// 遍历
	for (String beanName : beanNames) {

		// 通过 @Bean, @Component 等拿到的 BeanDefinition 都是不同的类型
		// 把不同类型的 BeanDefinition 都转换为统一的 RootBeanDefinition, 方便后续判断
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

		// 满足条件的 BeanDefinition 才会被加载
		// 条件: 不是抽象, 是单例, 不是懒加载
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

			// 判断是不是 FactoryBean, FactoryBean 这种 Bean 不是通过反射来实例化, 而是通过调用 getObject 来生产其他的 Bean
			if (isFactoryBean(beanName)) {

				// 通过 &beanName 的方式获取用于生产 Bean 的原始 FactoryBean 本身
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(
								(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {

				// 不是 FactoryBean 的话, 就调用 getBean 来生产 Bean
				getBean(beanName);
			}
		}
	}

	// ...
	
}

BeanFactory 和 FactoryBean 的区别

BeanFactory 是 Bean 工厂, FactoryBean 是一种特殊的 Bean, 这种类型的 Bean 不是通过反射来实例化, 而是通过调用其 getObject 方法, 通过编程的方式自行实现实例化

虽然名字很像容易混淆，但是完全2个东西

BeanFactory是Bean的工厂，spring的顶层核心接口，没有BeanFactory就没有Bean的存在，重要程度可想而知

FactoryBean也是一个接口，被他修饰的Bean将成为一个特殊的Bean, 原本的Bean将被隐藏，而是由FactoryBean的getObject返回最终的Bean

AbstractBeanFactory#getBean(String)

public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

AbstractBeanFactory#doGetBean

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {

	// 拿到真实的 BeanName, 这里传入的可能是别名或其他的
	String beanName = transformedBeanName(name);
	Object bean;

	// Eagerly check singleton cache for manually registered singletons.
	// 尝试去缓存中获取 Bean, 如果有的话直接返回, 没有的话再去创建
	// 其实就是去一级缓存(单例池,singletonObjects)中找
	Object sharedInstance = getSingleton(beanName);
	
	// ...

	// 缓存中没有该 Bean, 需要走创建流程
	
	// Check if bean definition exists in this factory.
	// 子父容器, 集成了 SpringMvc 后才有
	BeanFactory parentBeanFactory = getParentBeanFactory();
	
	// ...

	RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
	checkMergedBeanDefinition(mbd, beanName, args);

	// Guarantee initialization of beans that the current bean depends on.
	// 处理 dependsOn, 就是某个 Bean 必须在另一个 Bean 之前创建, 如果没有创建, 就先去创建那个 Bean
	String[] dependsOn = mbd.getDependsOn();
	if (dependsOn != null) {
		for (String dep : dependsOn) {
			if (isDependent(beanName, dep)) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
			}
			registerDependentBean(dep, beanName);
			try {

				// 优先去加载生产顺序排在当前 Bean 前面的 Bean
				getBean(dep);
			}
			catch (NoSuchBeanDefinitionException ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
			}
		}
	}

	// Create bean instance.
	if (mbd.isSingleton()) {

		// 这里的 getSingleton 和 上面的 getSingleton 不是同一个方法, 后者是从一级缓存中拿
		// 该方法传入了一段代码, 到合适的时机就会被回调执行
		sharedInstance = getSingleton(beanName, () -> {
			try {

				// 创建 Bean
				// getSingleton 里面调用 singletonFactory.getObject 的时候, 就会回调传入的 createBean 方法
				return createBean(beanName, mbd, args);
			}
			catch (BeansException ex) {
				// Explicitly remove instance from singleton cache: It might have been put there
				// eagerly by the creation process, to allow for circular reference resolution.
				// Also remove any beans that received a temporary reference to the bean.
				destroySingleton(beanName);
				throw ex;
			}
		});
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
	}

	// ...
			
	return (T) bean;
}

DefaultSingletonBeanRegistry#getSingleton

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	
	// ..

	// 把当前 BeanName 标记成为正在创建中(通过添加到 singletonsCurrentlyInCreation 这个 Set 里面)
	// 如果因为循环依赖而导致第二次要添加到 Set 中, 则添加将会失败, 貌似是处理循环依赖用的?
	// 这个方法里面, 如果添加 Set 失败的话, 会抛异常, 会不会打断 refresh 的流程
	beforeSingletonCreation(beanName);
	
	// ...

	// 执行传入代码的创建 Bean 的逻辑, 调用 createBean 方法
	singletonObject = singletonFactory.getObject();
	
	// ...
	
	// 将生成的 Bean 加入到缓存中
	// 加入到 一级缓存 和 用来记录保存已经处理过的 Bean 的 registeredSingletons
	// 从二三级缓存中移除
	addSingleton(beanName, singletonObject);

	return singletonObject;
		
}

AbstractAutowireCapableBeanFactory#createBean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {

	// ...
	
	// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
	// 调用 BeanPostProcessor
	// 这里是第一次调用 BeanPostProcessor
	// 通过调用 BeanPostProcessor 来尝试生成 Bean 对象, 如果这里成功生成 Bean 对象, 则会直接返回, 不会再走常规的创建流程
	// 不管是 cglib 还是 jdk, 通常不会在这里生成代理对象, 因为这里生成 Bean 的话, 还没有走填充的步骤, 不是完整的 Bean, 可能没法正常工作
	// 通常都是在 Bean 创建成功后的后置处理器中生成代理对象
	// 但是在这里会解析 AOP 切面信息进行缓存
	Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
	if (bean != null) {
		return bean;
	}
	
	// ...

	// 走真正的默认创建 Bean 的流程
	// 创建 Bean 的流程是 实例化 - 填充属性 - 初始化
	// Bean 实例化的流程是 BeanDefinition - BeanWrapper - Bean
	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
	if (logger.isTraceEnabled()) {
		logger.trace("Finished creating instance of bean '" + beanName + "'");
	}
	return beanInstance;
	
	// ...
	
}

AbstractAutowireCapableBeanFactory#doCreateBean

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {

	// Instantiate the bean.
	// BeanWrapper, 就是包装了一个 Bean, 提供了一些操作 bean 的方法
	// 提供用于分析和操作标准JavaBean的操作, 获得和设置属性值(单独或批量), 获取属性描述符以及查询属性的可读性的能力
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {

		// 实例化, 使用合适的方式, Bean 创建的第一步
		// 工厂方法(@Bean, 更灵活, 自己可以控制过程)
		// 反射(无参构造函数(class.newIns...), 有参构造函数(constructor.newIns..., @Autowired 构造器))
		// 方法链太长了, 先不看
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	Object bean = instanceWrapper.getWrappedInstance();
	
	// ...

	// Initialize the bean instance.
	Object exposedObject = bean;

	// 填充属性, Bean 创建的第二步, 调用 setter 方法赋值
	// 方法链太长了, 先不看
	populateBean(beanName, mbd, instanceWrapper);

	// 初始化, Bean 创建的第三步
	exposedObject = initializeBean(beanName, exposedObject, mbd);
	
	// ...

	// 默认单例 Bean 的生产流程走完
	return exposedObject;
}

AbstractAutowireCapableBeanFactory#createBeanInstance

Spring refresh - finishBeanFactoryInitialization - createBeanInstance 实例化

AbstractAutowireCapableBeanFactory#populateBean

Spring refresh - finishBeanFactoryInitialization - populateBean 填充属性

AbstractAutowireCapableBeanFactory#initializeBean(String, Object, RootBeanDefinition)

在这里插入代码片