源码解析 DefaultListableBeanFactory

DefaultListableBeanFactory作为SpringApplicationContext的核心,是BeanFactory的实现,广泛应用于XML和注解配置。本文将深入研究其getBean(String name)方法,了解Spring框架中bean的获取过程。

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

DefaultListableBeanFactory,是 GenericApplicationContext 和 AbstractRefreshableApplicationContext 的(bean工厂)默认策略,而这两者是所有 xxxApplicationContext 的基类,因此 DefaultListableBeanFactory 可以说是 ApplicationContext 的标准配置,非常具有学习价值

  • 值得一提的是,Spring 3.1 推荐的做法是采用 DefaultListableBeanFactory + XmlBeanDefinitionReader(不要将两者捆绑起来),前者用于管理Bean工厂,而后者可读取多种多样的XML资源,具有高度可配置性,这种模式得到大量使用,例如:
    • XmlWebApplicationContext 采用了 DefaultListableBeanFactory + XmlBeanDefinitionReader,后者专门用于读取XML配置
    • AnnotationConfigApplicationContext 采用了 DefaultListableBeanFactory + AnnotatedBeanDefinitionReader,后者专门用于读取注解配置

继承体系

这里写图片描述


1.查看getBean(String name)源码

DefaultListableBeanFactory 的 getBean(String name) 方法是由其父类 AbstractBeanFactory 实现的,查看其源码

@Override
public Object getBean(String name) throws BeansException {
    //第二个参数:bean的类型
    //第三个参数:仅用于实例创建过程所采用的参数
    //第四个参数:貌似是一种优化措施
    return doGetBean(name, null, null, false);
}

//......

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

    //解析 bean name
    final String beanName = transformedBeanName(name);
    Object bean;

    //快速检查singleton实例的缓存
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        if (logger.isDebugEnabled()) {
            //判断该singleton实例是否处于“正在创建”
            if (isSingletonCurrentlyInCreation(beanName)) {
                //是的话,说明这是“循环引用”现象,返回的是提前创建的未完全初始化的singleton实例
                logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                //否的话,说明singleton实例已完成初始化并缓存
                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        //bean instance -> 返回它本身
        //FactoryBean -> 创建一个Object,并返回
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        //判断该prototype实例是否处于“正在创建”(在当前线程)
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        //获取父Bean工厂(父容器)
        BeanFactory parentBeanFactory = getParentBeanFactory();
        //判断bean definition是否存在
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            //不存在 -> 递归查找父Bean工厂(父容器)
            String nameToLookup = originalBeanName(name);
            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为“已创建”,可用于后续的重复创建实例优化缓存效果
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            //如果目标是child bean definition,呢么会递归融合parent bean definition的所有属性
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            //BeanDefinition校验(比如Bean不能是Abstract)
            checkMergedBeanDefinition(mbd, beanName, args);

            //优先初始化当前Bean所依赖的其他Bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    registerDependentBean(dep, beanName);
                    getBean(dep);
                }
            }

            //获取singleton实例,必要时创建一个新的并注册(比如延迟加载的场景)
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                    @Override
                    public Object getObject() throws BeansException {
                        try {
                            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.
                            destroySingleton(beanName);
                            throw ex;
                        }
                    }
                });
                //bean instance -> 返回它本身
                //FactoryBean -> 创建一个Object,并返回
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            //创建一个新的prototype实例
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                //bean instance -> 返回它本身
                //FactoryBean -> 创建一个Object,并返回
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            //其他作用域(request、session、ServletContext等等)
            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 {
                    //从目标作用域的底层存储机制中获取该实例,必要时创建一个新的
                    //----比如 request.getAttribute("")就是“request”作用域的底层存储机制
                    //注:如果类似于singleton(长作用域)依赖一个request(短作用域)的场景,建议采用“Spring作用域代理”
                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        }
                    });
                    //bean instance -> 返回它本身
                    //FactoryBean -> 创建一个Object,并返回
                    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;
        }
    }

    //类型检查
    if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
        //如果类型不符,尝试进行“类型转换”
        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;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值