spring容器之bean加载总结篇

从我们的配置文件到解析,在到对bean的beanDefinition的定义和解析过程经历了漫长的过程,最后到我们bean的创建和初始化的过程,听着就很懵逼,所以我写这篇博客的主要作用是在捋一下spring对bean的创建过程以及初始化过程,首先我们从方法入口开始:

AbstractBeanFactory.java
//获取bean
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

这是我们获取bean的入口方法,接着看:

/**
 * 返回bean的实例,
 */
  AbstractBeanFactory.java
protected  T doGetBean(final String name, @Nullable final Class requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    //该方法去掉别名之后的bean的name,如我这里有一个Student的真实的bean,别名为 Student------>aaStudent
    //Student-------->aaaaStudent,该方法内部循环处理,最终返回Student即可
    final String beanName = transformedBeanName(name);
    Object bean;

    //从上面的去掉别名的beanName拿到后,从缓存中去拿,调用了DefaultSingletonBeanRegistry的getSingleton方法
    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 + "'");
            }
        }
        //获取bean的实例
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    //这里表明上述的sharedInstance为null
    else {
        //这里分情况来看,spring考虑到了,如果当前的bean已经被创建,获取会失败,可能有别的bean在引用该bean
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        //如果容器中没有找到，则从父类容器中加载
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            //当前类的爸爸中没找到,从爷爷辈去找,直到找到
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                //调用AbstractBeanFactory的doGetBean方法去获取bean的实例
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            //args为首次创建bean的实例时的参数
            else if (args != null) {
                //使用代理的方式去获取bean实例
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            //bean的真实类型
            else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            //这里表示我们的args和requiredType都为null,直接通过得到的bean的名字去获取实例
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }
        //对bean的真实类型检查,在检查之前不可使用该bean
        if (!typeCheckOnly) {
            //对已经创建完的bean的实例做标记,如:已完成创建
            markBeanAsCreated(beanName);
        }

        try {
            //合并父子bean的定义
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            //检查合并之后的bean的定义
            checkMergedBeanDefinition(mbd, beanName, args);

            //先初始化当前bean所依赖的bean
            //如:我的订单类需要商品类,此刻spring会先初始化商品类,大概就是这样的
            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 + "'");
                    }
                    //给当前bean注册一个依赖bean
                    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()) {
                //从缓存(singletonObjects)中去拿
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        //最后从缓存中移除对应的实例原因有:
                        //1.每当有bean在创建时,允许循环参考来解析对应的beanDefinition
                        //2.删除临时引用该bean的bean
                        destroySingleton(beanName);
                        throw ex;
                    }
                });

                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            //原型的情况下:
            else if (mbd.isPrototype()) {

                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    //创建完bean的处理
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {
                //获取bean的作用域
                String scopeName = mbd.getScope();
                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, () -> {
                        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;
        }
    }

    //检查类型与实际的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;
}

这是内部调用的#doGetBean(...)的方法,方法比较长,处理的逻辑比较复杂,我们简单的来总结下:

首先是对我们传入的name进行转化为beanName,可能传入的name是带有别名的,不是我们想要的

//该方法去掉别名之后的bean的name,如我这里有一个Student的真实的bean,别名为 Student------>aaStudent
//Student-------->aaaaStudent,该方法内部循环处理,最终返回Student即可
final String beanName = transformedBeanName(name);

public String canonicalName(String name) {
    String canonicalName = name;
    // Handle aliasing...
    String resolvedName;
    //循环处理,最终获取beanName
    do {
        //获取alias
        resolvedName = this.aliasMap.get(canonicalName);
        if (resolvedName != null) {
            canonicalName = resolvedName;
        }
    }
    while (resolvedName != null);
    return canonicalName;
}

然后尝试着从缓存中加载单例bean

/**
 *
 * @param beanName 转化之后的bean的beanName
 * @param allowEarlyReference  允许早期依赖
 * @return
 */
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //通过beanName从缓存中去拿对应的实例
    Object singletonObject = this.singletonObjects.get(beanName);
    //如果为null且当前的单例的bean正在创建过程中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        //锁定该全局变量singletonObjects进行相关的处理
        synchronized (this.singletonObjects) {
            //从早期单例bean缓存中去获取
            singletonObject = this.earlySingletonObjects.get(beanName);
            //如果为null,且提前创建
            if (singletonObject == null && allowEarlyReference) {
                //从单例工厂中获取
                ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    //调用getObject并获取对应的实例
                    singletonObject = singletonFactory.getObject();
                    //保存到earlySingletonObjects缓存中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    //同时移除singletonFactories中的对应的objectFactory
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

上述代码分别是从缓存singletonObjects earlySingletonObjects和singletonFactories中去获取bean,同样该方法也是解决循环依赖的重要之处,我们接着看:

获取bean的实例

/**
 *
 * 该方法的主要作用是获取一个bean的实例,从FactoryBean中
 * @param beanInstance 共享bean的实例
 * @param name 普通bean和有Factory前缀的bean的name
 * @param beanName 去掉别名之后的bean的name
 * @param mbd  这个是合并之后的Bean的定义的文件--->beanDefinition
 * @return 返回一个bean的object对象
 */
protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

    //首先对name进行检查
    //如果name是Factory类型的(即有&开头)
    if (BeanFactoryUtils.isFactoryDereference(name)) {
        //如果beanInstance是一个空bean类型的,直接返回一个空bean的对象
        if (beanInstance instanceof NullBean) {
            return beanInstance;
        }
        //如果beanInstance不是FactoryBean类型的,抛异常
        if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
        }
    }

    //这里的bean可能是factory类型,也可能是正常的bean
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }

    Object object = null;
    //如果是factory类型的bean
    if (mbd == null) {
        //尝试从getCachedObjectForFactoryBean获取
        object = getCachedObjectForFactoryBean(beanName);
    }
    //如果从缓存中没拿到
    if (object == null) {
        //这里确定的是beanInstance是FactoryBean类型的了
        FactoryBean factory = (FactoryBean) beanInstance;
        // Caches object obtained from FactoryBean if it is a singleton.
        //通过containsBeanDefinition方法检测
        if (mbd == null && containsBeanDefinition(beanName)) {
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        //判断bean的定义是否是合并之后的,不是由application容器来定义,而是用户自己定义的
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        //从FactoryBean中通过调用getObject返回一个Object对象
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    //将实例object返回
    return object;
}

这就是获取bean实例的过程,我们可以看到的是首先一进方法是对bean的类型进行判断,是一个factory类型的还是普通的bean类型,具体的方法详解请看:

spring容器之从bean的实例中获取对象
当我们从缓存中获取的单例bean(这里的bean不成熟)不存在时,从父工厂中去加载直到找到为止

//如果容器中没有找到，则从父类容器中加载
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//当前类的爸爸中没找到,从爷爷辈去找,直到找到
String nameToLookup = originalBeanName(name);
  if (parentBeanFactory instanceof AbstractBeanFactory) {
        //调用AbstractBeanFactory的doGetBean方法去获取bean的实例
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            //args为首次创建bean的实例时的参数
            else if (args != null) {
                //使用代理的方式去获取bean实例
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            //bean的真实类型
            else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            //这里表示我们的args和requiredType都为null,直接通过得到的bean的名字去获取实例
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

这段代码就是递归寻找bean的过程,其核心是通过代理的方式调用#getBean(...)获取bean实例,我们接着看

对bean进行类型检查

    if (!typeCheckOnly) {

    //对已经创建完的bean的实例做标记,如:已完成创建
    markBeanAsCreated(beanName);
        }

其主要是对bean的真实类型检查,在检查前该bean是不能使用的,接着是调用#markBeanAsCreated(beanName)进行其标记,避免该bean的重复创建,接着看:

循环依赖的处理

//先初始化当前bean所依赖的bean
//如:我的订单类需要商品类,此刻spring会先初始化商品类,大概就是这样的
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 + "'");
                    }
        //给当前bean注册一个依赖bean
        registerDependentBean(dep, beanName);
        try {
            //递归处理
            getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

循环递归处理,首先是注册依赖等一些列操作

创建bean实例,分情况处理:
单例情况下:

//单例的情况下
if (mbd.isSingleton()) {
//从缓存(singletonObjects)中去拿
sharedInstance = getSingleton(beanName, () -> {
    try {
        return createBean(beanName, mbd, args);
        }
        catch (BeansException ex) {
        //最后从缓存中移除对应的实例原因有:
        //1.每当有bean在创建时,允许循环参考来解析对应的beanDefinition
        //2.删除临时引用该bean的bean
        destroySingleton(beanName);
        throw ex;
        }
    });

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

其核心方法是createBean(beanName, mbd, args),我们接着看:

原型的情况下

spring容器之bean加载总结篇

创建bean实例

实例化bean实例

属性的填充

初始化bean

从bean实例中获取对象

你可能感兴趣的:(spring容器之bean加载总结篇)