bean的加载-初始化和使用

原创
2019/07/08 11:33
阅读数 238

bean的加载-初始化和使用

自上一篇bean的加载-配置文件的解析之后,仅仅是将所有的bean定义拿到了,这个时候的bean是还未进行初始化的。对于bean的初始化,是从BeanFactory.getBean()为入口开始的。

bean的加载是在拿到bean的定义之后,解析xml之后,bean的定义会被封装到BeanDefinition中,这个部分是在解析自定义标签和解析默认标签的时候封装的,这里只提一下,不做这个封装的分析了,喜欢的朋友自己去看吧,比较简单。

BeanDefinition

BeanDefinition

BeanDefinition是个借口,他有三个实现,都继承至AbstractBeanDefinition。<bean>元素标签拥有的class,scope、lazy-init等配置属性都是和BeanDefinition中是一一对应的,这个就不贴代码了,在父类AbstractBeanDefinition中。RootBeanDefinition是最常用的实现类,它对应一盘的<bean>标签。GenericBeandefinition是2.5之后新加入的,是一站式服务类。配置文件中可以定义父Bean和子Bean,父bean或者没有父beanean的普通bean就用RootBeanDefintion表示,而子bean就用childBeanDefinition表示。

所有的bean定义都会被注册到BEanDefinitionRegistry当中。spring容器的BeanDefinitionregistry就是spring的内存数据库,主要是以Map的形式保存,后续的操作都直接从BeanDefinitionRegistry中读取配置信息。

doGetBean()

了解了BeanDefinition之后,现在来开始加载这个bean吧。

//AbstractBeanFactory.java
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                          @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    // 提取对应的bean name
    final String beanName = transformedBeanName(name);
    Object bean;
    /**
     * 检查缓存中或者实例工厂中是否有对应的实例,为什么首先会使用这段代码呢?
     * 因为在创建单例Bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖,
     * Spring创建Bean的时候会不等Bean创建完成,就将其提前曝光,也就是将其加入缓存,一旦下一个bean需要,就可以立即从缓存中获得
     */
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        //...日志
        //返回对应的实例,有时候在诸如FactoryBean存在的情况下,并不是返回实例本身,而是应该返回<指定方法返回的实例>
        //比如FactoryBean时,指定方法就是getObject(),这里拿到的Bean是FactoryBean,而返回的应该是FactoryBean.getObject()
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        /**
         * 检查是否存在循环依赖,只有单例模式下才会尝试解决循环依赖,原型模式不解决,所以这里要判断是否存在循环依赖
         * 是否存在循环依赖的判断就是检查当前线程正在创建的bean是不是已经处于正在创建的状态了
         * 这个地方跟进去可以看到是是使用的一个TheadLocal, 加入正在创建的bean是在之后开始创建bean的时候加入的。
         * 注意:这里是原型模式的检查循环依赖!!不要找错地方了
         */
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        BeanFactory parentBeanFactory = getParentBeanFactory();
        //如果检查当前容器的beanDefinitionMap中不包含该bean,则尝试从父容器parentBeanFactory中获取
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        //如果不仅仅是做类型检查,那就是要创建bean,这里要进行记录
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            //将xml文件读取的GernericBeanDefinition转换为RootBeanDefinition
            //如果指定Bean是子Bean的话,同时会合并父Bean的相关属性
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            String[] dependsOn = mbd.getDependsOn();
            //如果存在依赖,则需要递归实例化依赖的bean。
            //这个地方是指当前bean初始化前必须要存在的依赖,比如@DependsOn;并不是bean自身内部属性的依赖,
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    //...日志
                    //缓存依赖调用
                    registerDependentBean(dep, beanName);
                    try {
                        //递归获取需要的bean
                        getBean(dep);
                    }
                    //...
                }
            }

            //实例化依赖的Bean之后就可以实例化本身了
            //singleton模式的创建
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) {
                //原型模式下的实例化bean
                Object prototypeInstance = null;
                try {
                    //加入到ThreadLocal,检查循环依赖时使用的那个,正在创建的bean就是从这里加进去的
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } else {
                //其他指定scope下的实例化bean
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                //...
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                //...
            }
        }
        //...
    }

    //检查需要的类型是否符合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;
        }
        //...
    }
    return (T) bean;
}
梳理一下大致流程:
1. 装换对应的beanName;
2. 尝试从缓存中加载单例;
3. bean的实例化,如果从缓存中得到了bean的原始状态,则需要对bean进行实例化。
缓存中记录的只是最原始状态的bean,并不一定是我们最终想要的bean,有可能是我们的工厂bean。
这个时候就需要对工厂bean进行处理,也就是调用工厂bean重定义的factory-method方法来返回我们真正想要的bean,
而getObjectForBeanInstance就是完成这个工作的。
4. 原型模式的循环依赖检查;
5. 如果当前容器中没有找到对应的bean,则检查parentBeanFactory,通常parentBeanFactory都为null;
6. 将xml配置文件的GernericBeanDefinition转换为RootBeanDefinition;
7. 寻找依赖到的其他bean;
8. 针对不同的scope进行bena的创建;
9. 类型转换,并返回相应的bean。

transformedBeanName()

这个方法是获得真正的bean名称,比如我们注册了别名的,如果我们使用别名获取的,那这里就会转换成真正的bean名称;还有种就是如果我们获取的是FactoryBean类型的话,会把前缀&去掉,然后使用这个beanname获得一个FactoryBean。可能有读者会有有点懵,FactoryBean是啥,提一下,这个东西其实是一个工厂Bean,他是用来创建我们所需要Bean的一种工厂,如果spring监测到我们获取的bean其实是一个工厂Bean的话,Spring会调用工厂Bean的指定方法来返回我们真正的Bean,而不是直接返回这个工厂Bean,有点绕,不明白的朋友可以去百度一下spring的FactoryBean的使用,很简单。

缓存获取getSingleton(beanName)

//DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName) {
    //参数设置为true表示允许早期依赖(就是允许检查为了解决循环依赖而提早曝光的bean)
    return getSingleton(beanName, true);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //先检查缓存中是否存在实例
    Object singletonObject = this.singletonObjects.get(beanName);
    //如果为空,且当前单例正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            //如果此bean正在加载,则不做任何处理
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                //如果为空,且允许循环依赖检查,则获取正在加载的bean
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    //调用指定的方法返回bean
                    singletonObject = singletonFactory.getObject();
                    //记录在缓存中,earlySingletonObjects与singletonFactories互斥,将正在加载的bean暴露到earlySingletonObjects当中,
                    //第一次暴露其实并不是真正暴露,仅仅是标记了当前bean正在创建中,是放在singletonFactory当中的,每一个bean都会这样做,这是为了解决循环依赖而设计的,具体细节去看另一篇博客<循环依赖>
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}
解释一下这里涉及的用于存储bean的不同的集合:
singletonObjects: 用于保存BeanName和穿件bean实例之间的关系,bean name-->bean instance;
singletonFactories: 用于保存BeanName和创建bean的工厂之间的关系,bean name--> ObjectFactory;
earlySingletonObjects: 也是保存beanName和创建bean实例之间的关系,与singletonObjects的不同在于,当一个单例bean被放到这里面后,那么当bean还在创建过程中,就可以获取到了,其目的使用来检查循环引用;
registeredSingletons: 用来保存当前所有已注册的bean。

singleton模式创建getSingleton(beanName, ObjectFactory)

//DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    //全局变量需要同步
    synchronized (this.singletonObjects) {
        //从缓存中取
        Object singletonObject = this.singletonObjects.get(beanName);
        //不存在时开始创建单例
        if (singletonObject == null) {
            //...日志
            //把当前正在创建的bean name加入到set集合中
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
                //初始化bean,这个singletonFacotry是调用当前方法的时候传递进来的匿名内部类,getObject()方法中会调用内部类的createBean()方法
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            //...
            finally {
                //...
                //从当前正在创建的bean的集合中移除掉当前bean name
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                //将新创建的单例bean加入缓存
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

回顾一下匿名内部类:

getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        //...
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

第二个参数就是我们的singletonFactory,调用的getObject方法就会回到这里,执行createBean。这个方法内容有点多,可以先去看对初始化完成后的bean的获取getObjectForBeanInstance。

createBean()

来吧,饶了这么久,还是要来createBean。

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
    //...
    RootBeanDefinition mbdToUse = mbd;
    //...
    //锁定class,根据class的属性或者className来解析class
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    try {
        //验证及准备覆盖的方法
        mbdToUse.prepareMethodOverrides();
    }
    //...
    try {
        //给beanPostProcessor一个机会返回代理来替代真正的实例,具有中断效应的beanPostProcessor就是在这里调用的
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        //如果bean不为空,则中断后续流程,直接返回bean
        if (bean != null) {
            return bean;
        }
    }
    //...
    try {
        //正常创建bean
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        //...日志
        return beanInstance;
    }
    //...
}

prepareMethodOverrides()

不知道有没有读者用过replace-method和lookup-method这配置功能。这两个东西加载的配置都会放到BeanDefinition的methodOverrides属性里。这两个功能实现原理其实就是在bean实例化的时候如果监测到存在methodOverride属性,会动态的对当前bean声场代理,并使用对应的拦截器为bean做增强处理,相关逻辑的实现在bean的实例化部分。

//AbstractBeanDefinition.java
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    //如果有被覆盖的方法
    if (hasMethodOverrides()) {
        Set<MethodOverride> overrides = getMethodOverrides().getOverrides();
        synchronized (overrides) {
            for (MethodOverride mo : overrides) {
                //遍历替换的方法进行处理
                prepareMethodOverride(mo);
            }
        }
    }
}

protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
    int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
    if (count == 0) {
        throw new BeanDefinitionValidationException(
                "Invalid method override: no method with name '" + mo.getMethodName() +
                        "' on class [" + getBeanClassName() + "]");
    }
    else if (count == 1) {
        //如果方法只有一个,则直接设置该方法没有被重载,省去参数检查的开销
        mo.setOverloaded(false);
    }
}

在java中方法是可以重载的,这样的话确定需要被覆盖的方法除了方法名之外,还需要匹配参数。在上面的检查中,如果找到的方法只有一个,则设置当前方法没有被重载,在后续覆盖的时候就可以直接获取该方法,省去了参数检查的开销

resolveBeforeInstantiation()

之前提到过有一种具有中断效应的beanPostProcessor,就是在这个地方进行调用的,看看吧。为什么说具有中断效应呢,因为如果在这里获得了bean之后,后续的流程就不会走了。但这不是很正常嘛?正常吗?我们需要的bean到这里其实还并没有实例化哦!!!震惊吧!

//AbstractAutowireCapableBeanFactory.java
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        //如果含有具有中断类型的bean处理器InstantiationAwareBeanPostProcessors
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            //获得目标类型,其实就是Bean的类型
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                //使用中断效应的InstantiationAwareBeanPostProcessors的处理器进行处理
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    //如果bean不为空,说明中断效果的处理器处理了,产生了中断之后,就走不到getObjectForBeanInstance了,因此这里继续调用bean的后置处理器
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    //返回bean
    return bean;
}


/**
 * 遍历调用具有中断效应的bean处理器InstantiationAwareBeanPostProcessor
 */
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            //在遍历的过程中,可以看出来在遇到的第一个处理完后如果result不为null,就直接返回了
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}

在这个地方产生了中断效应,注意区分InstantiationAwareBeanPostProcessor和BeanPostProcessor这俩的方法哦!!!一个结尾是Initxxx,一个是Instxxx哦!

public interface BeanPostProcessor {
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }
    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
            throws BeansException {
        return null;
    }
    default PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

InstantiationAwareBeanPostProcessor具有中断效应,BeanPostProcessor不具有中断效应

doCreateBean()

终于要开始真正实例化并创建我们的bean了,开始吧,虽然有点小累。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
        throws BeanCreationException {
    //开始实例化并初始化bean
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        //从缓存中取
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        //如果缓存中为空,则实例化bean,并包装成BeanWrapper,
        //convertService和自定义的属性解析器propertyEditor都会在这里一并封装到BeanWrapper中
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    //检查是否是NullBean类型
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                //执行MergedBeanDefinitionPostProcessor的处理,也是BeanPostProcessor的子类
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            //...
            mbd.postProcessed = true;
        }
    }
    //检查是否允许循环依赖并提早曝光,allowCircularReferences这个参数可以通过BeanFactory设置
    //单例 && 允许循环依赖 && 当前bean正在创建中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        //...日志
        //如果允许循环依赖,则提前暴露出一个bean工厂
        //getEarlyBeanReference里面应用了SmartInstantiationAwareBeanPostProcessor的处理,也是BeanPostProcessor的子类。
        //aop的织入就是就在这里,相关的处理器都是SmartInstantiationAwareBeanPostProcessor的子类
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    Object exposedObject = bean;
    try {
        //bean属性的设置,对bean进行填充,依赖注入
        populateBean(beanName, mbd, instanceWrapper);
        //检查aware接口->bean前置处理->检查是否实现InitializingBean并调用afterPropertiesSet方法->调用init-method->bean后置处理
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    //...
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        //earlySingletonReference只有在检测到有循环依赖的情况下才不会为空
        if (earlySingletonReference != null) {
            //如果exposedObject没有在初始化方法中被改变,也就是说没有被增强
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                //如果不允许循环依赖 && 存在依赖的bean,则检查自己和所依赖的bean中是否存在循环依赖
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                //检查循环依赖
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                //if条件语句中,会检查以来是否已经创建,如果已经创建就会将其移除,并返回true,如果当前的依赖还未创建,就返回false,并将其添加到actualDependentBeans中
                        actualDependentBeans.add(dependentBean);
                    }
                }
                //因为bean创建后,其依赖的bean一定是已经创建的
                //actualDependentBeans不为空则说明bean创建后还有以来未创建,也就说存在循环依赖
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                            "...");
                }
            }
        }
    }

    try {
        //注册destroy-method,包括实现DisposableBean的和自定义的
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    //...
    //返回bean
    return exposedObject;
}
粗略概括一下主要流程:
1. 如果是单例,则需要首先清除缓存;
2. 实例化bean,并将其和convertService,自定义属性解析器propertyEditor一并封装成BeanWrapper,初始化方式有以下几种;
 2.1如果存在工厂方法则使用工厂方法进行初始化;
 2.2. 存在多个构造函数,根据参数锁定构造函数进行初始化;
 2.3. 使用默认构造函数进行初始化;
3. 应用MergedBeanDefinitionPostProcessor;
4. 依赖处理;
5. 属性填充;
6. 循环依赖检查;
7. 注册DisposableBean和自定义的destory方法;
8. 完成创建并返回。

populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    if (bw == null) {
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
        }
        else {
            //bw为null,没有可填充的属性,直接返回
            return;
        }
    }

    boolean continueWithPropertyPopulation = true;

    //给InstantiationAwareBeanPostProcessor最后一次机会在属性设置前来改变bean
    //如:可以用来支持属性注入的类型
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                //返回值为是否继续填充bean,如果返回为false,则表示当前bean不需要在进行后续的处理了
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }
    //如果后处理器发出了停止填充命令,直接返回
    if (!continueWithPropertyPopulation) {
        return;
    }

    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        //根据名称自动注入
        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        //根据类型自动注入
        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }

    //后处理器是否已经初始化
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    //是否需要进行依赖检查
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    if (filteredPds == null) {
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }
                    //对所有需要进行依赖检查的属性值进行后处理,这里也是InstantiationAwareBeanPostProcessor哦
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }
                }
                pvs = pvsToUse;
            }
        }
    }
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }

    if (pvs != null) {
        //将属性值应用到bean中
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}
populateBean主要流程:
1. InstantiationAwareBeanPostProcessor处理器的应用,给它最后一次机会来处理bean,可以产生中断效果;
2. 根据注入类型byName/byType,提取依赖的bean,并同意放入propertyValues中;
  2.1 byName由autowireByName()方法处理,主要是根据名字获取对应的bean。
  2.2 byType由autowireByType()方法处理,主要逻辑是根据类型获取对应的bean,但是要比byName复杂一些,比如处理@Value注解,或者我们的自动注入是一个集合的时候,@AutoWired List<XxxService>.
3. 应用InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法,对获取完的属性,在填充之前再次处理,典型应用RequiredAnnotationBeanPostProcessor类中对属性的验证;
4. applyPropertyValues方法将上面所有的propertyValues中的属性填充至BeanWrapper,包括对Converter和PropertyEditors的使用对属性值进行处理。

initializeBean

//AbstractAutowireCapableBeanFactory.java
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        //...
    }
    else {
        //对特殊bean的处理,检查是否实现Aware并调用相应方法
        invokeAwareMethods(beanName, bean);
    }
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        //应用bean的前置处理器
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    try {
        //检查是否实现InitializingBean并调用afterPropertiesSet方法,调用初始化方法init-method
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    //...
    if (mbd == null || !mbd.isSynthetic()) {
        //应用bean的后处理器
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}
主要流程:
1. 对特殊bean的处理,检查是否是Aware子类,并调用相应的方法;
2. 应用bean的前处理器,BeanPostProcessor的子类;
3. 初始化bean;
  3.1 检查是否实现InitializingBean并调用相应方法;
  3.2 调用初始化方法init-method;
4. 应用bean的后处理器,BeanPostProcessor的子类。

这里可以看出来bean在初始化时的处理顺序。
Aware处理 --> 前置处理 --> afterPropertiesSet --> init-metod --> 后置处理。

registerDisposableBeanIfNecessary

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
    if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
        if (mbd.isSingleton()) {
            //单例模式
            //注册bean销毁方法,所有逻辑都在构造函数DisposableBeanAdapter中
            //包括检查是否是自定义的destroy方法,还是实现了DisposableBean
            registerDisposableBean(beanName,
                    new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        }
        else {
            //自定义scope模式
            Scope scope = this.scopes.get(mbd.getScope());
            if (scope == null) {
                throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
            }
            scope.registerDestructionCallback(beanName,
                    new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        }
    }
}

getObjectForBeanInstance

这个方法是获得我们真正想要的bean,因为原始bean可能是工厂bean,这样的话我们就需要调用指定的方法来获得真正的bean。

//AbstractAutowireCapableBeanFactory.java
protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
    //ThreadLocal,如果当前线程正在创建bean,那说明本次获取的bean其实是上个bean的依赖bean,加入到依赖当中
    String currentlyCreatedBean = this.currentlyCreatedBean.get();
    if (currentlyCreatedBean != null) {
        registerDependentBean(beanName, currentlyCreatedBean);
    }
    //调用父类返回bean
    return super.getObjectForBeanInstance(beanInstance, name, beanName, mbd);
}

继续看父类的方法。

//AbstractBeanFactory.java
protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

    //如果我们制定的name是&开头的,则说明可能是获取的工厂Bean或者其他,直接返回benInstance,不做任何处理
    if (BeanFactoryUtils.isFactoryDereference(name)) {
        //5.0之后出现了新的接口NullBean,如果实例是NullBean类型,则直接返回
        if (beanInstance instanceof NullBean) {
            return beanInstance;
        }
        //检查当前bean是否是FactoryBean类型,如果不是则报错,因为进入这个if,并走到这步,就说明需要返回的实例一定是FactoryBean
        if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
        }
    }
    //检查原始beanInstance是否是FactoryBeen类型,如果不是,那说明就是我们需要的bean,直接返回
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }

    //方法走到这里说明原始beanInstance是一个FactoryBean,而我们需要的真正bean是需要调用这个工厂bean的指定方法来获取的
    Object object = null;
    if (mbd == null) {
        //检查缓存是否存在已经解析过了的
        object = getCachedObjectForFactoryBean(beanName);
    }
    if (object == null) {
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        if (mbd == null && containsBeanDefinition(beanName)) {
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        //缓存没有,则走到这里,调用FactoryBean的指定方法,返回我们真正需要的bean
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

继续跟进getObjectFromFactoryBean(factory, beanName, !synthetic)这个方法。

//FactoryBeanRegistrySupport.java
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    //单例模式
    if (factory.isSingleton() && containsSingleton(beanName)) {
        synchronized (getSingletonMutex()) {
            //单例模式,先从缓存取
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
                //如果缓存中没有,则开始第一次初始化,这个方法里头就是去调用工厂Bean的指定方法factory.getObject()了
                object = doGetObjectFromFactoryBean(factory, beanName);
                //再检查一次缓存
                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                if (alreadyThere != null) {
                    object = alreadyThere;
                }
                else {
                    if (shouldPostProcess) {
                        //检查当前bean是否正在创建当中,如果是,则直接返回,不做任何处理
                        if (isSingletonCurrentlyInCreation(beanName)) {
                            // Temporarily return non-post-processed object, not storing it yet..
                            return object;
                        }
                        //开始处理bean
                        //将当前bean加入正在创建的集合
                        beforeSingletonCreation(beanName);
                        try {
                            //执行bean的处理器BeanPostProcessor的后置处理方法postProcessAfterInitialization方法
                            //不要慌以为漏掉了前置处理方法哦postProcessBeforeInitialization,前置处理是在createBean的时候,之前说过这个内容有点多,放到后边了的哦
                            object = postProcessObjectFromFactoryBean(object, beanName);
                        }
                        catch (Throwable ex) {
                            throw new BeanCreationException(beanName,
                                    "Post-processing of FactoryBean's singleton object failed", ex);
                        }
                        finally {
                            //从正在创建的bean的集合中移除当前bean
                            afterSingletonCreation(beanName);
                        }
                    }
                    //加入缓存,如果是单例模式,下次直接从缓存取
                    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;
    }
}

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
    throws BeanCreationException {
    //...
    object = factory.getObject();
    //...
    return object;
}

后置处理BeanPostProcessror

注释写得很详细,就不多解释了,直接来看调用bean的处理器BeanPostProcessror的方法。

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
    return applyBeanPostProcessorsAfterInitialization(object, beanName);
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {
    Object result = existingBean;
    //遍历所有注册了的BeanPostProcessor
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        //执行处理器的后处理方法
        Object current = processor.postProcessAfterInitialization(result, beanName);
        //如果处理后bean变成null了,则终止掉处理,返回result
        //所以在这里我们可以自己来实现一个BeanPostProcessor,指定了特定的顺序之后,返回null,就可以中断后续的处理了哦;不过还有专门用来中断的,称为具有中断 效应的bean处理器InstantiationAwareBeanPostProcessor哦!
        if (current == null) {
            return result;
        }
        //将处理过的bean赋值给result
        result = current;
    }
    return result;
}

bean的加载流程图

到最后了总结一下,把大致的bean加载流程图梳理一下。

bean_lifecycle

over ...

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部