spring ioc容器创建与bean初始化源码解析5：初始化所有剩余未初始化的单实例bean及最终完成容器创建

最新推荐文章于 2024-04-30 15:10:09 发布

const伐伐

最新推荐文章于 2024-04-30 15:10:09 发布

阅读量527

点赞数

分类专栏： spring ioc 阅读源码

本文链接：https://blog.csdn.net/u013905744/article/details/93716389

版权

阅读源码同时被 2 个专栏收录

18 篇文章 1 订阅

订阅专栏

spring ioc

12 篇文章 0 订阅

订阅专栏

1. beanFactory容器的创建及初始化

参考：spring ioc容器创建与bean初始化源码解析1：beanFactory容器的创建及初始化

2. 在beanFactory容器初始化之后定制和修改BeanFactory内容

参考：spring ioc容器创建与bean初始化源码解析2：在beanFactory容器初始化之后定制和修改BeanFactory内容

3. 注册BeanPostProcessor（作用在bean创建的过程中进行拦截，从而执行指定逻辑）

参考：spring ioc容器创建与bean初始化源码解析3：注册BeanPostProcessor（作用在bean创建的过程中进行拦截，从而执行指定逻辑）

4. 初始化MessageSource ApplicationEventMulticaster ApplicationListener

参考：spring ioc容器创建与bean初始化源码解析4：初始化MessageSource ApplicationEventMulticaster ApplicationListener

5. 初始化所有剩余未初始化的单实例bean及最终完成容器创建

参考：spring ioc容器创建与bean初始化源码解析5：初始化所有剩余未初始化的单实例bean及最终完成容器创建

6. spring ioc容器创建与bean初始化源码解析总结

参考：spring ioc容器创建与bean初始化源码解析总结

以下是第五篇

11. finishBeanFactoryInitialization(beanFactory);

初始化所有剩下的（因为之前的BeanPostProcessor Bean可能已经在前面初始化了）单实例bean；

// Instantiate all remaining (non-lazy-init) singletons.

finishBeanFactoryInitialization(beanFactory);

11.1 beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean

最主要的方法：

// Instantiate all remaining (non-lazy-init) singletons.

beanFactory.preInstantiateSingletons();

11.1 获取容器中的所有Bean，依次进行初始化和创建对象

List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

可能其中有些bean已经在前面创建好单例对象了

迭代一个副本，通过init方法，来注册新的bean definition

// Trigger initialization of all non-lazy singleton beans...

for (String beanName : beanNames) {

11.2 获取Bean的定义信息；RootBeanDefinition

RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

11.3 Bean不是抽象的，是单实例的，不是懒加载；

if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

11.3.1 判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；

if (isFactoryBean(beanName)) {

return (beanInstance instanceof FactoryBean);

11.3.2 不是工厂Bean。利用getBean(beanName);创建对象

getBean(beanName);

11.3.2.1 getBean(beanName)； ioc.getBean();

11.3.2.2 doGetBean(name, null, null, false);

11.3.2.3 先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）

从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取的

可以看到现在是17个bean

之后我们会添加一个beanName为blue的对象，后面会看到有18个bean

11.3.2.4 缓存中获取不到，开始Bean的创建对象流程；

// Check if bean definition exists in this factory.

BeanFactory parentBeanFactory = getParentBeanFactory();

特别是当springmvc与spring整合之后，就存在一些父子容器

11.3.2.5 标记当前bean已经被创建

markBeanAsCreated(beanName);

这样，当两个线程都要创建某个bean的时候，可以保证其单例

/**

 * Mark the specified bean as already created (or about to be created).

 * <p>This allows the bean factory to optimize its caching for repeated

 * creation of the specified bean.

 * @param beanName the name of the bean

 */

protected void markBeanAsCreated(String beanName) {

   if (!this.alreadyCreated.contains(beanName)) {

      synchronized (this.mergedBeanDefinitions) {

         if (!this.alreadyCreated.contains(beanName)) {

            // Let the bean definition get re-merged now that we're actually creating

            // the bean... just in case some of its metadata changed in the meantime.

            clearMergedBeanDefinition(beanName);

            this.alreadyCreated.add(beanName);

         }

      }

   }

}

11.3.2.6 获取Bean的定义信息；

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

11.3.2.7 获取当前Bean依赖的其他Bean；如果有按照getBean()把依赖的Bean先创建出来

// Guarantee initialization of beans that the current bean depends on.

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);

      getBean(dep);

   }

}

通过getBean(dep)来创建

11.3.2.8 启动单实例Bean的创建流程；

通过ObjectFactory的getObject来创建

// Create bean instance.

if (mbd.isSingleton()) {

   sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {

      @Override

      public Object getObject() throws BeansException {

         try {

            return createBean(beanName, mbd, args);

         }

11.3.2.8.1 createBean(beanName, mbd, args);

11.3.2.8.2 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象；

这块之前在spring AOP分析的时候分析过，如果有前面注册了的BeanPostProcessor是InstantiationAwareBeanPostProcessor的接口实现：那么这里会提前执行；

先触发：postProcessBeforeInstantiation()；

如果有返回值：再触发postProcessAfterInitialization()；

11.3.2.8.3 如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用下面11.3.2.8.4

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

11.3.2.8.4实际上创建指定的bean。

此时BeanPostProcessor的预创建处理已经执行完了，例如检查postProcessBeforeInstantiation的回调。

11.3.2.8.4.1 创建Bean实例

instanceWrapper = createBeanInstance(beanName, mbd, args);

使用适当的实例化策略为指定的bean创建新实例：工厂方法，构造函数自动装配或简单实例化。

Bean一定要是public的才能被创建

if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {

   throw new BeanCreationException(mbd.getResourceDescription(), beanName,

         "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());

}

if (mbd.getFactoryMethodName() != null)  {

   return instantiateUsingFactoryMethod(beanName, mbd, args);

}

通过工厂方法来初始化bean

protected BeanWrapper instantiateUsingFactoryMethod(

      String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {



   return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);

}

如果factory method不存在，那么就使用下面的方法来创建bean

if (resolved) {

   if (autowireNecessary) {

      return autowireConstructor(beanName, mbd, null, null);

   }

   else {

      return instantiateBean(beanName, mbd);

   }

}

autowire constructor（带有类型的构造函数参数），可以将构造函数中的参数注入

如果没有，就使用默认构造器

// Need to determine the constructor...

// No special handling: simply use no-arg constructor.

11.3.2.8.4.2 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

// Allow post-processors to modify the merged bean definition.

synchronized (mbd.postProcessingLock) {

   if (!mbd.postProcessed) {

      try {

         applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

      }

      catch (Throwable ex) {

         throw new BeanCreationException(mbd.getResourceDescription(), beanName,

               "Post-processing of merged bean definition failed", ex);

      }

      mbd.postProcessed = true;

   }

}

调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors

11.3.2.8.4.3 初始化bean实例

使用bean定义中的属性值填充给定BeanWrapper中的bean实例。

// Initialize the bean instance.

Object exposedObject = bean;

try {

   populateBean(beanName, mbd, instanceWrapper);

   if (exposedObject != null) {

      exposedObject = initializeBean(beanName, exposedObject, mbd);

   }

}

赋值之前：

11.3.2.8.4.3.1 拿到InstantiationAwareBeanPostProcessor后置处理器；

if (bp instanceof InstantiationAwareBeanPostProcessor) {

   InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

   if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {

      continueWithPropertyPopulation = false;

      break;

   }

}

执行postProcessAfterInstantiation()方法

11.3.2.8.4.3.2 再次拿到InstantiationAwareBeanPostProcessor后置处理器；

if (bp instanceof InstantiationAwareBeanPostProcessor) {

   InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

   pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

   if (pvs == null) {

      return;

   }

}

执行postProcessPropertyValues()方法

以上都是赋值之前

之后进行赋值

11.3.2.8.4.3.3 应用Bean属性的值；为属性利用setter方法等进行赋值；

applyPropertyValues(beanName, mbd, bw, pvs);

11.3.2.8.4.3.4 初始化bean

initializeBean(beanName, exposedObject, mbd);

if (exposedObject != null) {

   exposedObject = initializeBean(beanName, exposedObject, mbd);

}

11.3.2.8.4.3.4.1 执行Aware接口方法

invokeAwareMethods(beanName, bean);

private void invokeAwareMethods(final String beanName, final Object bean) {

   if (bean instanceof Aware) {

      if (bean instanceof BeanNameAware) {

         ((BeanNameAware) bean).setBeanName(beanName);

      }

      if (bean instanceof BeanClassLoaderAware) {

         ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());

      }

      if (bean instanceof BeanFactoryAware) {

         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);

      }

   }

}

判断是否实现了BeanNameAware BeanClassLoaderAware BeanFactoryAware

11.3.2.8.4.3.4.2 执行后置处理器初始化之前

wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

11.3.2.8.4.3.4.3

【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);

invokeInitMethods(beanName, wrappedBean, mbd);

通过check这个bean是否实现了InitializingBean或定义了custom init method，来给bean设置所有的属性

11.3.2.8.4.3.4.3.1 是否是InitializingBean接口的实现；执行接口规定的初始化；

boolean isInitializingBean = (bean instanceof InitializingBean);

11.3.2.8.4.3.4.3.2 是否自定义初始化方法；

invokeCustomInitMethod(beanName, bean, mbd);

11.3.2.8.4.3.4.4 执行后置处理器初始化之后


wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

applyBeanPostProcessorsAfterInitialization

BeanPostProcessor.postProcessAfterInitialization()；

11.3.2.8.4.3.4.5 注册Bean的销毁方法；

// Register bean as disposable.

try {

   registerDisposableBeanIfNecessary(beanName, bean, mbd);

}

11.3.2.8.4.3.5 将创建的Bean添加到缓存中singletonObjects；

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory<?>)

/** Cache of singleton objects: bean name --> bean instance */

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

if (newSingleton) {

   addSingleton(beanName, singletonObject);

}

将给定的singleton对象添加到此工厂的singleton缓存中

protected void addSingleton(String beanName, Object singletonObject) {

   synchronized (this.singletonObjects) {

      this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));

      this.singletonFactories.remove(beanName);

      this.earlySingletonObjects.remove(beanName);

      this.registeredSingletons.add(beanName);

   }

}

可以看到，添加了一个名为blue的Bean

ioc容器就是这些Map；很多的Map里面保存了单实例Bean，环境信息....

bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

获取给定bean实例的对象，或者是bean instance自身，如果是FactoryBean，那就是此factoryBean创建的object

// Now we have the bean instance, which may be a normal bean or a FactoryBean.

// If it's a FactoryBean, we use it to create a bean instance, unless the

// caller actually wants a reference to the factory.

if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {

   return beanInstance;

}

所有Bean都利用getBean创建完成以后；

org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons

对于所有的applicable bean，触发器post-initialization callback

// Trigger post-initialization callback for all applicable beans...

for (String beanName : beanNames) {

   Object singletonInstance = getSingleton(beanName);

   if (singletonInstance instanceof SmartInitializingSingleton) {

      final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;

      if (System.getSecurityManager() != null) {

         AccessController.doPrivileged(new PrivilegedAction<Object>() {

            @Override

            public Object run() {

               smartSingleton.afterSingletonsInstantiated();

               return null;

            }

         }, getAccessControlContext());

      }

      else {

         smartSingleton.afterSingletonsInstantiated();

      }

   }

}

检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；

12. finishRefresh();

完成BeanFactory的初始化创建工作；IOC容器就创建完成；


// Last step: publish corresponding event.

finishRefresh();

12.1 initLifecycleProcessor();

初始化和生命周期有关的后置处理器；LifecycleProcessor

public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";

默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();

加入到容器；

写一个LifecycleProcessor的实现类，可以在LifecycleProcessor（其是一个BeanFactory）

void onRefresh();

void onClose();

中进行一些动作

12.2 getLifecycleProcessor().onRefresh();

拿到前面定义的生命周期处理器LifecycleProcessor（BeanFactory）；回调onRefresh()；

12.3 publishEvent(new ContextRefreshedEvent(this));

发布容器刷新完成事件；

12.4 liveBeansView.registerApplicationContext(this);

const伐伐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录