七、finishBeanFactoryInitialization方法解析

最新推荐文章于 2023-02-10 10:28:05 发布
最新推荐文章于 2023-02-10 10:28:05 发布
阅读量297 收藏
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42795685/article/details/116940776
版权

代码：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		//判断BeanFactory中是否存在名称为“conversionService”且类型为ConversionService的Bean，如果存在则将其注入到beanFactory
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		/* 如果之前没有任何bean后处理程序(例如PropertyPlaceholderConfigurer bean)注册，
		则注册一个默认的嵌入式值解析器:此时，主要用于解析注释属性值。*/
		// 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// 尽早初始化LoadTimeWeaverAware bean，以允许尽早注册它们的转换器transformers。
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// 停止使用临时ClassLoader进行类型匹配。
		beanFactory.setTempClassLoader(null);//为了类型匹配，停止使用临时的类加载器

		//缓存容器中所有注册的BeanDefinition元数据，以防被修改。
		beanFactory.freezeConfiguration();

		//重点：实例化所有剩余的(非lazy-init)单例bean。
		beanFactory.preInstantiateSingletons(); //对配置了lazy-init属性的单态模式Bean进行预实例化处理
	}

接下来的代码大家可以参照第2章的流程图来阅读。我把图拿过来了。

finishBeanFactoryInitialization执行流程图

public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		//遍历一个副本以允许init方法注册新的bean定义。虽然这可能不是常规的工厂引导的一部分，但它可以正常工作。
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);//创建一个beanNames的备份

		//遍历所有beanDefinitionNames，开始实例化bean
		for (String beanName : beanNames) {
			//验证是否需要实例化
			//获取当前beanName对应的bean定义信息
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {//bean不是抽象的，不是懒加载，是单例

				if (isFactoryBean(beanName)) { //判断是否是FactoryBean接口的的实现类
					//获取实现类接口对应的bean。若是，通过getBean(&beanName)拿到的是FactoryBean本身；通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
					//这里拿到的是FactoryBean本身
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						//判断这个FactoryBean是否希望急切的初始化
						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) {
							//TODO 初始化bean(FactoryBean.getObject返回的对象)
							getBean(beanName);
						}
					}
				}
				else { //不是FactoryBean接口的的实现类
					//TODO 获取bean（初始化）
					getBean(beanName);
				}
			}
		}

		//触发所有SmartInitializingSingleton的后初始化回调
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				//获取系统安全性接口
				if (System.getSecurityManager() != null) {
					//如果有，根据所拥有的权限和指定来执行回调方法
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					//没有就直接执行回调方法
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

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

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
		//去除factoryBean名字前的&符号，解析别名
		String beanName = transformedBeanName(name);
		Object bean;

		//直接尝试分别从三级缓存获取或者singletonFactory.getObject()中获取,解决循环依赖
		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 + "'");
				}
			}
			//获取给定bean实例的对象，如果是FactoryBean，则为bean实例本身或其创建的对象。
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else { //缓存中没有 或者 缓存中有但参数不为空
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 获取父工厂,如果当前工厂找不到，就去父工厂查找，一直链式查找，直到找到
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				String nameToLookup = originalBeanName(name);//将bean名称解析规范
				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);
				}
			}

			// TODO 如果不需要类型检查，那么标记bean已经创建过了
			if (!typeCheckOnly) {
				//标记bean为已创建，加入alreadyCreated集合
				markBeanAsCreated(beanName);
			}

			try {
				//获取Bean定义信息
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				//检查，若是抽象类则抛出异常
				checkMergedBeanDefinition(mbd, beanName, args);

				// 保证初始化当前bean所依赖的bean。
				String[] dependsOn = mbd.getDependsOn();//获取当前bean的依赖项
				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);
						try {
							//递归getBean，确保依赖项全部初始化
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance. 创建bean实例。
				if (mbd.isSingleton()) { //如果是还单例bean(没有被修改成其他类型)
					//创建单例bean
					sharedInstance = getSingleton(beanName, () -> { //表达式会在getSingleton方法调用singletonFactory参数时执行
						//重写factoryBean中的getObject方法
						try {
							//TODO 创建bean，填充属性，处理循环依赖
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							/* 显式地从单例缓存中删除实例:它可能是在创建过程中急切地放在那里的，以允许循环引用解析。
							  还要删除接收到对bean的临时引用的任何bean。 */
							destroySingleton(beanName);
							throw ex;
						}
					});
					//若获取的bean为factoryBean，则获取该工厂创建的单例对象；
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) { //创建多实例的bean
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						//创建bean
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else { //其他的作用域的bean
					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);
							}
						});
						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;
			}
		}

		// 检查所需的类型是否与实际bean实例的类型匹配。
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isTraceEnabled()) {
					logger.trace("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		//返回创建的bean
		return (T) bean;
	}

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

		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		//bean定义的备份
		RootBeanDefinition mbdToUse = mbd;

		/* 确保bean类在此时被实际解析，如果动态解析的class不能存储在共享合并bean定义中，则克隆bean定义。*/
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);//TODO 获取beanDefinition对的class
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		//验证及准备覆盖的方法（对override属性进行标记及验证）
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {

			//给BeanPostProcessors一个返回代理而不是目标bean实例的机会。

			//执行InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation的实现方法
			//执行BeanPostProcessor.postProcessAfterInitialization的实现方法
			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 {
			//创建常规的Bean，并填充属性，处理循环依赖
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

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

		//实例化bean
		BeanWrapper instanceWrapper = null;
		//实例化bean的包装类
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			//TODO 创建beanName对应的对象,放入包装类，此时还不算是spring bean,还未初始化，是个半成品
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//获取beanName对应的对象
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		//允许后处理器修改合并的bean定义。
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try { //合并BeanDefinition
					//BeanPostProcessors,执行MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition实现类方法
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		//即使是由像BeanFactoryAware这样的生命周期接口触发的时候，也可以热切地缓存单例对象来解析循环引用。
		//判断当前是否单例&&允许循环引用&&当前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");
			}
			//将当前bean的工厂存入三级缓存singletonFactories
			addSingletonFactory(beanName,
					//执行SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference实现方法
					() -> getEarlyBeanReference(beanName, mbd, bean)  //在singletonFactory.getObject时会执行这个方法
			);
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			//属性填充，对循环依赖的属性进行处理
			populateBean(beanName, mbd, instanceWrapper);
			//初始化，调用工厂回调以及初始化方法和beanPostProcessor后处理程序，执行部分Aware(AOP在这里完成)
			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.");
					}
				}
			}
		}

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

		return exposedObject;
	}
qq_42795685
关注
专栏目录
spring源码解析（五）-finishBeanFactoryInitialization
huanglei_hacker的博客
06-07 659
介绍： 前面三篇文章小编介绍了spring启动过程中的三个重要方法：obtainFreshBeanFactory、invokeBeanFactoryPostProcessors、invokeBeanFactoryPostProcessors。。。。那么还有一个更为重要的方法，也是sping源码的核心部分------普通bean的创建和初始化的过程。。。。。 概述： 该方法会实例化所有剩余的非懒加载单例 bean。除了一些内部的 bean、实现了 BeanFactoryPostProcessor..
Spring源码解析之八finishBeanFactoryInitialization方法即初始化单例bean
「 虚幻私塾」
03-09 197
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 Spring源码解析之八finishBeanFactoryInitialization方法即初始化单例bean 七千字长文深刻解读，Spirng中是如何初始化单例bean的，和面试中最常问的Spring是如何解决循环依赖？ 今天解读Spring核心方法refresh()中最最重
finishBeanFactoryInitialization方法逐句分析
H.C. Lee的博客
05-21 316
本文是Spring系列文章的一部分。其他相关文章见Spring系列文章导航 本文逐句分析finishBeanFactoryInitialization方法。
finishBeanFactoryInitialization解析
qq_36716000的博客
06-01 136
finishBeanFactoryInitialization解析
SpringFramework源码分析(4):finishBeanFactoryInitialization方法详解
sodawoods的博客
07-18 238
在SpringFramework源码分析(2):IoC容器AnnotationConfigApplicationContext的创建中，我们分析了SpringIoC容器创建的源码。我们已经知道在AbstractApplicationContext的refresh方法里，通过invokeBeanFactoryPostProcessors(beanFactory)完成了类的扫描，将类转化成了BeanDefinition并存储在了DefaultListableBeanFactory的beanDefinitionM
finishBeanFactoryInitialization 详解（六）
Jay的博客
08-04 3786
前言 在介绍了 obtainFreshBeanFactory、invokeBeanFactoryPostProcessors、registerBeanPostProcessors 三个重要方法后，我们终于来到了最后一个重要方法：finishBeanFactoryInitialization。finishBeanFactoryInitialization 是这四个方法中最复杂也是最重要的，是整个 Spring IoC 核心中的核心。 概述 该方法会实例化所有剩余的非懒加载单例 bean。除了一些内部的 bea
Spring启动流程源码之finishBeanFactoryInitialization
qq_43418737的博客
03-09 815
Spring启动流程源码之finishBeanFactoryInitialization
Spring解析之finishBeanFactoryInitialization即初始化单例bean
Java_ttcd的博客
08-06 249
preInstantiateSingletons()方法的主要任务是进行初始化的，在初始化前同样是一系列判断，如，是否是懒加载的，是否是一个factorybean（一个特别的bean，负责工厂创建的bean），最后调用getBean()方法。此时返回A中，A此时能拿到B的对象顺利完成自己的初始化阶段2、3，最终A也完成了初始化，进去了一级缓存singletonObjects中，而且更加幸运的是，由于B拿到了A的对象引用，所以B现在hold住的A对象完成了初始化。比如A依赖于B，B依赖于C，C又依赖于A。..
Spring的refresh()方法相关异常解析
08-28
Spring refresh()方法相关异常解析 Spring 是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring 是一个轻量级的 Java 开发框架，由...
finishBeanFactoryInitialization
qq_39412825的博客
04-28 104
1、进行对象的创建 1、setConversionService设置类型的转换服务 2、addEmbeddedValueResolver 设置内置的值处理器 3、freezeConfigurations() 冻结BeanDefinition 4、preInstantiasteSingletons 开始对象的实例化 1、从容其中获取所有的beanDefinitionNames集合 2、从集合中获取每一个元素，来进行对象的创建 3、根据benaName来获取完整的Bean Definition对象，而且是Roo
6、finishBeanFactoryInitialization流程.vsdx
08-15
详细讲解了spring启动流程中refresh()方法中的finishBeanFactoryInitialization流程：初始化所有剩下的单实例bean
spring源码08——finishBeanFactoryInitialization(beanFactory)
lovesman的博客
06-24 260
调用链： finishBeanFactoryInitialization(beanFactory) ---->DefaultListableBeanFactory.preInstantiateSingletons(); 类名：DefaultListableBeanFactory 对符合条件的bean进行初始化，条件就是： 非抽象的，单实例的，非懒加载的 public void preInstantiateSingletons() throws BeansException { if (
spring 源码笔记 启动过程(十三) finishBeanFactoryInitialization(beanFactory)
TBryant的博客
01-13 310
第十三步：finishBeanFactoryInitialization(beanFactory) 第一次调用Bean后置处理器：判断Bean是否需要代理 第一次调用Bean后置处理器调用链 resolveBeforeInstantiation:1099, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.s...
10_finishBeanFactoryInitialization
hu619016140的博客
08-26 190
finishBeanFactoryInitialization 的作用就是初始化剩余的所有单实例bean。除了一些需要提前初始化的类。比如前面实现了BeanDefinitionRegistryPostProcessor(在invokeBeanFactoryPostProcessors方法的时候)。通过beanFactory.getBean提前获取的。最后的都是在该方法中完成创建。 pr...
JAVA的反射学习
weixin_39618279的博客
11-05 192
反射的目的是为了获得某个实例的信息。因此，当我们拿到某个Object实例时，我们可以通过反射获取该Object的class信息 void printObjectInfo(Object obj) { Class cls = obj.getClass(); } 要从Class实例获取获取的基本信息，参考下面的代码： public class Main { public static void main(String[] args) { printClassInfo...
【Spring-4】refresh方法之finishBeanFactoryInitialization
qq_34501351的博客
08-04 151
该方法主要处理实例化bean的操作，懒加载的bean在调用的时候实例化，不是懒加载的则在此时进行实例化。 @Override public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // 找到所有的注册的bd List<Stri
七、Spring IOC——finishBeanFactoryInitialization方法(实例化各种非懒加载单例对象)
qq_35784669的博客
11-19 267
看下Spring如何实例化bean,以及如何实现在bean的实例化通过各种各样的后置处理器完成bean的增强。 1、入口是AbstractApplicationContext中的finishBeanFactoryInitialization(beanFactory);,源码如下,主要做了如下几件事： protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { //
refresh之finishBeanFactoryInitialization(beanFactory)
qq_39804316的博客
04-24 605
finishBeanFactoryInitialization(beanFactory)这个方法是来实例化所有的非懒加载的Bean的，在前面已经将配置文件解析成了beanDefinition，现在准备生产，这个过程涉及来几个重要的概念 bean的生命周期 循环依赖 三级缓存 bean的后置处理器 protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // Initia
Spring源码学习笔记(十二)、finishBeanFactoryInitialization
dongdong199033的博客
02-10 426
/ 初始化所有的singleton beans(lazy-init的除外)初始化所有的singleton beans(lazy-init的除外)
spring refresh方法源码解析
最新发布
06-03
12. 调用 `finishBeanFactoryInitialization(beanFactory)` 方法，完成所有非延迟初始化的单例 bean 的初始化工作； 13. 调用 `finishRefresh()` 方法，完成上下文的刷新工作。 需要注意的是，`refresh()` 方法在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值