spring创建bean的详细过程

最新推荐文章于 2024-07-18 05:47:25 发布

lzt928786458

最新推荐文章于 2024-07-18 05:47:25 发布

阅读量494

点赞数

分类专栏：笔试面试题整理 spring 文章标签： spring java bean

本文链接：https://blog.csdn.net/weixin_38857307/article/details/114643019

版权

本文详细阐述了Spring创建Bean的三个主要步骤：通过反射创建Bean实例，填充Bean属性值，执行Bean初始化。核心方法包括AbstractAutowireCapableBeanFactory的createBean和doCreateBean。在refresh容器时，Spring会初始化所有非延迟加载的bean，涉及到的关键函数有doGetBean，createBean以及BeanPostProcessor的相关处理。BeanPostProcessor在初始化过程中起到关键作用，能够提前处理Bean的实例化和初始化操作。

摘要由CSDN通过智能技术生成

参考：https://www.cnblogs.com/kevin-yuan/p/12157017.html

bean创建的三步
1.通过反射创建 bean 的实例
2.填充 bean 里面的属性值，包括 @AutoWired、@Resource、@Value 标记的属性
3.执行bean初始化
在AbstractAutowireCapableBeanFactory类里面有一个createbean方法，createBean里面真正创建bean的是doCreateBean

createBeanInstance() // 通过反射创建 bean 的实例
populateBean() // 填充 bean 里面的属性值，包括 @AutoWired、@Resource、@Value 标记的属性
initializeBean() // 对 bean 进行初始化工作，包括一些初始化方法的执行，如：awareMethods、BeanPostProcessor、initMethods

Spring Bean 的初始化是在 Spring 容器 refresh() 时进行的。
Spring 容器 refresh 时会调用 finishBeanFactoryInitialization() 来初始化所有非延迟加载的 bean。

org.springframework.context.support.AbstractApplicationContext.refresh()
    --> org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization // 初始化bean（延迟加载除外）
        --> org.springframework.beans.factory.config.ConfigurableListableBeanFactory.preInstantiateSingletons()
            --> org.springframework.beans.factory.support.AbstractBeanFactory.getBean
                --> org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
                    --> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean // 创建 bean（实例化 bean）

根据参考文献里面的执行链，我在idea里面看了看，比较关键的几个函数，就是doGetBean createBean

doGetBean方法介绍（100多行的函数，标一下关键点）
0. pre: 查看bean注册缓存，如果 bean 已经注册过，就从缓存中获取 bean 的实例

在 parentBeanFactory 中去找，如果找到对应的bean，则直接返回父容器里面的 bean
初始化当前 bean 依赖的 bean
创建 bean 的实例
　　3.1 单例类型的 bean 创建
　　3.2 原型类型的 bean 创建
　　3.3 其他 scope 类型（request、session等）的 bean 创建
将新创建的 bean 的实例保存到缓存 singletonObjects 中

    protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
   
        String beanName = this.transformedBeanName(name);
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        //下面这个if就是在判断是否有缓存中有
        if (sharedInstance != null && args == null) {
   
            if (this.logger.isTraceEnabled()) {
   
                if (this.isSingletonCurrentlyInCreation(beanName)) {
   
                    this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
   
                    this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }

            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
   
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
   
                throw new BeanCurrentlyInCreationException(beanName);
            }
			//去父类的工厂里面找，进了下面那个if循环，就出不来了
            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
   
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
   
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }

                if (args != null) {
   
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                if (requiredType != null) {
   
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }

                return parentBeanFactory.getBean(nameToLookup);
            }

            if (!typeCheckOnly) {
   
                this.markBeanAsCreated(beanName);
            }
			
			//真正创建bean
            try {
   
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                //获取这个bean的依赖
                String[] dependsOn = mbd.