• 欢迎访问 winrains 的个人网站!
  • 本网站主要从互联网整理和收集了与Java、网络安全、Linux等技术相关的文章,供学习和研究使用。如有侵权,请留言告知,谢谢!

Spring IoC源码分析之Bean的加载(1)

Spring winrains 来源:大王叫下 12个月前 (10-13) 38次浏览

前言

在之前的文章中,我们分析了Spring的Ioc的初始化过程,实际上就是把 beanNameBeanDefinition 注册到DefaultListableBeanFactory的map中。
在完成 bean 的注册之后, refresh() 还调用了很多后处理器的方法,其中有一个方法 finishBeanFactoryInitialization(),注释上面写着 Instantiateall remaining(non-lazy-init)singletons ,意味着非延迟加载的类,将在这一步实例化,完成类的加载。
而我们使用到 context.getBean(“beanName”) 方法,如果对应的 bean 是非延迟加载的,那么直接就能拿出来进行使用,而延迟加载的 bean 就需要上面的步骤进行类的加载,加载完之后才能进行使用。

我们接着分析一下Ioc的bean实例化过程:

一、getBean

当我们显示或者隐式地调用 BeanFactory#getBean(String name) 方法时,则会触发加载 Bean 阶段。代码如下:

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

内部调用 doGetBean(String name, final Class<T> requiredType, Object[] args, boolean typeCheckOnly) 方法,其接受四个方法参数:

  • name :要获取 Bean 的名字
  • requiredType :要获取 bean 的类型
  • args :创建 Bean 时传递的参数。这个参数仅限于创建 Bean 时使用。
  • typeCheckOnly :是否为类型检查。

二、doGetBean

//真正实现向IOC容器获取Bean的功能,也是触发依赖注入功能的地方
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    //根据指定的名称获取被管理Bean的名称,剥离指定名称中对容器的相关依赖
    // 如果指定的是别名,将别名转换为规范的Bean名称
<1>     final String beanName = transformedBeanName(name);
        Object bean;
        // Eagerly check singleton cache for manually registered singletons.
    // 从缓存中获取已被创建过的单例Bean
<2>     Object sharedInstance = getSingleton(beanName);
        //如果缓存中有
    if (sharedInstance != null && args == null) {
        if (logger.isDebugEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        //注意:BeanFactory是管理容器中Bean的工厂
        //     FactoryBean是创建创建对象的工厂Bean,两者之间有区别
        //获取给定Bean的实例对象,该对象要么是 bean 实例本身,要么就是 FactoryBean 创建的 Bean 对象
        //(为什么要再次获取呢,因为上面获取的sharedInstance不一定是完整的)
<3>         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {
            // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        // 因为 Spring 只解决单例模式下的循环依赖,在原型模式下如果存在循环依赖则会抛出异常。
<4>         if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            // Check if bean definition exists in this factory.
        //对IOC容器中是否存在指定名称的BeanDefinition进行检查,首先检查是否
        //能在当前的BeanFactory中获取的所需要的Bean,如果不能则委托当前容器
        //的父级容器去查找,如果还是找不到则沿着容器的继承体系向父级容器查找
        BeanFactory parentBeanFactory = getParentBeanFactory();
        //当前容器的父级容器存在,且当前容器中不存在指定名称的Bean
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            //解析指定Bean名称的原始名称
            String nameToLookup = originalBeanName(name);
            // 若为 AbstractBeanFactory 类型,委托父类处理
            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 {
                // No args -> delegate to standard getBean method.
                //委派父级容器根据指定名称和类型查找
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        // 创建的Bean是否需要进行类型验证,一般不需要
<5>         if (!typeCheckOnly) {
                //向容器标记指定的Bean已经被创建
            markBeanAsCreated(beanName);
        }
        try {
            //从容器中获取 beanName 相应的 GenericBeanDefinition 对象,并将其转换为 RootBeanDefinition 对象
            // 主要解决Bean继承时子类合并父类公共属性问题
<6>             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                // 检查给定的合并的 BeanDefinition (是否为抽象类)
            checkMergedBeanDefinition(mbd, beanName, args);
            // Guarantee initialization of beans that the current bean depends on.
            // 处理所依赖的 bean @DependsOn()
            // 获取当前Bean所有依赖Bean的名称
<7>             String[] dependsOn = mbd.getDependsOn();
                //如果有依赖
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    //校验该依赖是否已经注册过给当前 Bean
                    if (isDependent(beanName, dep)) {
                        //已注册,抛出异常
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    //没有,则先注册依赖的bean
                    registerDependentBean(dep, beanName);
                    //递归调用getBean(),先生成依赖的bean
                    getBean(dep);
                }
            }
            // Create bean instance.
            //创建单例Bean
<8>             if (mbd.isSingleton()) {
                    //这里使用了一个匿名内部类,创建Bean实例对象,并且注册给所依赖的对象
                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.
                        //显式地从容器单例模式Bean缓存中清除实例对象
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                //获取给定Bean的实例对象
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            //创建多例Bean
            else if (mbd.isPrototype()) {
                //原型模式(Prototype)是每次都会创建一个新的对象
                Object prototypeInstance = null;
                try {
                    //加载前置处理,默认的功能是注册当前创建的原型对象
                    beforePrototypeCreation(beanName);
                    //创建指定Bean对象实例
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    //加载后置处理,默认的功能告诉IOC容器指定Bean的原型对象不再创建
                    afterPrototypeCreation(beanName);
                }
                //获取给定Bean的实例对象
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            //要创建的Bean既不是Singleton也不是Prototype
            //如:request、session、application等生命周期
            else {
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                //Bean定义资源中没有配置生命周期范围,则Bean定义不合法
                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的实例对象
                    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实例对象进行类型检查
<9>     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.isDebugEnabled()) {
                    logger.debug("Failed to convert bean '" + name + "' to required type '" +
                        ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

代码很长,需要一些耐心,下面我们来逐步分析这段代码:

  • <1>处:具体分析,见2.1获取原始beanName
  • <2>处: 具体分析,见2.2从缓存中获取单例bean
  • <3>处: 具体分析,见2.3获取最终的bean实例对象
  • <4>处: 具体分析,见2.4原型模式依赖检查(Prototype)和从 parentBeanFactory 获取 Bean
  • <5>处: 具体分析,见2.5标记bean为已创建或即将创建
  • <6>处: 具体分析,见2.6获取BeanDefinition
  • <7>处: 具体分析,见2.7bean依赖处理
  • <8>处: 具体分析,见2.8不同作用域bean的实例化
  • <9>处: 具体分析,见2.9类型转换

2.1、获取原始beanName

代码如下:

final String beanName = transformedBeanName(name);

继续深入,代码如下:

protected String transformedBeanName(String name) {
    return canonicalName(BeanFactoryUtils.transformedBeanName(name));
  }

BeanFactoryUtils.transformedBeanName(name)方法主要是去除 FactoryBean 的修饰符

// 对FactoryBean的转义定义,因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象,
// 如果需要得到工厂本身,需要转义
String FACTORY_BEAN_PREFIX = "&";
public static String transformedBeanName(String name) {
    Assert.notNull(name, "'name' must not be null");
    String beanName = name;
    while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
        beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
    }
    return beanName;
}

ps: 如果一个factoryBean的名称为“student”,获取factoryBean创建的Bean时,使用getBean("student"),获取factoryBean本身时,使用getBean("&student")
接着深入,最终代码如下:

/** Map from alias to canonical name */
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
//循环处理,从aliasMap中根据aliasName获取真实beanName,直到获取到的真实beanName为null
public String canonicalName(String name) {
    String canonicalName = name;
    // Handle aliasing...
    String resolvedName;
    do {
        resolvedName = this.aliasMap.get(canonicalName);
        if (resolvedName != null) {
            canonicalName = resolvedName;
        }
    } while (resolvedName != null);
    return canonicalName;
}

主要是一个循环获取 beanName 的过程,例如,别名 A 指向名称为 B 的 bean 则返回 B,若 别名 A 指向别名 B,别名 B 指向名称为 C 的 bean,则返回 C

2.2、从缓存中获取单例bean

Spring 对单例模式的 bean 只会创建一次。后续,如果再获取该 Bean ,则是直接从单例缓存中获取,该过程就体现在 #getSingleton(String beanName) 方法中。代码如下:

/** Cache of singleton objects: bean name --> bean instance */
// 单例bean的缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** Cache of singleton factories: bean name --> ObjectFactory */
// 单例对象工厂缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name --> bean instance */
// 预加载单例bean缓存
// 存放的 bean 不一定是完整的
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
//对于单例模式的Bean整个IOC容器中只创建一次,不需要重复创建
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从单例缓存中获取单例bean
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果缓存中没有 并且 该bean正在创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            // earlySingletonObjects 中没有,且允许提前创建
            if (singletonObject == null && allowEarlyReference) {
                // 从缓存中获取 ObjectFactory
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 从单例工厂中获取bean
                    singletonObject = singletonFactory.getObject();
                    // 存入early
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

这段代码很简单,流程如下:

  • 第一步,从singletonObjects中获取Bean对象
  • 第二步,如果获取不到且Bean正在创建中,从earlySingletonObjects获取Bean对象
  • 第三步,如果获取不到且允许提前创建,从singletonFactories获取FactoryBean
  • 第四步,如果不为null,则通过FactoryBean.getObject()获取Bean,然后将其加入到 earlySingletonObjects ,并且从 singletonFactories 删除,两者是互斥的,主要用来解决循环依赖的问题
  • 总结就是:从这三个Map依次去取,取不到就取下一个Map

2.2.1、isSingletonCurrentlyInCreation

在上面的代码中又一个重要的方法isSingletonCurrentlyInCreation(beanName),代码如下:

private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
public boolean isSingletonCurrentlyInCreation(String beanName) {
    return this.singletonsCurrentlyInCreation.contains(beanName);
}

这个方法是用来判断当前Bean是否在创建中,看到是个Map,我们可以猜测,应该有一个地方在创建Bean的时候,会把正在创建的BeanName给put到这个Map中。具体我们之后将。

2.2.2、getObjectForBeanInstance

当我们从getSingleton(beanName)拿到bean对象后,会接着调用getObjectForBeanInstance()方法,来获取最终的Bean实例。

  • 为什么这里要再获取一次Bean呢,之前明明都拿到了呀?
  • 因为我们从缓存中获取的 bean 是最原始的 Bean ,并不一定是我们最终想要的 Bean
  • 怎么办呢?调用 #getObjectForBeanInstance(…) 方法,进行处理,该方法的定义为获取给定 Bean 实例的对象,该对象要么是 bean 实例本身,要么就是 FactoryBean 创建的 Bean 对象。

看代码:

// 获取给定Bean的实例对象,主要是完成FactoryBean的相关处理
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.
    // 容器已经得到了Bean实例对象,这个实例对象可能是一个普通的Bean,
    // 也可能是一个工厂Bean,如果是一个工厂Bean,则使用它创建一个Bean实例对象,
    // 如果调用本身就想获得一个容器的引用,则指定返回这个工厂Bean实例对象
    // 若为工厂类引用(name 以 & 开头) 且 Bean实例也不是 FactoryBean
    if (BeanFactoryUtils.isFactoryDereference(name) && !(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.
    // 如果类型不是FactoryBean,直接返回
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }
    Object object = null;
    // 若 BeanDefinition 为 null,则从缓存中加载 Bean 对象
    if (mbd == null) {
        // 从Bean工厂缓存中获取给定名称的Bean实例对象
        object = getCachedObjectForFactoryBean(beanName);
    }
    // 若 object 依然为空,则可以确认,beanInstance 一定是 FactoryBean 。从而,使用 FactoryBean 获得 Bean
    // 对象
    if (object == null) {
        // Return bean instance from factory.
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // Caches object obtained from FactoryBean if it is a singleton.
        // 检测是否定义 beanName
        if (mbd == null && containsBeanDefinition(beanName)) {
            // 从容器中获取指定名称的Bean定义,如果继承基类,则合并基类相关属性
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        // 如果从容器得到Bean定义信息,并且Bean定义信息不是虚构的,
        // 则让工厂Bean生产Bean实例对象
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        // 调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法,
        // 实现工厂Bean生产Bean对象实例的过程
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

首先看下这个方法的流程:

  • 1、类型检查,判断是否是FactoryBean
  • 2、对非 FactoryBean 不做处理
  • 3、对 bean 进行转换
  • 4、处理 FactoryBean 类型:委托给 getObjectFromFactoryBean 方法进行处理。

我们直接看第3步,走到这里,说明这个bean一定是FactoryBean类型的,再从Ioc容器中获取该beanName对应的BeanDefinition,如果不为null,且不是abstract,则调用getObjectFromFactoryBean方法获取bean实例
从这里可以看出, getObjectForBeanInstance(Object beanInstance, String name, String beanName,RootBeanDefinition mbd) 方法,分成两种情况:

  • 第一种,当该实例对象为非 FactoryBean类型,直接返回给定的 Bean 实例对象 beanInstance 。
  • 第二种,当该实例对象为FactoryBean 类型,从 FactoryBean ( beanInstance ) 中,获取 Bean 实例对象。

2.2.3、getObjectFromFactoryBean

我们接着看第二种情况:

//Bean工厂生产Bean实例对象
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    //为单例模式且缓存中存在
    if (factory.isSingleton() && containsSingleton(beanName)) {
        //多线程同步,以防止数据不一致
1.1         synchronized (getSingletonMutex()) {
                //从缓存中获取指定的 factoryBean
1.2             Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    // 为空,则从 FactoryBean 中获取对象
                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)
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    }
                    else {
1.3                     if (shouldPostProcess) {
                            try {
                                // 对从 FactoryBean 获取的对象进行后处理
                            // 生成的对象将暴露给 bean 引用
                            object = postProcessObjectFromFactoryBean(object, beanName);
                        }
                        catch (Throwable ex) {
                            throw new BeanCreationException(beanName,
                                    "Post-processing of FactoryBean's singleton object failed", ex);
                        }
                    }
                    //将生产的实例对象添加到Bean工厂缓存中
1.4                     this.factoryBeanObjectCache.put(beanName, object);
                    }
                }
                return object;
            }
        }
        // 为空,则从 FactoryBean 中获取对象
2       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;
    }
}
  • 1、判断是否为单例并且缓存中存在 如果存在,则顺着1.1往下走,不存在,则走2的流程
  • 1.1、sync加锁,锁住的是singletonObjects,和其他单例锁一样,保证全局唯一
  • 1.2、从缓存factoryBeanObjectCache中获取Bean实例 如果获取不到,则调用doGetObjectFromFactoryBean()方法获取,实际最后调用的是factory.getObject()方法
  • 1.3、如果需要后续处理( shouldPostProcess = true ),则进行下一步处理 postProcessObjectFromFactoryBean() 方法,对从 FactoryBean 处获取的 Bean 实例对象进行后置处理。其默认实现是直接返回 object 对象,不做任何处理。代码如下:
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
    return object;
}

但是子类可以重写,例如应用后处理器等。

  • 1.4、加入到 factoryBeanObjectCache 缓存中
  • 2、如果缓存中不存在,同样调用doGetObjectFromFactoryBean()获取bean实例

总结

到这里,doGetBean()方法的2.2从缓存中获取单例bean2.3获取最终的bean实例对象我们已经分析完了,下篇文章我们接着分析后面的步骤。

作者:大王叫下

来源:https://juejin.im/post/5d6dd278f265da03e921e6fd


版权声明:文末如注明作者和来源,则表示本文系转载,版权为原作者所有 | 本文如有侵权,请及时联系,承诺在收到消息后第一时间删除 | 如转载本文,请注明原文链接。
喜欢 (0)