Spring4.3.x 容器中bean的创建过程(1)——走进初始化bean的主要战场

本文详细解析了Spring框架中Bean的创建过程,包括BeanDefinition对象的作用、Bean的实例化及初始化流程,以及如何通过BeanFactory接口创建不同作用域的Bean。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

概述

spring创建bean时需要一个重要的对象,那就是BeanDefinition对象,spring在创建BeanFactory时会把xml配置文件和注解信息转换为一个个BeanDefinition对象,BeanDefinition对象存储的是单个bean的配置信息,比如依赖类、scope、是否延迟加载等等,对于BeanDefinition的创建过程,可以阅读我的Spring4.3.x 浅析xml配置的解析过程系列,如
把<bean>标签转换成BeanDefinition对象
解析context命名空间之annotation-config标签
解析context命名空间之component-scan标签
解析aop命名空间之config标签
解析aop命名空间之aspectj-autoproxy标签

拿到BeanDefinition对象和一切准备工作完成后,Spring就开始根据BeanDefinition对象创建第一的bean。那Spring容器是怎么创建bean的呢?这就是这篇文章讨论的内容。

在spring容器的初始化过程中,BeanFactory对象创建完成后,容器就会创建并执行bean工厂后处理器对象,然后在注册Bean后处理器时会创建Bean后处理器对象,初始化消息资源时会创建MessageSource对象,初始化事件传播器时会创建ApplicationEventMulticaster对象。前面所有应用内部级的对象创建完成后,容器才会初始化所有业务级的非延迟加载单例对象。关于spring容器的初始化过程见Spring4.3.x 容器的刷新过程,下面从spring容器创建非延迟加载单例对象来探讨bean的创建过程。

创建bean的过程

Spring容器在刷新过程中以AbstractApplicationContext的finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)方法为初始化容器中所有非延迟加载单例bean的入口,这个方法的源码如下。

    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // 初始化ConversionService
        // 在ConfigurableApplicationContext接口中声明:String CONVERSION_SERVICE_BEAN_NAME = "conversionService";
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // 注册一个默认的内部value解析器
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
                @Override
                public String resolveStringValue(String strVal) {
                    return getEnvironment().resolvePlaceholders(strVal);
                }
            });
        }

        // 初始化LoadTimeWeaverAware对象来支持注册他们的transformers
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // 停止使用临时类加载器来做类型匹配
        beanFactory.setTempClassLoader(null);

        // 允许缓存所有的bean元数据定义,不希望今后再更改工厂的配置
        beanFactory.freezeConfiguration();

        // 初始化所有非延迟单例bean
        beanFactory.preInstantiateSingletons();
    }

finishBeanFactoryInitialization方法中创建bean的代码是最后一句,调用ConfigurableListableBeanFactory接口的preInstantiateSingletons()方法,这个方法的实现代码在DefaultListableBeanFactory类中,源码如下。

    @Override
    public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Pre-instantiating singletons in " + this);
        }

        // 复制一份Bean名称
        List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

        // 触发所有非延迟加载单例bean的初始化
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    // 获取FactoryBean对象
                    final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                    boolean isEagerInit; // 标识FactoryBean是否需要马上初始化Bean
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                            @Override
                            public Boolean run() {
                                return ((SmartFactoryBean<?>) factory).isEagerInit();
                            }
                        }, getAccessControlContext());
                    } else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        // 创建Bean
                        getBean(beanName);
                    }
                } else {
                    // 创建Bean
                    getBean(beanName);
                }
            }
        }

        for (String beanName : beanNames) {
            // 获取指定的Bean,此步骤会使用BeanFacotry对象获取对应的Bean
            Object singletonInstance = getSingleton(beanName);
            // 触发所有SmartInitializingSingleton对象的afterSingletonsInstantiated()方法
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            smartSingleton.afterSingletonsInstantiated();
                            return null;
                        }
                    }, getAccessControlContext());
                } else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }

preInstantiateSingletons()方法调用BeanFactory接口的getBean(String name)方法来创建Bean,此方法的实现代码在AbstractBeanFacotry中,源码如下。

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

这里简单说一下BeanFactory的5个getBean重载方法的实现最终都是调用AbstractBeanFacotry类的doGetBean方法,它有4个参数,第一个参数为字符串类型的name参数,可以是bean的ID或者别名;第二个参数为Class类型的requiredType参数,指定需要获取的Bean的类型;第三个参数为Object数组的args参数,用于指定构造方法的参数;第四个参数为布尔类型的typeCheckOnly,true表示只做类型检查,false不仅要检查类型,还要把bean标识为已创建。这个方法的源码如下。

    protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {

        final String beanName = transformedBeanName(name);
        Object bean;

        // 首先从singleton缓存中查找手动注册的单例对象
        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 + "'");
                }
            }
            // 返回sharedInstance自身
            // 如果sharedInstance为FactoryBean对象,则返回它所创建的Bean实例
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        } else {
            // 检查beanName是否指向的是一个正在创建的prototype对象,是则抛出异常
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // 检查当前BeanFacotry中是否存在对应的BeanDefintion对象
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // 不存在,则从父BeanFactory中获取Bean
                String nameToLookup = originalBeanName(name);
                if (args != null) {
                    // 根据指定的构造器参数创建Bean
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                } else {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }

            if (!typeCheckOnly) {
                // 把bean标识为已创建
                markBeanAsCreated(beanName);
            }

            try {
                // 获取RootBeanDefinition对象
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                // 检查BeanDefintion是否合格,如果它代表的是一个抽象类,则抛出异常
                checkMergedBeanDefinition(mbd, beanName, args);

                // 获取bean所依赖的bean
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    // 初始化所有依赖的Bean
                    for (String dependsOnBean : dependsOn) {
                        if (isDependent(beanName, dependsOnBean)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                        }
                        registerDependentBean(dependsOnBean, beanName);
                        getBean(dependsOnBean);
                    }
                }

                // 创建Bean实例
                if (mbd.isSingleton()) {
                    // 创建单例bean
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                // 创建Bean
                                return createBean(beanName, mbd, args);
                            } catch (BeansException ex) {
                                destroySingleton(beanName);
                                throw ex;
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    // bean为prototype,创建新的实例
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);
                        // 创建bean
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    // 创建其它作用域的Bean
                    String scopeName = mbd.getScope();
                    final Scope scope = this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
                    try {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                            @Override
                            public Object getObject() throws BeansException {
                                beforePrototypeCreation(beanName);
                                try {
                                    // 创建bean
                                    return createBean(beanName, mbd, args);
                                }
                                finally {
                                    afterPrototypeCreation(beanName);
                                }
                            }
                        });
                        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;
            }
        }

        // 检查创建好的Bean实例的类型是否与requiredType匹配
        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                // 如果不匹配则进行类型转换
                return getTypeConverter().convertIfNecessary(bean, requiredType);
            } 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;
    }

在doGetBean方法中,不管是哪种作用域的Bean,都会调用createBean方法来创建Bean实例,createBean方法在AbstractBeanFactory中被定义为抽象方法,它的实现在AbstractAutowireCapableBeanFactory类中,源码如下。

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

        // 从bean的定义中获取正确的Class对象
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        try {
            // 准备方法重写,这个是通过<lookup-method>标签定义的
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }

        try {
            // 执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法返回一个代理对象
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        } catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }

        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }

AbstractAutowireCapableBeanFactoryd的createBean会调用resolveBeforeInstantiation方法来执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法,如果这个方法返回的bean不为null,则bean创建完成。否则将调用看AbstractAutowireCapableBeanFactory类的doCreateBean方法创建bean的,doCreateBean方法的源码如下。

    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        // 初始化bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 创建Bean实例,并返回其包装器
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
        Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

        // 到这一步,Bean已经实例化完成,但还没定制bean的属性
        // 此时,执行MergedBeanDefinitionPostProcessor对象的postProcessMergedBeanDefinition方法
        // 比如处理@Autowired、@Value等注解
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                mbd.postProcessed = true;
            }
        }

        // 为了解决bean之间的循环引用,需要提前缓存单例的Bean的引用
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            // 为单例bean添加ObjectFactory对象
            addSingletonFactory(beanName, new ObjectFactory<Object>() {
                @Override
                public Object getObject() throws BeansException {
                    // 此处将执行SmartInstantiationAwareBeanPostProcessor后处理器的getEarlyBeanReference方法
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }

        // 初始化bean的
        Object exposedObject = bean;
        try {
            // 设置bean的属性值
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                // 调用bean后处理器以及InitializingBean的afterPropertiesSet方法
                // =>和init-method方法
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        } catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            } else {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }

        if (earlySingletonExposure) {
            // 获得单例bean
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!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需要在工厂关闭前被销毁,则注册bean
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        } catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

doCreateBean方法是实例化和初始化bean的战场,它调用createBeanInstance方法创建bean的实例和BeanWrapper对象;调用populateBean方法设置bean的属性;调用initializeBean方法执行Bean后处理器和InitializingBean对象的afterPropertiesSet方法以及init-method方法;最后调用registerDisposableBeanIfNecessary方法注册bean的销毁方法。

总结

(1)不管是什么作用域的bean,都会通过AbstractAutowireCapableBeanFactory类的doCreateBean方法来创建。doCreateBean方法是创建bean的主要战场。

(2)只要调用BeanFactory对象的任意一个getBean方法都会触发bean的创建,BeanFactory接口提供了5个getBean重载方法。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值