微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

Spring refresh - finishBeanFactoryInitialization

分类：Java作者：mrathena原文地址AI导航网

博文目录

文章目录

生产 Bean 的流程

遍历 BeanName,筛选符合条件的走 getBean 流程

refresh 的 finishbeanfactoryInitialization 方法开始生产所有的单例 Bean

doGetBean 流程

Abstractbeanfactory 的 getBean 方法开始获取某个单例 Bean

  • 调用 doGetBean 方法
  • 先调用 getSingleton 尝试从一级缓存中取 Bean,有的话直接返回
  • 没有的话,尝试调用 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法,看该 Bean 是否能走短路创建
  • 不行的话,调用 doCreateBean 走真正的生产 Bean 的流程

deCreateBean 流程

AbstractAutowireCapablebeanfactory 的 doCreateBean 方法开始真正生产 Bean

  • 实例化: 就是通过工厂(@Bean)或反射(无参反射,有参构造函数反射)等完成 Bean 从无到有的第一步. ObjectBean 是不是在这里生效?
  • 填充属性: Bean 如果有 @Autowired / @Value 注解标注的属性,则需要做自动填充,主要由 AutowiredAnnotationBeanPostProcessor 来完成
  • 初始化
    • 调用 BeanNameAware,BeanClassLoaderAware,beanfactoryAware 的 set 方法
    • 调用所有 BeanPostProcessor 的 postProcessBeforeInitialization 方法
      • 其中有一个 ApplicationContextAwareProcessor,会调用 EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,ApplicationEventPublisherAware,MessageSourceAware,ApplicationContextAware 的 set 方法
      • 其中有一个 CommonAnnotationBeanPostProcessor,会处理 @postconstruct 注解,会调用被该注解标注的方法
    • 调用 InitializingBean 的 afterPropertiesSet,自定义的 init-method 方法
    • 调用所有 BeanPostProcessor 的 postProcessAfterInitialization 方法,AOP 动态代理就是在这里处理的

将 Bean 添加到一级缓存中

将成品 Bean 添加到一级缓存(单例池)中,从二三级缓存中移除,然后添加到保存已经处理过的 Bean 的 registeredSingletons 中

详细流程说明

类跳转

  • org.springframework.context.support.AbstractApplicationContext#finishbeanfactoryInitialization
    • org.springframework.beans.factory.support.DefaultListablebeanfactory#preInstantiateSingletons
      • org.springframework.beans.factory.support.Abstractbeanfactory#getBean(java.lang.String)
      • org.springframework.beans.factory.support.Abstractbeanfactory#doGetBean
        • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String)
        • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String,org.springframework.beans.factory.ObjectFactory<?>)
          • org.springframework.beans.factory.support.AbstractAutowireCapablebeanfactory#createBean(java.lang.String,org.springframework.beans.factory.support.RootBeanDeFinition,java.lang.Object[])
            • org.springframework.beans.factory.support.AbstractAutowireCapablebeanfactory#resolveBeforeInstantiation
            • org.springframework.beans.factory.support.AbstractAutowireCapablebeanfactory#doCreateBean
              • org.springframework.beans.factory.support.AbstractAutowireCapablebeanfactory#createBeanInstance
              • org.springframework.beans.factory.support.AbstractAutowireCapablebeanfactory#populateBean
              • org.springframework.beans.factory.support.AbstractAutowireCapablebeanfactory#initializeBean(java.lang.String,java.lang.Object,org.springframework.beans.factory.support.RootBeanDeFinition)
        • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingleton

AbstractApplicationContext#finishbeanfactoryInitialization

protected void finishbeanfactoryInitialization(ConfigurableListablebeanfactory beanfactory) {
	
	// ...

	// Allow for caching all bean deFinition Metadata,not expecting further changes.
	// 冻结所有 BeanDeFinition,将一个标记置为 true,表示要开始生产 Bean 了
	beanfactory.freezeConfiguration();

	// Instantiate all remaining (non-lazy-init) singletons.
	// 实例化剩余的单例 Bean
	beanfactory.preInstantiateSingletons();
}

DefaultListablebeanfactory#preInstantiateSingletons

  • 拿到所有的 BeanDeFinition 的名字来遍历 BeanDeFinition
  • 如果这个 BeanDeFinition 所代表的 Bean 不是抽象的,是单例的,不是懒加载的,则走流程
    • 如果这个 BeanDeFinition 所代表的 Bean 是 factorybean,则判断是否需要提前初始化,需要的话就走流程 getBean
    • 如果这个 BeanDeFinition 所代表的 Bean 不是 factorybean,就走流程 getBean
@Override
public void preInstantiateSingletons() throws BeansException {
	
	// ...

	// Iterate over a copy to allow for init methods which in turn register new bean deFinitions.
	// While this may not be part of the regular factory bootstrap,it does otherwise work fine.
	// 获取到所有的 BeanDeFinition 的名字
	List<String> beanNames = new ArrayList<>(this.beanDeFinitionNames);

	// Trigger initialization of all non-lazy singleton beans...
	// 遍历
	for (String beanName : beanNames) {

		// 通过 @Bean,@Component 等拿到的 BeanDeFinition 都是不同的类型
		// 把不同类型的 BeanDeFinition 都转换为统一的 RootBeanDeFinition,方便后续判断
		RootBeanDeFinition bd = getMergedLocalBeanDeFinition(beanName);

		// 满足条件的 BeanDeFinition 才会被加载
		// 条件: 不是抽象,是单例,不是懒加载
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

			// 判断是不是 factorybean,factorybean 这种 Bean 不是通过反射来实例化,而是通过调用 getobject 来生产其他的 Bean
			if (isfactorybean(beanName)) {

				// 通过 &beanName 的方式获取用于生产 Bean 的原始 factorybean 本身
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof factorybean) {
					factorybean<?> factory = (factorybean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof Smartfactorybean) {
						isEagerInit = AccessController.doPrivileged(
								(PrivilegedAction<Boolean>) ((Smartfactorybean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof Smartfactorybean &&
								((Smartfactorybean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {

				// 不是 factorybean 的话,就调用 getBean 来生产 Bean
				getBean(beanName);
			}
		}
	}

	// ...
	
}

beanfactory 和 factorybean 的区别

beanfactory 是 Bean 工厂,factorybean 是一种特殊的 Bean,这种类型的 Bean 不是通过反射来实例化,而是通过调用其 getobject 方法,通过编程的方式自行实现实例化

虽然名字很像容易混淆，但是完全2个东西

beanfactory是Bean的工厂，spring的顶层核心接口，没有beanfactory就没有Bean的存在，重要程度可想而知

factorybean也是一个接口，被他修饰的Bean将成为一个特殊的Bean,原本的Bean将被隐藏，而是由factorybean的getobject返回最终的Bean

Abstractbeanfactory#getBean(String)

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

Abstractbeanfactory#doGetBean

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

	// 拿到真实的 BeanName,这里传入的可能是别名或其他的
	String beanName = transformedBeanName(name);
	Object bean;

	// Eagerly check singleton cache for manually registered singletons.
	// 尝试去缓存中获取 Bean,如果有的话直接返回,没有的话再去创建
	// 其实就是去一级缓存(单例池,singletonObjects)中找
	Object sharedInstance = getSingleton(beanName);
	
	// ...

	// 缓存中没有该 Bean,需要走创建流程
	
	// Check if bean deFinition exists in this factory.
	// 子父容器,集成了 SpringMvc 后才有
	beanfactory parentbeanfactory = getParentbeanfactory();
	
	// ...

	RootBeanDeFinition mbd = getMergedLocalBeanDeFinition(beanName);
	checkMergedBeanDeFinition(mbd, beanName, args);

	// Guarantee initialization of beans that the current bean depends on.
	// 处理 dependsOn,就是某个 Bean 必须在另一个 Bean 之前创建,如果没有创建,就先去创建那个 Bean
	String[] dependsOn = mbd.getDependsOn();
	if (dependsOn != null) {
		for (String dep : dependsOn) {
			if (isDependent(beanName, dep)) {
				throw new BeanCreationException(mbd.getResourceDescription(),
						"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
			}
			registerDependentBean(dep, beanName);
			try {

				// 优先去加载生产顺序排在当前 Bean 前面的 Bean
				getBean(dep);
			}
			catch (NoSuchBeanDeFinitionException ex) {
				throw new BeanCreationException(mbd.getResourceDescription(),
						"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
			}
		}
	}

	// Create bean instance.
	if (mbd.isSingleton()) {

		// 这里的 getSingleton 和 上面的 getSingleton 不是同一个方法,后者是从一级缓存中拿
		// 该方法传入了一段代码,到合适的时机就会被回调执行
		sharedInstance = getSingleton(beanName, () -> {
			try {

				// 创建 Bean
				// getSingleton 里面调用 singletonFactory.getobject 的时候,就会回调传入的 createBean 方法
				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 = getobjectForBeanInstance(sharedInstance, name, mbd);
	}

	// ...
			
	return (T) bean;
}

DefaultSingletonBeanRegistry#getSingleton

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	
	// ..

	// 把当前 BeanName 标记成为正在创建中(通过添加到 singletonsCurrentlyInCreation 这个 Set 里面)
	// 如果因为循环依赖而导致第二次要添加到 Set 中,则添加将会失败,貌似是处理循环依赖用的?
	// 这个方法里面,如果添加 Set 失败的话,会抛异常,会不会打断 refresh 的流程
	beforeSingletonCreation(beanName);
	
	// ...

	// 执行传入代码的创建 Bean 的逻辑,调用 createBean 方法
	singletonObject = singletonFactory.getobject();
	
	// ...
	
	// 将生成的 Bean 加入到缓存中
	// 加入到 一级缓存 和 用来记录保存已经处理过的 Bean 的 registeredSingletons
	// 从二三级缓存中移除
	addSingleton(beanName, singletonObject);

	return singletonObject;
		
}

AbstractAutowireCapablebeanfactory#createBean

protected Object createBean(String beanName, RootBeanDeFinition mbd, @Nullable Object[] args) throws BeanCreationException {

	// ...
	
	// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
	// 调用 BeanPostProcessor
	// 这里是第一次调用 BeanPostProcessor
	// 通过调用 BeanPostProcessor 来尝试生成 Bean 对象,如果这里成功生成 Bean 对象,则会直接返回,不会再走常规的创建流程
	// 不管是 cglib 还是 jdk,通常不会在这里生成代理对象,因为这里生成 Bean 的话,还没有走填充的步骤,不是完整的 Bean,可能没法正常工作
	// 通常都是在 Bean 创建成功后的后置处理器中生成代理对象
	// 但是在这里会解析 AOP 切面信息进行缓存
	Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
	if (bean != null) {
		return bean;
	}
	
	// ...

	// 走真正的默认创建 Bean 的流程
	// 创建 Bean 的流程是 实例化 - 填充属性 - 初始化
	// Bean 实例化的流程是 BeanDeFinition - BeanWrapper - Bean
	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
	if (logger.isTraceEnabled()) {
		logger.trace("Finished creating instance of bean '" + beanName + "'");
	}
	return beanInstance;
	
	// ...
	
}

AbstractAutowireCapablebeanfactory#doCreateBean

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

	// Instantiate the bean.
	// BeanWrapper,就是包装了一个 Bean,提供了一些操作 bean 的方法
	// 提供用于分析和操作标准JavaBean的操作,获得和设置属性值(单独或批量),获取属性描述符以及查询属性的可读性的能力
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factorybeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {

		// 实例化,使用合适的方式,Bean 创建的第一步
		// 工厂方法(@Bean,更灵活,自己可以控制过程)
		// 反射(无参构造函数(class.newIns...),有参构造函数(constructor.newIns...,@Autowired 构造器))
		// 方法链太长了,先不看
		instanceWrapper = createBeanInstance(beanName, args);
	}
	Object bean = instanceWrapper.getWrappedInstance();
	
	// ...

	// Initialize the bean instance.
	Object exposedobject = bean;

	// 填充属性,Bean 创建的第二步,调用 setter 方法赋值
	// 方法链太长了,先不看
	populateBean(beanName, instanceWrapper);

	// 初始化,Bean 创建的第三步
	exposedobject = initializeBean(beanName, exposedobject, mbd);
	
	// ...

	// 默认单例 Bean 的生产流程走完
	return exposedobject;
}

AbstractAutowireCapablebeanfactory#createBeanInstance

Spring refresh - finishBeanFactoryInitialization - createBeanInstance 实例化

AbstractAutowireCapablebeanfactory#populateBean

Spring refresh - finishBeanFactoryInitialization - populateBean 填充属性

AbstractAutowireCapablebeanfactory#initializeBean(String,RootBeanDeFinition)

在这里插入代码片

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

String真的不可变吗？
Java中的String是不可变对象 在面向对象及函数编程语言中，不可变对象（英语：Immutable object）是一种对象，在被创造之后，它的状态就不可以被改变。至于状态可以被改变的对象，则被称为可变对象（英语：mutable object）。-- 来自百度百科 Java8 String源码
String, StringBuffer 和 StringBuilder之间的区别
String, StringBuffer 和 StringBuilder 可变性 String不可变 StringBuffer 和 StringBuilder 可变 线程安全 String 不可变，因此是线程安全的 StringBuilder不是线程安全的 StringBuffer 是线程安全的，内
讲讲Java的序列化反序列化？
序列化：把对象转换为字节序列的过程称为对象的序列化. 反序列化：把字节序列恢复为对象的过程称为对象的反序列化. 什么时候会用到 当只在本地 JVM 里运行下 Java 实例，这个时候是不需要什么序列化和反序列化的，但当出现以下场景时，就需要序列化和反序列化了： 当需要将内存中的对象持久化到磁盘，数据
数组到底是不是对象
先说结论，是对象！可以继续往下看 数组是不是对象 什么是对象？对象是类的一个实例，有状态和行为 Java对象： 软件的对象也有行为和状态 软件对象的状态称之为属性 方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成 而java中的数组具有java中其他对象的一些基本特点。比如封装了一些数据
金融、支付行业的开发者不得不知道的float、double计算误差问题
为什么浮点数 float 或 double 运算的时候会有精度丢失的风险呢？ 《阿里巴巴 Java 开发手册》中提到：“浮点数之间的等值判断，基本数据类型不能用 == 来比较，包装数据类型不能用 equals 来判断”。“为了避免精度丢失，可以使用 BigDecimal 来进行浮点数的运算”。 浮点
浅谈Integer缓存机制原理
面试题引入 这里引申出一个经典问题，看下面代码 Integer a = 100; Integer b = 100; System.out.println(a == b);//true Integer c = 200; Integer d = 200; System.out.println(c ==
能否自定义一个String类使用
先说下结论，可以自定义包名不为java.lang的String类，区别包名是可以正常使用的。 包名不为java.lang package com.seven.jvm; public final class String { /** The value is used for character st
一文讲清楚static关键字
static能修饰的地方 静态变量 静态变量: 又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它；静态变量在内存中只存在一份。 实例变量: 每创建一个实例就会产生一个实例变量，它与该实例同生共死。 静态方法 静态方法在类加载的时候就存在了，它不依赖于任何实
String究竟能存储多少字符？
能存储多少字符，通过以下步骤来看 首先String的length方法返回是int。所以理论上长度一定不会超过int的最大值。 编译器对字符串字面量长度的限制源自Java编译器（如javac）在处理常量池时的实现。编译器源码如下，限制了字符串长度大于等于65535就会编译不通过：// src/jdk.
解决哈希冲突的三种方法
为什么会哈希冲突 我们知道，在使用Map，Set这些集合时，都会重写hashcode方法，但Java中的hashCode方法会将对象映射到一个32位的整数范围（即从-2^31 到 2^31-1）。无论输入数据多么庞大，哈希函数生成的哈希值总是落在这个有限范围内。因此是会存在hash冲突的。 无论哈希
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native