关于spring源码如何去创建bean的

本次是上次spring容器源码分析的后续

首先,我们进入

AbstractBeanFactory类中的getBean方法

源码提供了很多种getBean方法让我们去获取bean对象

public Object getBean(String name) throws BeansException {
    return this.doGetBean(name, (Class)null, (Object[])null, false);
}

public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    return this.doGetBean(name, requiredType, (Object[])null, false);
}

public Object getBean(String name, Object... args) throws BeansException {
    return this.doGetBean(name, (Class)null, args, false);
}

public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
    return this.doGetBean(name, requiredType, args, false);
}

但是最终的调用都集中到了doGetBean方法

核心代码:

1.parentBeanFactory.getBean

2.this.getObjectForBeanInstance

3.AbstractBeanFactory.this.createBean

等几个方法去获取bean对象或者去创建bean对象

整个这一段的代码逻辑很长,我们先来看看createBean的相关代码逻辑

首先第三点AbstractBeanForBeanInstance的实现类AbstractAutowireCapableBeanFactory中的createBean方法

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if(this.logger.isDebugEnabled()) {
        this.logger.debug("Creating instance of bean '" + beanName + "'");
    }

    this.resolveBeanClass(mbd, beanName, new Class[0]);

    try {
        //方法的重写
        mbd.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException var5) {
        throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "Validation of method overrides failed", var5);
    }

    Object beanInstance;
    try {
        //初始化bean实例之前
        beanInstance = this.resolveBeforeInstantiation(beanName, mbd);
        if(beanInstance != null) {
            return beanInstance;
        }
    } catch (Throwable var6) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var6);
    }
    //此处我们再次见到了do开头的方法
    //去创建bean对象
    beanInstance = this.doCreateBean(beanName, mbd, args);
    if(this.logger.isDebugEnabled()) {
        this.logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    // 返回bean实例对象
    return beanInstance;
}

继续跟踪,此时会跳转到doCreateBean方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) {
    //封装bean实例对象
    BeanWrapper instanceWrapper = null;
    //判断当前bean定义是否为单例的
    if(mbd.isSingleton()) {
        //如果是单例的首先需要去删除原先容器中创建的bean实例缓存
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }

    if(instanceWrapper == null) {
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }
    
    final Object bean = instanceWrapper != null?instanceWrapper.getWrappedInstance():null;
    //获取创建bean实例对象的类型
    Class<?> beanType = instanceWrapper != null?instanceWrapper.getWrappedClass():null;
    Object var7 = mbd.postProcessingLock;
    //调用postProcess后置处理器
    synchronized(mbd.postProcessingLock) {//此处还未进行锁,只是加上了一个标记,当存在资源竞争的时候才会将此处锁住
        if(!mbd.postProcessed) {//标记
            this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            mbd.postProcessed = true;//重新设置标记
        }
    }
    //向容器中缓存单例模式的bean实例对象,防止循环
    boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
    if(earlySingletonExposure) {
        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
        }
        //匿名内部类，先去获取bean实例对象的引用,以防止循环
        this.addSingletonFactory(beanName, new ObjectFactory<Object>() {
            public Object getObject() throws BeansException {
                return AbstractAutowireCapableBeanFactory.this.getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }
    //bean实例对象的初始化,依赖注入在此处触发
    //这个exposedObject对象用来保存依赖注入后的bean实例对象
    Object exposedObject = bean;

    try {
        //将bean实例对象封装,并为bean实例对象中的属性赋值
        this.populateBean(beanName, mbd, instanceWrapper);
        //初始化exposedObject对象
        if(exposedObject != null) {
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        }
    } catch (Throwable var17) {
        if(var17 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var17).getBeanName())) {
            throw (BeanCreationException)var17;
        }

        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var17);
    }

    //此处逻辑重点:只关注当前创建的bean对象,当每个被创建的bean对象都处理完之后,所有的bean对象都是注入的最新的正确的bean实例
    if(earlySingletonExposure) {
        //获取单例模式的bean实例
        Object earlySingletonReference = this.getSingleton(beanName, false);
        if(earlySingletonReference != null) {
            //初始化的exposedObject对象和当前单例的bean实例对象是同一个的时候
            if(exposedObject == bean) {
                //bean实例对象初始化完成
                exposedObject = earlySingletonReference;
            } else if(!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                //获取当前bean对象依赖的其他bean对象
                String[] dependentBeans = this.getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                String[] arr$ = dependentBeans;
                int len$ = dependentBeans.length;
                //对依赖bean进行bean检查
                for(int i$ = 0; i$ < len$; ++i$) {
                    String dependentBean = arr$[i$];
                    if(!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }

                if(!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    try {
        //注册完成依赖注入的bean
        this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
        return exposedObject;
    } catch (BeanDefinitionValidationException var16) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
    }
}

通过以上逻辑我们可以看出依赖注入的核心在以下2个方法

1.this.createBeanInstance(beanName, mbd, args)

2.this.populateBean(beanName, mbd, instanceWrapper)