目录
前言
看了这么久，终于将Bean的初始化流程看完了，整个初始化流程异常复杂，之前的博客介绍了BeanDefinition家族、DefaultSingletonBeanRegistry，这些都是为介绍Bean的初始化做准备的，在初始化过程中，并不会运用到BeanDefinition的所有属性
源头
在ContextLoaderListener中，可以看到容器启动后会执行refresh方法，这个方法会执行finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)方法，这里会初始化Bean，如下：
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext, DisposableBean {
beanFactory是DefaultListableFactory类型
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
......// 省略
// 源头在这里
beanFactory.preInstantiateSingletons();
}
}preInstantiateSingletons方法
这个方法在DefaultListableBeanFactory中实现：
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// 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.
拷贝一份的目的是允许DefaultListableFactory注册新的BeanDefinition，在常规Bean初始化中，
由于spring是单线程初始化Bean，拷不拷贝其实没差，这里这么做，可能是为以后多线程初始化打基础吧
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
由此可见，初始化时，使用的统一视图是RootBeanDefinition，这里可以看到spring对于具有继承关系的Bean的处理方式——首先初始化父BeanDefinition，
接着将子BeanDefinition的内容覆盖父BeanDefinition的内容
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
非抽象、非单例、非懒加载，进行初始化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
工厂类与非工厂类分开处理，原因下面讲
if (isFactoryBean(beanName)) {
这里使用getBean（String beanName）方法初始化Bean，我们平常也是通过getBean（String beanName）方法获得我们想要的Bean，
这两个方法是一样的，为了获得工厂类对象，通常会在工厂类的beanName前添加&符号，基于此，初始化时需要区分工厂类、非工厂类，
工厂类需要加上&，表示初始化工厂类，而不是获得工厂类生产的对象
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
如果工厂类继承了SmartFactoryBean，并且isEagerInit()返回True，则在初始化工厂类之后，立刻初始化产品类
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 {
非工厂类无需什么判断，直接初始化
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
在初始化Bean之后，若Bean继承了SmartInitializingSingleton，则调用相应的生命周期回调
for (String beanName : beanNames) {
请查看DefaultSingletonBeanRegistry篇的getSingleton
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
getBean(String beanName)
这个方法在DefaultListableBeanFactory中实现
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}doGetBean
这个方法在AbstractBeanFactory中实现
/**
* Return an instance, which may be shared or independent, of the specified bean.
* @param name the name of the bean to retrieve
* @param requiredType the required type of the bean to retrieve
* @param args arguments to use when creating a bean instance using explicit arguments
* (only applied when creating a new instance as opposed to retrieving an existing one)
* @param typeCheckOnly whether the instance is obtained for a type check,
* not for actual use
* @return an instance of the bean
* @throws BeansException if the bean could not be created
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
将别名转换为Bean的id名
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
请查看DefaultSingletonBeanRegistry的getSingleton方法，如果Bean已经实例化了，
则直接返回Bean，在容器初始化后，我们使用getBean方法，就是在这里返回
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
在IOC容器初始化完毕后，对于工厂类，使用getBean返回的是工厂的生产类，如果beanName含有&号，则获得工厂类，
假设单例非懒加载工厂类名字为a，IOC容器初始化后，当我们使用getBean("a")时，
便会在这个位置执行这个方法，返回工厂类的生产类
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
非单例循环依赖的处理：通过 ThreadLocal实现（维护了正在创建的 beanName）
通过将正创建的 beanName 放置于 ThreadLocal 中（见 beforePrototypeCreation），
在创建结束后会将 ThreadLocal 中对应 beanName 移除（见 afterPrototypeCreation），
如果创建期间发现某个Bean的依赖也正处于创建状态（在ThreadLocal中可以找到），说明出现循环依赖，会抛异常；
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
从父容器中获得Bean
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
由getBean参数可知IOC容器初始化时，typeCheckOnly值为false，所以会进入到这个if语句中
if (!typeCheckOnly) {
标记Bean正在创建
markBeanAsCreated(beanName);
}
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
校验如果是抽象类会抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
对于depends-on属性的值，优先进行初始化，这里会进行循环依赖的检查
仅限于通过depends-on属性形成的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 {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
创建单例Bean
if (mbd.isSingleton()) {
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;
}
});
该方法作用同上
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
创建scope为prototype的Bean
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
将beanName放入ThreadLocal中，表明该Bean正在创建，与上文的isPrototypeCurrentlyInCreation(beanName)
对应
beforePrototypeCreation(beanName);
创建原型Bean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
从ThreadLocal中移除beanName，表明原型Bean已经实例化完毕
afterPrototypeCreation(beanName);
}
该方法作用同上
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
创建scope为其它值的Bean
String scopeName = mbd.getScope();
判断scope的值是否合法
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
作用和上文所讲的一样，对于非单例，非原型的Bean来说，其实也会创建多个实例，
因此处理循环Bean的方式和原型Bean的一致
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
对Bean进行类型转换，在Bean进行初始化时并不会进行，一般从IOC容器请求Bean时可以用到
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
重要的是createBean方法，这个方法会实例化Bean，接下来看看getObjectForBeanInstance，接下来的三个方法告诉我们，spring初始化完毕后，是如何处理工厂类的，什么时候返回工厂类实例，什么时候返回工厂类的生产类
getObjectForBeanInstance
该方法位于AbstractBeanFactory中
/**
* Get the object for the given bean instance, either the bean
* instance itself or its created object in case of a FactoryBean.
* @param beanInstance the shared bean instance
* @param name name that may include factory dereference prefix
* @param beanName the canonical bean name
* @param mbd the merged bean definition
* @return the object to expose for the bean
*/
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
如果beanName含有&，说明获得工厂类本身，这里进行了两个检查，为null直接返回，如果类没有继承FactoryBean，则抛出异常
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
}
// 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.
这里有两种情况
1、beanName含有&，并且继承了FactoryBean，直接返回工厂类，在spring容器初始化时，由于spring会在工厂类的beanName前加上&，所以工厂类在这里直接返回
2、beanName不含有&，没有继承FactoryBean，说明不是工厂类，直接返回
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
剩下的情况——beanName不含有&，并且是工厂类
如果BeanDefinition为空，即不知道工厂类是啥，尝试从缓存中获取该Bean过去生产的Bean
Object object = null;
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
缓存中没有生产类的实例，对于单例生产类来说，说明工厂类还没有初始化其实例，
对于非单例生产类，缓存中不会存储其实例
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
确保BeanDefinition不为空
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
是否为合成类，之前的博客有说，这里不赘述
boolean synthetic = (mbd != null && mbd.isSynthetic());
从工厂中获得生产类
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
getObjectFromFactoryBean
这个方法位于FactoryBeanRegistrySupport，需注意，在spring初始化时，实例化单例非懒加载工厂类时，是不会执行这个方法的，在spring初始化完毕后，假设工厂类名字为a，当我们使用getBean("a")时，便会执行这个方法，返回生产类
/**
* Obtain an object to expose from the given FactoryBean.
* @param factory the FactoryBean instance
* @param beanName the name of the bean
* @param shouldPostProcess whether the bean is subject to post-processing
* @return the object obtained from the FactoryBean
* @throws BeanCreationException if FactoryBean object creation failed
* @see org.springframework.beans.factory.FactoryBean#getObject()
*/
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
单例工厂类生产的Bean也是单例的，为了确保生产的类是单例，spring使用了双重判断锁
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
双重判断，如果获得锁时，其他线程刚好初始化完生产类，则使用，而不是自己生产
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
下面会展开讲解该方法
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
这里有点奇怪，初始化完毕后，还需要再次判断，我们是上了单例锁的，这里我尝试解释一下，不一定对，
这里注意，我们是对SingeltonObjects上的锁，并不是对factoryBeanObjectCache上锁，意味着其他线程可以
向factoryBeanObjectCache写入数据，这里再次判断，确保Bean唯一
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
对于非合成类来说，shouldPostProcess为true，会进入到if语句中
if (shouldPostProcess) {
这一句不知啥意思，spring4还没有这句代码，
isSingletonCurrentlyInCreation用于判断beanName对应的bean是否处于初始化状态
if (isSingletonCurrentlyInCreation(beanName)) {
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
bean生命周期：BeanPostProcessor.postProcessAfterInitialization
beforeSingletonCreation(beanName);
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
afterSingletonCreation(beanName);
}
}
将生产的Bean放入缓存
if (containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
else {
初始化非单例
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}doGetObjectFromFactoryBean
该方法同样位于FactoryBeanRegistrySupport
/**
* Obtain an object to expose from the given FactoryBean.
* @param factory the FactoryBean instance
* @param beanName the name of the bean
* @return the object obtained from the FactoryBean
* @throws BeanCreationException if FactoryBean object creation failed
* @see org.springframework.beans.factory.FactoryBean#getObject()
*/
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
调用工厂类的getObject方法，获得实例
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
这里有点奇怪，NullBean是什么类？没见过，暂时把它等价于null
object = new NullBean();
}
return object;
}
总结
这篇博客主要讲解了工厂类的实例化，以及IOC容器初始化完毕后，当我们调用getBean函数时，如何对工厂类进行处理，如果我们继承并实现了SmartFactoryBean，并且其isEagerInit()返回true，则在IOC容器初始化时，便会初始化工厂类的生产类