Spring Ioc中Bean加载的方法

本篇内容主要讲解"Spring Ioc中Bean加载的方法"，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习"Spring Ioc中Bean加载的方法"吧!

前言

在之前的文章中，我们分析了Spring的Ioc的初始化过程，实际上就是把beanName和BeanDefinition注册到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@Overridepublic Object getBean(String name) throws BeansException {        return doGetBean(name, null, null, false);}

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

• name ：要获取 Bean 的名字

• requiredType ：要获取 bean 的类型

• args ：创建 Bean 时传递的参数。这个参数仅限于创建 Bean 时使用。

• typeCheckOnly ：是否为类型检查。

二、doGetBean

//真正实现向IOC容器获取Bean的功能，也是触发依赖注入功能的地方        protected  T doGetBean(final String name, @Nullable final Class 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原型模式依赖检查

• <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 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 singletonObjects = new ConcurrentHashMap<>(256);        /** Cache of singleton factories: bean name --> ObjectFactory */        //单例对象工厂缓存        private final Map> singletonFactories = new HashMap<>(16);        /** Cache of early singleton objects: bean name --> bean instance */        //预加载单例bean缓存        //存放的 bean 不一定是完整的        private final Map 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 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()) {                                //从缓存中获取指定的 factoryBean1.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实例

到此，相信大家对"Spring Ioc中Bean加载的方法"有了更深的了解，不妨来实际操作一番吧！这里是网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！