您的位置：首页 > 编程语言 > Java开发

Spring IOC源码分析（七）：IOC容器的设计实现与bean对象的创建流程

2019-03-08 18:04 951 查看

一、IOC容器的设计与实现

1. 获取bean对象

spring主要通过BeanFactory接口的getBean方法来从IOC容器，即BeanFactory的实现类中获取某个bean对象实例，如下为BeanFactory的getBean方法定义：

public interface BeanFactory {

...

/**
* Return an instance, which may be shared or independent, of the specified bean.
* <p>This method allows a Spring BeanFactory to be used as a replacement for the
* Singleton or Prototype design pattern. Callers may retain references to
* returned objects in the case of Singleton beans.
* <p>Translates aliases back to the corresponding canonical bean name.
* Will ask the parent factory if the bean cannot be found in this factory instance.
* @param name the name of the bean to retrieve
* @return an instance of the bean
* @throws NoSuchBeanDefinitionException if there is no bean definition
* with the specified name
* @throws BeansException if the bean could not be obtained
*/

// getBean方法的其中一个版本
// 获取name对应的bean对象实例，如果是单例的则直接返回，原型的则每次创建一个新的bean对象实例
Object getBean(String name) throws BeansException;

...

}

在BeanFactory接口的具体实现类中，通过类型为ConcurrentHashMap的容器map来保存beanName和bean对象实例的映射。
在接口设计层面，BeanFactory接口并不直接定义该映射map，只是定义从该映射map获取bean对象的方法，而是抽象了一个BeanRegistry的概念，分别在SingletonBeanRegistry定义单例bean对象的映射map和在FactoryBeanRegistrySupport定义了由FactoryBean创建的bean对象的映射map；然后BeanFactory接口的具体实现类同时实现BeanFactory接口和BeanRegistry概念的接口SingletonBeanRegistry和FactoryBeanRegistrySupport，从而实现一个完整的IOC容器，类似于使用了一种读写分离的方式来进行接口拓展。

2. 注册bean对象

单例bean对象容器SingletonBeanRegistry：定义了registerSingleton注册bean对象到IOC容器中。

public interface SingletonBeanRegistry {

/**
* Register the given existing object as singleton in the bean registry,
* under the given bean name.
* <p>The given instance is supposed to be fully initialized; the registry
* will not perform any initialization callbacks (in particular, it won't
* call InitializingBean's {@code afterPropertiesSet} method).
* The given instance will not receive any destruction callbacks
* (like DisposableBean's {@code destroy} method) either.
* <p>When running within a full BeanFactory: <b>Register a bean definition
* instead of an existing instance if your bean is supposed to receive
* initialization and/or destruction callbacks.</b>
* <p>Typically invoked during registry configuration, but can also be used
* for runtime registration of singletons. As a consequence, a registry
* implementation should synchronize singleton access; it will have to do
* this anyway if it supports a BeanFactory's lazy initialization of singletons.
* @param beanName the name of the bean
* @param singletonObject the existing singleton object
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
* @see org.springframework.beans.factory.DisposableBean#destroy
* @see org.springframework.beans.factory.support.BeanDefinitionRegistry#registerBeanDefinition
*/
void registerSingleton(String beanName, Object singletonObject);

...

}

SingletonBeanRegistry接口实现类DefaultSingletonBeanRegistry

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

...

}

FactoryBean创建的bean对象容器FactoryBeanRegistrySupport：继承于DefaultSingletonBeanRegistry，映射map中的bean对象实例是通过调用FactoryBean的getObject方法获取的bean对象。

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {

/** Cache of singleton objects created by FactoryBeans: FactoryBean name to object. */
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);

...

}

3. 完整的IOC容器

BeanFactory的基础抽象实现类：AbstractBeanFactory，AbstractBeanFactory继承了以上的BeanFactory接口和
SingletonBeanRegistry接口。
```
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

...

}
```

二、IOC容器中bean对象的创建流程

在spring的体系结构设计当中，主要通过ApplicationContext来对外提供IOC服务，即与应用代码集成，而不是在应用代码中直接使用BeanFactory。通过ApplicationContext来初始化BeanFactory和从BeanFactory获取应用所需的bean对象。

1. ApplicationContext的生命周期

ApplicationContext的生命周期如下：具体在AbstractApplicationContext的refresh方法定义。

public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// 为beanFactory添加内部的BeanPostProcessor的bean对象等
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

// 从beanFactory的beanDefinitions中获取实现了BeanPostProcessor接口的beanDefinition，
// 然后创建bean对象，添加到beanFactory

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
initMessageSource();

// Initialize event multicaster for this context.
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
onRefresh();

// Check for listener beans and register them.
registerListeners();

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

// Last step: publish corresponding event.
finishRefresh();
}

...

}
}

在finishBeanFactoryInitialization方法是创建单例bean对象，在这里涉及到bean对象的整个创建流程。
bean对象的创建是在调用了BeanFactory的getBean方法触发的，即如果指定beanName的bean对象不存在，则开始创建该bean对象实例，如下为AbstractBeanFactory的getBean方法定义：
```
public Object getBean(String name) throws BeansException {

// doGetBean底层调用createBean方法创建bean对象实例
return doGetBean(name, null, null, false);
}
```

2. BeanFactory中普通bean对象的创建：不是FactoryBean创建的bean对象

注意以下过程是正常bean对象的创建过程，不是由FactoryBean创建bean对象的过程。FactoryBean创建bean对象是在自身的getObject方法实现的。

底层关于bean对象实例创建的核心方法为createBean：如下为AbstractAutowireCapableBeanFactory的createBean方法定义：核心过程为首先进行类加载，然后检查是否创建代理对象替代该bean对象，如果是则创建代理对象之间返回，否则进入bean对象的正常创建流程，具体在doCreateBean方法定义。

/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
* @see #doCreateBean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {

if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;

// 为给定bean进行类加载

// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}

// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}

try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.

// 调用InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation
// （如果创建了bean，则还要调用BeanPostProcessor的postProcessAfterInitialization）

// 调用用于生成AOP的代理对象的BeanPostProcessor，如果bean不为null，则说明产生代理对象了，可以直接返回
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
// 如果bean不为null ,则直接返回，这种情况通常为AOP创建了代理对象。后面的doCreateBean不再执行
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}

try {
// 正常的，非代理bean对象的创建
// 包括检查是否进行了类加载（没有则进行类加载），bean对象实例创建，bean对象实例的属性赋值，init-method的调用，BeanPostProcessor的调用
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}

doCreateBean方法定义一个完整bean对象的创建，在内部完成bean对象后置处理器BeanPostProcessor的调用，初始化相关的init-methdo和InitializingBean的afterPropertiesSet的调用：

// bean对象实例创建的核心实现方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {

// 使用构造函数或者工厂方法来创建bean对象实例
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}

// 修改BeanDefinition的BeanPostProcessor的执行，如合并其他BeanDefinition进来
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {

// 调用修改BeanDefinition的BeanPostProcessor，
// 即MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}

...

// 初始化bean对象实例，包括属性赋值，初始化方法，BeanPostProcessor的执行
// Initialize the bean instance.
Object exposedObject = bean;
try {

// 1. InstantiationAwareBeanPostProcessor执行:
// 	(1). 调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation,
//  (2). 调用InstantiationAwareBeanPostProcessor的postProcessProperties和postProcessPropertyValues
// 2. bean对象的属性赋值
populateBean(beanName, mbd, instanceWrapper);

// 1. Aware接口的方法调用
// 2. BeanPostProcess执行：调用BeanPostProcessor的postProcessBeforeInitialization
// 3. 调用init-method：首先InitializingBean的afterPropertiesSet，然后应用配置的init-method
// 4. BeanPostProcess执行：调用BeanPostProcessor的postProcessAfterInitialization
exposedObject = initializeBean(beanName, exposedObject, mbd);
}

...

// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}

return exposedObject;
}

3. FactoryBean创建的bean对象

FactoryBean接口在其getObject方法自定义bean对象的创建过程，而不是使用以上的createBean方法，故应用中配置的BeanPostProcessor，InitializingBean接口的方法等不会对FactoryBean创建的bean对象起作用。
这样设计也保证了spring自身可以利用FactoryBean接口来创建bean对象，如内部组件，而不会受到应用代码的影响。

4. 注册到IOC容器

单例bean对象

单例bean对象注册到IOC容器是在doGetBean方法内完成的，核心逻辑为getSingleton：调用createBean方法创建bean对象实例然后注册到单例bean对象映射map中。

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

// 创建bean对象实例并注册到单例bean映射map中
sharedInstance = getSingleton(beanName, () -> {
try {
// bean对象实例创建
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;
}
});

// 如果sharedInstance不是FactoryBean接口的实现类，则直接返回sharedInstance；
// 否则调用sharedInstance的getObject方法获取实际的bean对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

在getSingleton方法内调用addSingleton方法将该bean对象存放到单例bean对象映射map，即singletonObjects：

protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}

FactoryBean创建的bean对象

FactoryBean创建的bean对象，即调用FactoryBean的getObject方法返回的bean对象，注册到IOC容器（由FactoryBean创建的bean对象的映射map，即FactoryBeanRegistrySupport的factoryBeanObjectCache），也是在doGetBean方法中实现的，具体在FactoryBeanRegistrySupport的getObjectForBeanInstance方法实现。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航