spring5源码篇(3)——getBean

已于 2023-03-16 21:36:11 修改
阅读量507 收藏
点赞数 1
分类专栏： Spring 文章标签： spring java
于 2023-03-05 20:54:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43196360/article/details/129348052
版权
文章详细阐述了SpringFramework在v5.3.19版本中bean的加载和创建过程，包括从`AbstractBeanFactory`的`doGetBean`方法开始，如何处理单例和原型bean，依赖检查，以及不同作用域下的bean创建。在bean创建阶段，重点讨论了`createBean`和`doCreateBean`方法，涉及bean实例化、属性填充、初始化以及循环依赖检查等关键步骤。
摘要由CSDN通过智能技术生成

spring-framework 版本：v5.3.19

文章目录

bean的加载

beanFactory的genBean最常用的一个实现就是AbstractBeanFactory.getBean()。
以ApplicationContext为例，流程是: ApplicationContext.getBean()----》BeanFactory.getBean()----》AbstractBeanFactory.getBean()
在这里插入图片描述
而真正做事情的是deGetBean方法

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

		//获取beanName
		String beanName = transformedBeanName(name);
		Object beanInstance;

		//无论是什么作用域都先尝试从单例池获取
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isTraceEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			//有时候并不是放回实例本身，而是返回其映射的实例。如：BeanFactory情况下返回指定方法返回的实例
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			//当原型模式下有循环依赖时，抛异常（原型模式下若存在循环依赖会导致内存泄漏）
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			//尝试从父beanFactory加载bean
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else if (requiredType != null) {
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}

			//如果不是仅仅做类型检查则是创建bean，这里进行记录
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
					.tag("beanName", name);
			try {
				if (requiredType != null) {
					beanCreation.tag("beanType", requiredType::toString);
				}
				//得到合并后的beanDefinition
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				//检查beanDefinition，抽象的beanDefinition会报错
				checkMergedBeanDefinition(mbd, beanName, args);

				//先加载dependsOn标注的bean
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						//dePendsOn引起的循环依赖，抛异常
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						//注册dependentBeanMap（dependsOn 于哪些bean）和注册dependenciesForBeanMap（被哪些bean dependOn）
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				//-----------------------------------开始创建bean-----------------------------------------------
				//单例模式
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//原型模式
				else if (mbd.isPrototype()) {
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				//其他模式
				else {
					String scopeName = mbd.getScope();
					if (!StringUtils.hasLength(scopeName)) {
						throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
					}
					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, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new ScopeNotActiveException(beanName, scopeName, ex);
					}
				}
			}
			catch (BeansException ex) {
				beanCreation.tag("exception", ex.getClass().toString());
				beanCreation.tag("message", String.valueOf(ex.getMessage()));
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
			finally {
				beanCreation.end();
			}
		}
		//必要时进行类型转换
		return adaptBeanInstance(name, beanInstance, requiredType);
	}

bean的创建

从bean的加载中得知，当一个从缓存中获取不到的时候就会调用createBean方法去创建一个bean。而在AbstractBeanFactory中这是一个抽象方法，具体的创建逻辑由具体的beanFactory类自行实现。至少目前为止，spring内置的实现只有AbstractAutowireCapableBeanFactory.createBean()。无论是AnnotationConfigApplicationContext还是ClassPathXmlApplicationContext创建bean的逻辑最终都会来到这个方法。

虽然AnnotationConfigApplicationContext和ClassPathXmlApplicationContext并不直接继承AbstractAutowireCapableBeanFactory。但是都维护了一个DefaultListableBeanFactory成员变量，而这个成员变量继承自AbstractAutowireCapableBeanFactory。

createBean
在这里插入图片描述

doCreateBean

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

		//如果是单例，factoryBeanCache.remove
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}

		//实例化bean
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		//MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition（如：AutowiredAnnotationBeanPostProcessor）
		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;
			}
		}

		//提前暴露bean，循环依赖处理
		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");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		Object exposedObject = bean;
		try {
			//属性填充
			//InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
			//byName，byType注入
			//InstantiationAwareBeanPostProcessor.postProcessProperties --如果返回null--> postProcessPropertyValues（如：AutowiredAnnotationBeanPostProcessor）
			//applyPropertyValuespostProcessPropertyValues
			populateBean(beanName, mbd, instanceWrapper);
			//初始化bean（是指据配置自定义的初始化bean如：@PostConstruct，而不是指构造方法的初始化）
			//初始化之前会调用 PostProcessors.postProcessBeforeInitialization
			//初始化之后会调用 PostProcessors.postProcessAfterInstantiation
			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) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(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 " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		//注册DisposableBean，如果配置了destroy-methoy，这里需要注册以便于在销毁的时候调用
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

initializeBean
在这里插入图片描述

总结

getBean流程

1：transformedBeanName(name) 转换为对应的beanName
2：getSingleton(beanName) 尝试从缓存中加载单例
3：isPrototypeCurrentlyIncreation(beanName) 原型模式的依赖检查
4：检测父BeanFactory
5：getMergedLocalBeanDefinition(beanName) GernericBeanDefinition转换为RootBeanDefinition
6：依赖检测
7：根据不同的模式创建bean
8：getObjectForBeanInstance(prototypeInstance, name, beanName, mbd) 根据得到的Bean获取真正对象
9：如果需要则做类型转换

createBean流程

1：锁定class
2：指定方法的覆盖
3：InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
4：doCreateBean

doCreateBean流程

1：若为单例，移除factoryBeanCache内的缓存
2：实例化Bean
3：MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition（如：AutowiredAnnotationBeanPostProcessor）
4：提前暴露bean，循环依赖处理

(populateBean)
5：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
6：byName、byType自动注入
7：InstantiationAwareBeanPostProcessor.postProcessProperties --如果返回null–> postProcessPropertyValues（如：AutowiredAnnotationBeanPostProcessor的自动注入）
8：applyPropertyValues

(initializeBean)
9：aware方法的执行（beanNameAware，beanClassLoaderAware，beanFactoryAware）
10：PostProcessors.postProcessBeforeInitialization
11：自定义初始化bean（如：InitializingBean.afterPropertiesSet，@PostConstruct，init-method）
12：PostProcessors.postProcessAfterInstantiation

13：循环依赖检查，判断是否需要抛出异常
14：注册DisposableBean

贫僧洗发水呢
关注
专栏目录
Spring 源码之--getBean完整流程
pengweismile的专栏
06-18 1914
begin with : new AnnotationConfigApplicationContext(MainConfig.class); ==> org.springframework.context.annotation.AnnotationConfigApplicationContext public AnnotationConfigApplicationContext(...
Spring源码-getBean获取bean实例
vanchine的博客
02-15 1164
实例化Bean 单例bean，并且lazy-init为false（默认是false），则 ApplicationContext在刷新的时候就实例化该Bean，并且将实例化的Bean放到缓存中，下次再使用该Bean的时候， 直接从这个缓存中获取；如果单例bean是懒加载的，即lazy-init为true，则在第一次getBean获取该Bean的时候进行实例化，并放入缓存；scope是prototype的多例bean，每次使用获取Bean的时候都会进行实例化 <bean id="" class="" sc
Spring源码分析之——getBean细节
做最亮的星星
01-03 608
先看一下调用图，方便后面看代码 @Test public void testGetBean() { // 业务代码 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-bean.xml"); XXXX xxxx = applicationContex...
getBean(String)和getBean(Class＜T＞)的区别
kaoguopu7299的博客
04-24 400
Q:有的bean可以用getBean(String)拿到，用getBean(Class＜T＞)拿不到，有的却相反。 getBean(String): getBean(Class＜T＞) 相对比较复杂
spring getBean源码调用大致流程
万物皆字节
11-04 605
大致调用流程 以配置文件的方式为例 org.springframework.context.support.AbstractApplicationContext.getBean(String) ↓ org.springframework.beans.factory.support.AbstractBeanFactory.getBean(String) ↓ org.springframewor...
spring源码研究——getBean
小9的专栏
08-14 330
我们追踪getBean，大致会追踪到这样一个方法org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(String name,Class<T> requiredType,Object[] args, boolean typeCheckOnly) throws BeansException 其实这是BeanFac
spring源码系列（五）——番外篇回答网友的问题
12-21
在Spring框架中，`@Autowired` 注解和 `ApplicationContextAware` 接口都可以用来注入 `ApplicationContext` 对象，但它们的实现方式和使用场景略有不同。`@Autowired` 是Spring提供的依赖注入机制，主要用于自动...
二、Spring源码分析——BeanFactory
08-11
《Spring源码分析——BeanFactory》 在Java的IoC（Inversion of Control）和DI（Dependency Injection）领域，Spring框架扮演着至关重要的角色。BeanFactory是Spring的核心组件之一，它是容器的基石，负责管理应用...
Spring源码——JDBC
等一杯咖啡的博客
10-27 1778
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第八章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 本章内容基于之前所说的Spring IOC 和 AOP功能...
Spring源码——AOP
等一杯咖啡的博客
10-21 2251
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第七章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 正式进入正文前，强烈推荐先阅读文末参考阅读第一篇：关于 S...
ApplicationContext的getBean
weixin_43735471的博客
10-10 5779
通过ApplicationContext获取bean的方法
ApplicationContext.getBean源码解析
小英雄
07-04 1367
spring中有两种类型的Bean：一种是普通的JavaBean；另一种就是工厂Bean（FactoryBean），这两种Bean都受Spring的IoC容器管理，但它们之间却有一些区别。 普通的JavaBean不再多说，我们将其定义好，然后在配置文件中定义并配置其依赖关系，就可以通过IoC容器的getBean获取到。 那么FactoryBean呢？ FactoryBean跟普通Bean不同，它是实现了FactoryBean<T>接口的Bean， 1.通过BeanFactory类的.
Spring--getBean()与@Autowired的对比
IT利刃出鞘的博客
08-18 5099
本文介绍getBean()与@Autowired的对比。
SpringBoot中获取ApplicationContext对象并getBean的三种实现方式
韩大能耐的博客
08-25 8404
1.方式一：直接注入 @Autowired private ApplicationContext applicationContext; @Test public void test() { // T 为转换后的具体bean类型 T bean = (T) applicationContext.getBean("beanId"); } 2.方式二：利用SpringBoot启动类中run方法返回的Context，存到项目静态变量中，使用自定
spring源码学习 getSingleton()方法
m0_51571683的博客
12-26 1085
getSingleton()是位于DefaultSingletonBeanRegistry类中的方法，是用来获取bean的单例实例的。在创建bean实例的时候都会用到这个方法
Spring ApplicationContext的getBean方法
最新发布
小湘西的博客
06-05 779
方法可以接受接口或实现类作为参数。当接口有多个实现类时，可以通过指定Bean名称、使用@Qualifier注解、标注@Primary注解来获取具体的实现类Bean。这些方法可以帮助你在Spring容器中精确地找到并管理不同的Bean实例。
Spring——ApplicationContext之getBean方法详解
热门推荐
weixin_43949634的博客
02-23 1万+
我们知道可以通过ApplicationContext的getBean方法来获取Spring容器中已初始化的bean。getBean一共有以下四种方法原型： getBean(String name) getBean(Class type) getBean(String name,Class type) getBean(String name,Object[] args) 下来我们分别来探讨以上四种方式获取bean的区别。 其中实体类Person定义如下： public class Person { p
SpringContext.getBean
qq_43409111的博客
07-23 2720
@Autowired SpringContext springContext; package com.yzf.sysnps.common.core; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.sprin
application.getBean(FactoryBean)源码浅析
活成自己想要的模样
06-19 1576
在配置ehcache的时候没搞懂以下配置到底什么情况,其中EhCacheManagerFactoryBean到底返回的到底是EhCacheManagerFactoryBean实例还是CacheManager实例，返回CacheManager实例的话又是org.springframework.cache.ehcache.EhCacheCacheManager还是net.sf.ehcache.Cach...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值