spring源码解析（十）：refresh()中finishBeanFactoryInitialization()：初始化所有剩下的单实例bean

最新推荐文章于 2022-10-24 08:30:00 发布
最新推荐文章于 2022-10-24 08:30:00 发布
阅读量340 收藏
点赞数
分类专栏： spring源码之启动流程 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011151359/article/details/99586020
版权

文章目录

spring refresh()中finishBeanFactoryInitialization()：初始化所有剩下的单实例bean

finishBeanFactoryInitialization():初始化所有剩下的单实例bean。
除了一些内部的Bean、实现了BeanFactoryPostProcessor的Bean、实现了BeanPostProcessor的Bean，其他的Bean都会在这个方法中被实例化,并且BeanPostProcessor的调用也是在这个方法中。

在这里插入图片描述

流程图下载地址：https://download.csdn.net/download/u011151359/11558047

查看finishBeanFactoryInitialization()

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        //初始化上下文的转换服务，ConversionService是一个类型转换接口
		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));
		}
        
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

        //初始化LoadTimeWeaverAware Bean
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}
        //停止使用临时的类加载器
		beanFactory.setTempClassLoader(null);

        //缓存所有的bean definition数据
		beanFactory.freezeConfiguration();

        // 实例化所有的non-lazy-init 单例
		beanFactory.preInstantiateSingletons();
	}

1、preInstantiateSingletons()：预实例化所有非懒加载单例Bean

直接进入最后一行：beanFactory.preInstantiateSingletons(),进入到DefaultListableBeanFactory类中的preInstantiateSingletons():预实例化所有非懒加载单例Bean

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}

        //1. 获取beanDefinitionNames所有的beanNames
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

        //2. 遍历初始化所有非懒加载单例Bean
		for (String beanName : beanNames) {
		    //Bean定义公共的抽象类是AbstractBeanDefinition，普通的Bean在Spring加载Bean定义的时候，实例化出来的是GenericBeanDefinition
			//Spring上下文包括实例化所有Bean用的AbstractBeanDefinition是RootBeanDefinition
			//用getMergedLocalBeanDefinition方法做了一次转化，将非RootBeanDefinition转换为RootBeanDefinition
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			
			//如果Bean不是抽象的，是单例的，不是懒加载的，则开始创建单例对象通过调用getBean(beanName)方法初始化
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			    //是否为FactoryBean
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final 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 {
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

该方法实现了：

  1. 获取容器内加载的所有BeanDefinition
  2. 遍历初始化所有非懒加载单例Bean

1.1、getMergedLocalBeanDefinition():将非RootBeanDefinition转换为RootBeanDefinition

普通的Bean在Spring加载Bean定义的时候，实例化出来的是GenericBeanDefinition。

Spring上下文包括实例化所有Bean用的AbstractBeanDefinition是RootBeanDefinition

用getMergedLocalBeanDefinition方法做了一次转化，将非RootBeanDefinition转换为RootBeanDefinition

    protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
		// Quick check on the concurrent map first, with minimal locking.
		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
		if (mbd != null) {
			return mbd;
		}
		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
	}
	
	protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
			throws BeanDefinitionStoreException {

		return getMergedBeanDefinition(beanName, bd, null);
	}


protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
			throws BeanDefinitionStoreException {

		synchronized (this.mergedBeanDefinitions) {
		
		    //准备一个RootBeanDefinition变量引用，用于记录要构建和最终要返回的BeanDefinition，
			RootBeanDefinition mbd = null;

			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}

			if (mbd == null) {
				if (bd.getParentName() == null) {
					// Use copy of given root bean definition.
					if (bd instanceof RootBeanDefinition) {
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
						mbd = new RootBeanDefinition(bd);
					}
				}
				else {
					BeanDefinition pbd;
					try {
						String parentBeanName = transformedBeanName(bd.getParentName());
						if (!beanName.equals(parentBeanName)) {
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
							BeanFactory parent = getParentBeanFactory();
							if (parent instanceof ConfigurableBeanFactory) {
								pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
							}
							else {
								throw new NoSuchBeanDefinitionException(parentBeanName,
										"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
										"': cannot be resolved without an AbstractBeanFactory parent");
							}
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
					}
					// Deep copy with overridden values.
					mbd = new RootBeanDefinition(pbd);
					mbd.overrideFrom(bd);
				}

				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
				}

				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}

				if (containingBd == null && isCacheBeanMetadata()) {
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}

			return mbd;
		}
	}

1.2、查看getBean(beanName)->doGetBean():核心方法

其中 getBean(beanName)为核心方法，进入到AbstractBeanFactory类的getBean()方法：

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

继续进入到doGetBean()：

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        
        //转换beanName(去掉name前面的"&"")
		final String beanName = transformedBeanName(name);
		Object bean;
        
        //在singleton缓存中查找bean实例 第一次初始化时候返回为空
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		else {
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

            //获取父类的BeanFactory
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
            //把需要创建的bean打上正在创建标记
            //上文中markBeanAsCreated(beanName)方法使用，避免重复创建
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
			
			    //根据BeanName获取BeanDefinition
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

                //BeanDefinition里存储的依赖bean挨个取出来进行实例化,递归调用getBean
				String[] dependsOn = mbd.getDependsOn();
				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(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance.
				//创建单例的bean
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
                //创建多例的bean
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
                //创建其他作用域的bean
				else {
					String scopeName = mbd.getScope();
					final 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;
			}
		}

		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.isDebugEnabled()) {
					logger.debug("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}
1.2.1、查看createBean():创建bean方法
@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

        //判断注入的Bean是否可以被实例化，是否可以通过类装载器载入
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		//重写prepareMethod
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
		    //如果Bean配置了PostProcessor，那么返回一个Proxy
			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.isDebugEnabled()) {
				logger.debug("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);
		}
	}
1.2.1.1、查看doCreateBean()
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
        
        //包含了真正的bean对象和bean的class，以及PropertyDescriptor集合
		BeanWrapper instanceWrapper = null;
		//如果是singleTon，从factoryBeanInstanceCache中获取instanceWrapper
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		//如果没有，则自己创建
		if (instanceWrapper == null) {
		    //进行bean的构造方法，创建bean
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		//如果不是NullBean，则将resolvedTargetType 属性设置为当前的WrappedClass
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		//这边主要是寻找几个meta，@PostConstruct,@Autowire,@Value,@Resource，@PreDestory等
		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是单例，且支持循环依赖，且当前bean正在创建，通过往singletonFactories添加一个objectFactory，
        //这样后期如果有其他bean依赖该bean 可以从singletonFactories获取到bean，getEarlyBeanReference可以对返回的bean进行修改，这边目前除了可能会返回动态代理对象 其他的都是直接返回bean
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
		    //填充bean的属性
			populateBean(beanName, mbd, instanceWrapper);
			//初始化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) {
				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 " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
		    //注册DisposableBean
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}
1.2.1.1.1、createBeanInstance():创建instanceWrapper
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		if (mbd.getFactoryMethodName() != null)  {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		// Need to determine the constructor...
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
		return instantiateBean(beanName, mbd);
	}
1.2.1.1.2.applyMergedBeanDefinitionPostProcessors():寻找@PostConstruct,@Autowire,@Value,@Resource，@PreDestory等
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}

其中getBeanPostProcessors()：
在这里插入图片描述

1.2.1.1.3、initializeBean():初始化bean
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}
陈小亮L
关注
专栏目录
spring核心源码分析第十八篇 refresh流程一finishBeanFactoryInitialization三步曲之createBeanInstance
小麒麟的博客
01-04 716
这里写目录标题createBeanInstance核心流程demo讲解supplier与factorymethoddemo一supplierdemo一instantiateUsingFactoryMethod源码分析源码分析一构造方法的选择源码分析一instantiateBean的实现jdk创建对象cglib创建对象总结 createBeanInstance核心流程 Supplier机制 FactoryMethod机制 autowireConstructor机制 instantiateBean机制
Spring源码：Bean的实例化及初始化过程
个人站点：javatv.net
11-03 4576
1. 概述 在前面的文章中，我们把 refresh() 中 obtainFreshBeanFactory、invokeBeanFactoryPostProcessors、方法都梳理了一遍，其中还有一个 registerBeanPostProcessors，但个人觉得实际上和 invokeBeanFactoryPostProcessors类似，所以没有单独写一篇文章去描述的，尽管它非常重要，但是你可以自己去分析一下或者看看这篇文章：registerBeanPostProcessors 详解。 refresh(
SpringBoot finishBeanFactoryInitialization(beanFactory) 方法分析(bean实例化)
weixin_43960292的博客
04-10 586
finishBeanFactoryInitialization(beanFactory) /** * Finish the initialization of this context's bean factory, * initializing all remaining singleton beans. */ protected void finishBeanFactoryI...
spring加载流程refresh之finishBeanFactoryInitialization(beanFactory)
yu_kang的博客
03-24 2170
实例化所有BeanAbstractApplicationContext.finishBeanFactoryInitialization()判断是否有bdName为conversionService的bd(实现ConversionService接口)判断是否有LoadTimeWeaverAware类型的bdDefaultListableBeanFactory.preInstantiateSingle...
Spring refresh - finishBeanFactoryInitialization
mrathena
10-15 208
博文目录 文章目录前言AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory);DefaultListableBeanFactory.preInstantiateSingletons();BeanFactory 和 FactoryBean 的区别 前言 finishBeanFactoryInitialization(beanFactory) 主要是实例化所有满足条件的单例 Bean AbstractApplicatio
spring ioc容器创建与bean初始化源码解析5：初始化所有剩余未初始化的单实例bean及最终完成容器创建
u013905744的专栏
06-26 525
11. finishBeanFactoryInitialization(beanFactory); 初始化所有剩下的（因为之前的BeanPostProcessor Bean可能已经在前面初始化了）单实例bean； // Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization...
Spring Bean生命周期：Bean的初始化阶段
我就是我的博客
03-04 1217
【Spring Bean 生命周期系列】传送门 1、Spring Bean生命周期: Bean元信息的配置与解析阶段 2、Spring Bean生命周期: Bean的注册 3、Spring Bean生命周期: BeanDefinition的合并过程 4、Spring Bean生命周期: Bean的实例化 5、Spring Bean生命周期：属性赋值阶段 写在前面 注：本文章使用的 SpringBoot 版本为 2.2.4.RELEASE，其 Spring 版本为 5.2.3.RELEASE 前言 接着上
SpringIOC refresh()初始化代码实例
08-24
在 finishBeanFactoryInitialization() 方法中，Spring 框架会对 beanFactory 进行初始化，包括实例化所有不需要延迟初始化的单例bean，并将 beanDefinitionNames 拷贝到 frozenBeanDefinitionNames 中。同时，...
Spring Bean创建初始化流程.docx
03-04
在Spring框架中，Bean的创建和初始化是IoC（Inversion of Control）容器的核心功能，这一过程涉及到多个步骤。以下是对Spring Bean创建初始化流程的详细解释： 1. **初始化ApplicationContext**： 开始时，通过`...
深入解析Spring IoC源码：核心机制与实践应用
最新发布
12-13
6. **容器刷新**：最后，调用`refresh()`方法，执行一系列初始化操作，包括调用`invokeBeanFactoryPostProcessors`和`finishBeanFactoryInitialization`，确保所有Bean定义被正确处理和初始化。 二、Spring Bean的...
6、finishBeanFactoryInitialization流程.vsdx
08-15
详细讲解了spring启动流程中refresh()方法中的finishBeanFactoryInitialization流程：初始化所有剩下的单实例bean
初学Spring源码3.11:finishBeanFactoryInitialization(beanFactory)
qq_34069839的博客
11-13 243
finishBeanFactoryInitialization(beanFactory) finishBeanFactoryInitialization方法做了两件事： beanFactory对象的初始化 实例化bean配置文件中配置的单例bean /** * 完成上下文的bean Factory的初始化,初始化所有的剩余的单例bean * Finish the initialization of this context's bean factory, * initializing all ..
spring源码08——finishBeanFactoryInitialization(beanFactory)
lovesman的博客
06-24 252
调用链： finishBeanFactoryInitialization(beanFactory) ---->DefaultListableBeanFactory.preInstantiateSingletons(); 类名：DefaultListableBeanFactory 对符合条件的bean进行初始化，条件就是： 非抽象的，单实例的，非懒加载的 public void preInstantiateSingletons() throws BeansException { if (
spring 源码笔记 启动过程(十三) finishBeanFactoryInitialization(beanFactory)
TBryant的博客
01-13 296
第十三步：finishBeanFactoryInitialization(beanFactory) 第一次调用Bean后置处理器：判断Bean是否需要代理 第一次调用Bean后置处理器调用链 resolveBeforeInstantiation:1099, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.s...
【Spring源代码阅读之九】refresh刷新容器之finishBeanFactoryInitialization()方法对非延迟加载的单例Bean调用getBean()实例化流程
weixin_42997554的博客
03-22 545
refresh刷新容器之finishBeanFactoryInitialization方法对非延迟加载的单例Bean调用getBean实例化流程导图AbstractApplicationContext#finishBeanFactoryInitialization()DefaultListableBeanFactory#preInstantiateSingletons()AbstractBeanF...
Spring注解驱动开发第46讲——Spring IOC容器创建源码解析(六)之初始化所有剩下的单实例bean（上）
李阿昀的博客
03-02 1464
写在前面 在前面几讲中，我们已经对IOC容器创建过程中的大部分方法进行过研究，其中比较核心的方法就是如下两个： invokeBeanFactoryPostProcessors方法：该方法在《Spring注解驱动开发第42讲——Spring容器创建源码解析(二)之执行BeanFactoryPostProcessor》这一讲中已经详细讲过了，要是还有不清楚的同学，可以查阅这篇文章哟！ registerBeanPostProcessors方法：该方法在《Spring注解驱动开发第43讲——Spring容器创建源
Spring注解驱动开发-扩展原理之011-Spring容器刷新第十一步-finishBeanFactoryInitialization(beanFactory)
Choco1ove的博客
05-19 167
11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean； /*************************AbstractApplicationContext***************************/ /** * Finish the initialization of this context's bean factory, * initializing all remaining singleton b
Spring refresh 方法之四 finishBeanFactoryInitialization分析
技术分享、唠嗑水文、如有不周、还望海涵
10-24 334
该文章的内容有视频讲解，地址👉：点我直达这个方法非常重要，执行流程也非常复杂。上面我们做了那么多详细的介绍，仅仅只是为这一步做铺垫，该方法就是将上面注册进BeanFactory中的所有单实例Bean定义进行实例化的功能。源码入口 进入org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization 这里没做啥事情，唯一需要注意的是就是向 beanFactory 中加了个类型转换器。那
SpringIOC初始化：refresh()方法深度解析
"本文将深入探讨Spring IOC容器的refresh()方法，通过实例代码解析其在初始化过程中的核心步骤，包括完成BeanFactory初始化、配置转换服务、处理嵌入式值解析器以及加载时间织入（LoadTimeWeaving）的处理。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值