Spring IOC 容器源码简单分析(三)——创建单例Bean

最新推荐文章于 2023-03-09 18:32:21 发布
最新推荐文章于 2023-03-09 18:32:21 发布
阅读量187 收藏
点赞数
分类专栏： Spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RebelHero/article/details/114373700
版权

前言

在Spring IOC 容器源码简单分析(二)——获取单例Bean

我们说了获取bean相关的一系列方法，就是先去缓存中获取，如果缓存没命中的话， 肯定就需要去创建bean了，那么在哪创建单例呢， 这就是上篇遗留的<5>和<6>的问题了，这个创建的过程很长，这篇文章可能一下写不完，慢慢来吧。

话不多说，let’s go。

由于接上文，因此还是沿用上次的习惯。

<6> 解析createBean

由于<5>的时候引用到了<6>，所以先来分析<6>的情况。

// 前情提要：
// beanName是根据name转换好的。 mbd 是 合并后的BeanDefinition， 
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

    if (logger.isTraceEnabled()) {
        logger.trace("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 {
        // Spring统一将 lookup-method 和 replace-method 称为override method，处理的就是这俩。
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                                               beanName, "Validation of method overrides failed", ex);
    }

    try {
        // <6-1> 在 bean 初始化前应用后置处理，如果后置处理返回的 bean 不为空，则直接返回
        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);
    }

    try {
        // <6-2> 创建bean。
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        // A previously detected exception with proper bean creation context already,
        // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
}

简单描述一下：

  1. 解析 bean class
  2. 处理 lookup-method 和 replace-method 配置
  3. 在 bean 初始化前应用后置处理，若后置处理返回的 bean 不为空，则直接返回
  4. 否则，调用 doCreateBean 创建 bean 实例。

总之，就是能返回bean实例。

<6-1>解析resolveBeforeInstantiation

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
   Object bean = null;
   // 检测是否解析过，该值会在下面的代码中会被设置
   if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
      // 确保BeanDefinition 不是合成的(不确定这句话是不是对的，因为翻阅了很久还是没找到它设为true的时机)
      // 同时 此工厂是否拥有InstantiationAwareBeanPostProcessor，它将在创建时应用于单例bean。
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         Class<?> targetType = determineTargetType(beanName, mbd);
         if (targetType != null) {
             // 前置
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
            if (bean != null) {
               // 后置处理。
               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
         }
      }
      mbd.beforeInstantiationResolved = (bean != null);
   }
   return bean;
}


protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // bean 初始化前置处理
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}

<6-2> 解析doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// BeanWrapper 是一个接口，它包裹着 bean 实例。
		BeanWrapper instanceWrapper = null;
		// 如果是单例。
		if (mbd.isSingleton()) {
			// 老实说这个缓存我不知道是干啥的。
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// <6-2-1> 在这create Bean。
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		// 获取实例化好的bean，暂时没填充属性。
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}
		// 允许后置处理器修改合并的bean定义。
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// 如果是单例的 && 允许循环依赖的 && 存于创建状态中。
		// 看单词意思，早期单例曝光，这个变量用于解决循环依赖。
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
            // 添加工厂对象到 singletonFactories 缓存中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// 初始化bean实例。
		Object exposedObject = bean;
		try {
			// <6-2-2> 在这，填充前面	实例化好的bean的属性。
			populateBean(beanName, mbd, instanceWrapper);
        	 // <6-2-3> 处理 bean 初始化完成后的各种回调。
			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) {
            // 还是获取早期引用。
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
                // 如果bean没有被wrapper封装。
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
                // 说明被wrapper封装了， allowRawInjectionDespiteWrapping 变量为true时表示，尽管被封装了，但还是允许原始的bean注入。
                // 那么下面的条件是， 被封装了 && 不允许原始的bean被注入 && 该bean有依赖的bean
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
                    // 表示实际依赖的对象。
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
                        // 如果已经创建的bean中包含该dependentBean，那么会返回false
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
                    // 那么就会报出异常，大概就是，作为循环引用，已经被注入到其他bean中了，但没使用到使用bean的最终版本。
					if (!actualDependentBeans.isEmpty()) {
						// 抛异常的，我给注释了。
					}
				}
			}
		}

		
		try {
            // 注册销毁逻辑
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

这里又延伸了其他的方法，还是鉴于篇幅的原因，我就不在此进行叙述，下篇见。

然后也简单概括一下该方法的整体逻辑。

  1. 还是先从缓存中获取BeanWrapper ，并清除掉。
  2. 缓存没有就去创建，并包裹在BeanWrapper，但此时还没有填充属性 。
  3. 如果允许暴露早期引用，就放进调用addSingletonFactory方法，用于解决循环依赖。
  4. 调用 populateBean 方法填充属性，调用 initializeBean 方法完成剩下的初始化工作。
  5. 注册销毁逻辑。

感觉spring写的真的很复杂，到第三篇才开始创建bean了，还只是刚开始创建，属性填充啥的都得下篇。

<5>解析getSingleton

这个要和之前<2>的getSingleton区分一下哈，不是一个方法哈。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(beanName, "Bean name must not be null");
   synchronized (this.singletonObjects) {
      // 还是先获取bean的实例，那不为空就说明就可以返回了。
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
         if (this.singletonsCurrentlyInDestruction) {
            throw new BeanCreationNotAllowedException(beanName,
                  "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                  "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
         }
         if (logger.isDebugEnabled()) {
            logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
         }
         // 到这里说明为空，那么需要将beanName放入到singletonsCurrentlyInCreation 和 inCreationCheckExclusions 中。
         // 表示该beanName正在创建。
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
             // 就是这里调用到了<6>！
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
         catch (IllegalStateException ex) {
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               throw ex;
            }
         }
         catch (BeanCreationException ex) {
            if (recordSuppressedExceptions) {
               for (Exception suppressedException : this.suppressedExceptions) {
                  ex.addRelatedCause(suppressedException);
               }
            }
            throw ex;
         }
         finally {
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = null;
            }
            // 由于已经获取到了，那么将beanName从singletonsCurrentlyInCreation 和 inCreationCheckExclusions 中移除。
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
            // 添加到singletonObjects和 registeredSingletons 中，并移除
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

简单概括一下：

  1. 先获取缓存中的bean，有就直接返回了。
  2. 否则，将beanName放入到singletonsCurrentlyInCreation 和 inCreationCheckExclusions 中。
  3. 调用singletonFactory.getObject 方法从而调用 createBean 方法创建 bean 实例
  4. 将 beanName 从 singletonsCurrentlyInCreation 集合中移除，同时添加缓存。

总结

这里由于是倒着写 5、6的，可能有些许的不好理解 ，主要是5中的调用singletonFactory.getObject可以调用到<6> createBean，至于<6>中的细节，在本篇中已写，耐心点看，其中还有创建单例的具体，我将在下篇中写到。

7k9c
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
深入解析Spring IoC源码：核心机制与实践应用
12-13
本文深入探讨了Spring框架中IoC容器的源码机制，涵盖了容器的初始化、Bean工厂的实例化、Bean定义的读取及Spring Bean的生命周期管理。通过精细的分析，本文揭示了AnnotationConfigApplicationContext的实例化过程，...
Spring IOC 容器源码分析 - 创建单例 bean 的过程
yyguy的博客
03-10 150
1. 简介 在上一篇文章中，我比较详细的分析了获取 bean 的方法，也就是getBean(String)的实现逻辑。对于已实例化好的单例 bean，getBean(String) 方法并不会再一次去创建，而是从缓存中获取。如果某个 bean 还未实例化，这个时候就无法命中缓存。此时，就要根据 bean 的配置信息去创建这个 bean 了。相较于getBean(String)方法的实现逻辑，创建...
Spring 单例的实现方式
qq_36891203的博客
04-09 949
单例模式 面试最常问的一种设计模式，即一个类只有一个实例 Java里有五种方式实现单例： 懒汉 饿汉synchronized 饿汉DLC 静态内部类 枚举类 spring里也有单例的概念，但不是严格意义上的单例模式 IOC容器通过HashMap存储bean，如果bean的作用域是单例，每次getBean就从HashMap里拿出bean，如果bean的作用域是prototype每次getBean就重新new一个返回。 默认情况下IOC容器是饿汉式，在初始化容器时就创建bean， 可以通过@Lazy注解延迟.
Spring IOC 实现原理
兴趣是最好的老师，勤能补拙
03-09 600
Spring IOC 实现原理
SpringIOC创建对象的单例和多例模式
weixin_44121790的博客
03-18 665
SpringIOC创建对象的单例和多例模式 单例模式(默认): 设置了单例模式的bean,会在Spring容器对象被创建的时候 就完成初始化创建,无论获取多少次都是同一个对象. 多例模式: 设置了多例模式的bean,在Spring容器对象被创建的时候不会被初 始化创建,每次获取的时候都会重新创建,每次获取的对象都不相同. <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.or
spring怎么实现单例模式
liyanlei的专栏
03-05 8537
spring怎么实现单例模式_弹指天下-CSDN博客_spring 单例模式 在Spring中，bean可以被定义为两种模式：prototype（多例）和singleton（单例） singleton（单例）：只有一个共享的实例存在，所有对这个bean的请求都会返回这个唯一的实例。 prototype（多例）：对这个bean的每次请求都会创建一个新的bean实例，类似于new。 Spring bean 默认是单例模式。 简单来说，spring中的单例是通过单例注册表实现的。 实战演示： 代码详
深入解析Spring IoC：源码与实践指南
最新发布
12-13
同时，本文还探讨了Spring Bean的生命周期，重点在于Bean容器的创建与Bean的初始化过程。这些深入的分析不仅有助于理解Spring的内部工作机制，而且对于Java开发者来说，能够更好地掌握如何有效地使用Spring框架进行...
spring IOC源码 – 单实例bean的循环依赖 源码及过程
12-21
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; /** * @author ：xiaolinzi * @date ：2020-4-14 20:46 * @email ： xiaolinzi95_27@163....
Spring IoC源码分析1
08-03
1. bean的装配方式 1.表明当前类是一个配置类，是方法bean的源 2.将@Configuration配置的AppConfig的BeanDefinitio
SpringIOC源码.rar
06-10
1、 需要去构造一个Spring容器：ClassPathXmlApplicationContext； 2、 需要注解定义两个注解：@Service、@Resource； 3、 使用反射的手段读取指定目录下的class信息，解析Class信息； 4、 对Class信息的注解做处理...
Spring是如何实现单例模式的？
ClawHub的专栏
12-13 1661
Spring是通过注册表实现单例的，Ioc容器维护了一个bean表格，当需要一个单例bean时，从表格中获取，没有获取到的，向表格注册一个新的bean。 源码就不贴了。  ...
spring IOC容器创建对象的三种方式
xyffly的博客
02-26 5344
SpringIOC容器，是spring核心内容。 作用：创建对象 & 处理对象的依赖关系,把对象的创建交给IOC容器   IOC容器创建对象（默认单例）： 创建对象, 有三种方式： 1） 调用无参数构造器 2） 带参数构造器 3） 工厂创建对象                    工厂类，静态方法创建对象                    工厂类，非静态方法创建对象
SpringIOC的创建对象的单例多例模式和自动注入
wyy的博客
05-26 760
[1] SpringIOC创建对象的单例和多例模式 问题: Spring容器对象根据配置文件创建对象的时机默认发生在Spring容器对象在被创建的时候,也就是说,我们一旦获取到Spring容器对象,意味着可以直接获取Spring容器中的对象使用了.那么,如果我对同一个bean对象,连续获取N次,获取到的是不是同一个对象呢?因为spring容器对象底层使用的是map集合存储的bean对象,对map集合按照同一个键名获取数据,获取的是同一个,也就说按照同一个键名从Spring容器中获取的都是同一个对象,那么如
Bean作用域、生命周期
qq_41552331的博客
10-08 144
作用域 在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象 . 作用域的种类 Spring 容器在初始化一个 Bean 的实例时，同时会指定该实例的作用域。Spring3 为 Bean 定义了五种作用域，具体如下。 1）singleton 单例模式，使用 singleton 定义的 Bean 在 Spring 容器中只有一个实例，这也是 Bean 默认的作用域。 <bean id="Serv
Spring之IOC和单例、多例
ITzhanghao的博客
08-23 553
spring之IOC 什么是IOC？ IOC：控制反转，将对象的创建、销毁、初始化等一系列的生命周期的过程交给spring容器来处理 搭建spring框架的过程： 第一步 新建一个Java Project，并建立一个lib文件夹，然后导入spring的jar包 第二步 书写主配置文件(applicationContext.xml) 不是必须这个名字，但是规范是这么写，一般大家都会遵守规范。 ...
Java面试题（十）
筱岩的博客
07-03 378
91、用Java写一个单例类。  答：  - 饿汉式单例 public class Singleton {    private Singleton(){}    private static Singleton instance = new Singleton();    public static Singleton getInstance(){            return in
设计模式
Donnie93的专栏
02-28 596
简述一下你了解的设计模式。 答：所谓设计模式，就是一套被反复使用的代码设计经验的总结（情境中一个问题经过证实的一个解决方案）。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式使人们可以更加简单方便的复用成功的设计和体系结构。将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。 在GoF的《Design Patterns: Elements of
用java代码自定义一个springioc容器
09-05
以上代码实现了一个简单的Spring IOC容器，核心思想是使用一个Map来存储注册的bean，通过bean的名称来获取对应的对象。在main方法中，我们创建了一个UserService对象并注册到容器中，然后通过容器的getBean方法获取...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值