美文网首页spring cloud基础知识点
spring之Bean实例化过程

spring之Bean实例化过程

作者: nextbeginning | 来源:发表于2019-03-25 17:37 被阅读0次
    一、概述

    spring初始化Bean的流程比较复杂,除了普通的构造函数实例化Bean之外,spring还支持工厂模式创建Bean(即常说的Factory Bean)。在spring实例化完Bean之后,会进行Bean的一些初始化工作。其中涉及到扩展点调用、运行时类型成员解析、依赖注入、懒加载等流程,还解决了循环引用、类型转换等问题。熟悉Bean加载的过程,开发过程中选择扩展点时就可以做到游刃有余。为了更加关注逻辑流程,本文所贴的代码精简掉了不相关的部分。

    二、Bean实例化概要流程
    1.获取Bean过程中涉及到的扩展点

    org.springframework.beans.factory.support.MethodOverride
    org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor
    org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor
    org.springframework.beans.factory.config.BeanPostProcessor
    org.springframework.beans.factory.InitializingBean

    2.关键方法框架图
    org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
    org.springframework.beans.factory.support.AbstractBeanFactory.getObjectForBeanInstance
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean
    三、Bean实例化详细流程
    1.相关入口
    • 根据类型获取Bean
      org.springframework.context.support.AbstractApplicationContext.getBean(Class<T>)
    • 根据名字获取Bean
      org.springframework.context.support.AbstractApplicationContext.getBean(String)
    • 实际获取Bean
      org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
    • 根据给出的Bean获取真实Bean(可能是factoryBean)
      org.springframework.beans.factory.support.AbstractBeanFactory.getObjectForBeanInstance
    • 创建Bean
      org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean
    • 实际创建Bean
      org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean
    2.详细解析

    除了单例且非懒加载的Bean是在ApplicationContext刷新的时候初始化之外。其他Bean都是在使用的时候才会加载,即我们常用的getBean方法。这个方法提供了很多重载,总的类型只有两种:

    • 根据类型获取Bean
    • 根据Name获取Bean
      两种类型最终内部都调用到了同一个方法,详见下述伪代码:
    -------------------- 根据类型获取Bean最终调用的是doGetBean方法
    -- org.springframework.context.support.AbstractApplicationContext
    public <T> T getBean(Class<T> requiredType) throws BeansException {
        return getBeanFactory().getBean(requiredType);
    }
    -- org.springframework.beans.factory.support.DefaultListableBeanFactory
    public <T> T getBean(Class<T> requiredType) throws BeansException {
        return getBean(requiredType, (Object[]) null);
    }
    public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
        String[] beanNames = getBeanNamesForType(requiredType);
        if (beanNames.length == 1) {
            return getBean(beanNames[0], requiredType, args);
        }
    }
    -- org.springframework.beans.factory.support.AbstractBeanFactory.getBean
    public <T> T getBean(String name, Class<T> requiredType, Object[] args) throws BeansException {
      return doGetBean(name, requiredType, args, false);
    }
    
    -------------------- 根据名字获取Bean最终调用的也是doGetBean方法
    -- org.springframework.context.support.AbstractApplicationContext
    public Object getBean(String name) throws BeansException {
        return getBeanFactory().getBean(name);
    }
    
    -- org.springframework.beans.factory.support.AbstractBeanFactory
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }
    

    doGetBean方法中很多地方都会调用getObjectForBeanInstance来获取最终需要的bean。该方法是spring为实现FactoryBean而编写的,其内部判断了是否需要利用工厂模式来创建出目标bean,详细伪代码如下:

    protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
        -- 如果对象不是一个FactoryBean或者这里就是要取FactoryBean,则直接返回
        if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
            return beanInstance;
        }
        -- 如果对象是一个FactoryBean且这里要获取对应的Bean,则尝试从factoryBean已创建的对象缓存中获取
        Object object = null;
        if (mbd == null) {
            object = getCachedObjectForFactoryBean(beanName);
        }
        -- 缓存中没有则用Factory去创建出Bean
        if (object == null) {
            FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
            if (mbd == null && containsBeanDefinition(beanName)) {
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    }
    -- org.springframework.beans.factory.support.FactoryBeanRegistrySupport
    protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
        Object object = doGetObjectFromFactoryBean(factory, beanName);
        object = postProcessObjectFromFactoryBean(object, beanName);
        this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
        return (object != NULL_OBJECT ? object : null);
    }
    
    -- doGetObjectFromFactoryBean中关键代码
    object = factory.getObject();
    return object;
    

    如果factory缓存中没有需要的Bean时,不管是单例Bean、模板Bean,最终都会调用createBean方法来创建一个Bean,并调用getObjectForBeanInstance方法确定目标bean。createBean内部会调用doCreateBean方法进行对象的创建、初始化等工作,详细伪代码如下:

    -- doGetBean
      Object bean = createBean(beanName, mbd, args);
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    -- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
    protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        resolveBeanClass(mbd, beanName);
        mbd.prepareMethodOverrides();
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        if (bean != null) {
            return bean;
        }
        Object beanInstance = doCreateBean(beanName, mbd, args);
        return beanInstance;
    }
    -- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        // 创建目标对象,包装成BeanWrapper
        BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
        // 执行MergedBeanDefinitionPostProcessor接口
        applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
        //将单例添加到Bean工厂的缓存中,解决循环引用问题
        ...
        // 成员变量初始化
        populateBean(beanName, mbd, instanceWrapper);
        Object exposedObject =  initializeBean(beanName, bean, mbd);
        //实例化它依赖的Bean
        ...
        //如果这个Bean是可销毁的Bean,则注册到factory中。
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
        return exposedObject;
    }
    

    populateBean和initializeBean完成了Bean的成员变量初始化工作。其中,populateBean方法在属性设置之前调用了InstantiationAwareBeanPostProcessor,允许实现自定义方式的属性注入。之后把依赖的非简单类型取出依赖注入(有set方法的这种)。再把所有属性在类型转换器走一次,设置到Bean中(applyPropertyValues)。

    protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        PropertyValues pvs = mbd.getPropertyValues();
        //调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法,
        ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)
        if (...) { //允许InstantiationAwareBeanPostProcessor终止初始化流程
            return;
        }
        //根据类型或者名字调用setXXX方法自动注入
        autowireByXXX(beanName, mbd, bw, newPvs);
        //成员被自动注入后,调用InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法
        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
        if (pvs == null) {
            return;
        }
        //解析所有运行时的引用,应用所有的属性值(包含类型转换)。
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
    

    initializeBean调用了些Aware方法:

    • BeanNameAware
    • BeanClassLoaderAware
    • BeanFactoryAware
      调用BeanPostProcessor的postProcessBeforeInitialization方法(例如ApplicationContextAware)。如果Bean实现了InitializingBean,则调用它的afterPropertiesSet方法。调用Bean设置的initMethod方法,调用BeanPostProcessor的postProcessAfterInitialization方法。详细的伪代码如下:
    protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        invokeAwareMethods(beanName, bean);
        Object wrappedBean = bean;
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        //包含InitializingBean的方法和自定义的init方法
        invokeInitMethods(beanName, wrappedBean, mbd);
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        return wrappedBean;
    }
    
    四、总结

    spring实例化Bean过程,提供了许多扩展点。其Factory Bean模式也是通过getBean方法内部做了特殊处理才实现的。在Bean被实例化之前,会调用MergedBeanDefinitionPostProcessor进行预处理,给予了我们对对象进行代理的机会,使其不去创建具体的目标类型对象。在配置文件加载前、加载后,spring都提供了可供我们添加逻辑的接口,来实现自己的增强功能。
    对ApplicationContext初始化流程不熟悉的话,可以参考这篇文章:spring扩展之application context初始化流程

    相关文章

      网友评论

        本文标题:spring之Bean实例化过程

        本文链接:https://www.haomeiwen.com/subject/oekcvqtx.html