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

spring容器创建及bean初始化过程

分为6个部分

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初始化源码解析总结

 

以下是第一篇

spring就是通过org.springframework.context.support.AbstractApplicationContext#refresh方法来创建容器并初始化所有的bean

1. prepareRefresh()

刷新前的预处理;

// Prepare this context for refreshing.

prepareRefresh();

准备这个context来进行刷新，设置其startup date以及active flag，并执行property sources的初始化

1.1 initPropertySources()初始化一些属性设置;子类自定义个性化的属性设置方法；

比如说我们自己写一个AnnotationConfigApplicationContext的子类 来override initPropertySources方法

// Initialize any placeholder property sources in the context environment

initPropertySources();

1.2 getEnvironment().validateRequiredProperties();检验属性的合法等（验证标记为必需的属性是否可解析）

// Validate that all properties marked as required are resolvable

// see ConfigurablePropertyResolver#setRequiredProperties

getEnvironment().validateRequiredProperties();

1.3 earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件；

// Allow for the collection of early ApplicationEvents,

// to be published once the multicaster is available...

this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();

 

2. obtainFreshBeanFactory();

获取BeanFactory（让子类来刷新内部bean工厂）

// Tell the subclass to refresh the internal bean factory.

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

设置一个序列化的id

this.beanFactory.setSerializationId(getId());

 

2.1 refreshBeanFactory();刷新 创建了BeanFactory对象；

 

org.springframework.beans.factory.support.DefaultListableBeanFactory

/**

 * Create a new GenericApplicationContext.

 * @see #registerBeanDefinition

 * @see #refresh

 */

public GenericApplicationContext() {

   this.beanFactory = new DefaultListableBeanFactory();

}

 

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

为序列化目的指定一个id，如果需要，允许将此BeanFactory从此id反序列化回BeanFactory对象。

public void setSerializationId(String serializationId) {

   if (serializationId != null) {

      serializableFactories.put(serializationId, new WeakReference<DefaultListableBeanFactory>(this));

   }

   else if (this.serializationId != null) {

      serializableFactories.remove(this.serializationId);

   }

   this.serializationId = serializationId;

}

2.2 getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象；

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

 

2.3 将创建的BeanFactory【DefaultListableBeanFactory】返回；

/**

 * Return the single internal BeanFactory held by this context

 * (as ConfigurableListableBeanFactory).

 */

@Override

public final ConfigurableListableBeanFactory getBeanFactory() {

   return this.beanFactory;

}

 

流程图：beanFactory就是spring中的一种容器了

3. prepareBeanFactory(beanFactory);

BeanFactory的预准备工作（对BeanFactory进行一些设置）；

3.1 设置BeanFactory的类加载器、支持表达式解析器...

beanFactory.setBeanClassLoader(getClassLoader());

beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

3.2 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

 

3.3 设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；

beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);

beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);

beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);

beanFactory.ignoreDependencyInterface(MessageSourceAware.class);

beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

 

3.4 注册可以解析的自动装配；我们能直接在任何组件中自动注入autowiring：

BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext

beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);

beanFactory.registerResolvableDependency(ResourceLoader.class, this);

beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);

beanFactory.registerResolvableDependency(ApplicationContext.class, this);

 

3.5 添加BeanPostProcessor【ApplicationListenerDetector】

// Register early post-processor for detecting inner beans as ApplicationListeners.

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

 

3.6 添加编译时的AspectJ支持；目前beanFactory容器中并没有name=loadTimeWeaver的bean，所以直接跳过

// Detect a LoadTimeWeaver and prepare for weaving, if found.

if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

   beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

   // Set a temporary ClassLoader for type matching.

   beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

}

 

3.7 给BeanFactory中注册一些能用的environment组件；

名字是environment，类型是ConfigurableEnvironment

名字是systemProperties类型是Map<String, Object>

                   systemEnvironment类型是Map<String, Object>

以后如果要使用，也可以autowire

// Register default environment beans.

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

}

 

到这一步，我们的beanFactory容器就已经创建好了，并对其中的一些属性进行了设置

4. postProcessBeanFactory(beanFactory);

BeanFactory准备工作完成后进行的后置处理工作（允许在上下文子类中对bean工厂进行post-processing）；

// Allows post-processing of the bean factory in context subclasses.

postProcessBeanFactory(beanFactory);

 

4.1 子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置

ResourceAdapterApplicationContext类图

org.springframework.jca.context.ResourceAdapterApplicationContext#postProcessBeanFactory

@Override

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

   beanFactory.addBeanPostProcessor(new BootstrapContextAwareProcessor(this.bootstrapContext));

   beanFactory.ignoreDependencyInterface(BootstrapContextAware.class);

   beanFactory.registerResolvableDependency(BootstrapContext.class, this.bootstrapContext);



   // JCA WorkManager resolved lazily - may not be available.

   beanFactory.registerResolvableDependency(WorkManager.class, new ObjectFactory<WorkManager>() {

      @Override

      public WorkManager getObject() {

         return bootstrapContext.getWorkManager();

      }

   });

}

 

 

以上这4步就是BeanFactory的创建及预准备工作