Spring之bean的创建过程

已于 2024-06-21 21:44:33 修改
阅读量68 收藏
点赞数
文章标签： spring java 后端
于 2023-04-24 14:32:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43653230/article/details/130327917
版权

1.spring的bean实例化的入口方法为getBean. 这个方法在AbstractBeanFactory类中，这个方法进一步调用doGetBean方法来获取实例。
在这里插入图片描述

@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}
 
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException      {
	return doGetBean(name, requiredType, null, false);
}
 
@Override
public Object getBean(String name, Object... args) throws BeansException {
	return doGetBean(name, null, args, false);
}

2.AbstractBeanFactory.doGetBean

@SuppressWarnings("unchecked")
	protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
           //解析beanName 这个方法的作用主要是将别名转化成真的beanName和将factoryBeanName(&beanName)转化成真的beanName
		final String beanName = transformedBeanName(name);
		Object bean;
		   //检查singleton cache 这一步有很关键的意义：
           //1.可以检测到手工注入的singleton
           //2.可以检测到还没有完成populte的singleton(这个作用是用来协助依赖注入的)
           //3.可以预先检测当前beanName的singleton是否已经完成new操作 防止重复创建
           //4.prototype bean在这里会返回null
		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 + "'");
				}
			}
            //这一步主要是为factoryBean做的 
            //1.如果sharedInstance不是一个factoryBean return sharedInstance
            //2.如果sharedInstance是一个factoryBean且name为&beanName的形式 return sharedInstance
            //3.return ((FactoryBean<?>)sharedInstance).getObject(); 并且将返回结果缓存在了FactoryBeanRegistrySupport类的factoryBeanObjectCache实例域上
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
 
		else {
			//这里用了prototype bean的创建池 防止多件bean重复创建
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
 
			//如果bean definition在双亲容器中， 则将创建bean的任务委托给双亲容器
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
 
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}
 
			try {
                //这里是一个MergedBeanDefinition的过程 主要是将BeanDefinition都包装成RootBeanDefinition并放到mergedBeanDefinitions里 
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);
 
				//保证当前bean dependsOn的bean都在当前bean创建之前完成初始化
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dependsOnBean : dependsOn) {
                         //这里检测dependsOnBean是否depends-on beanName
						if (isDependent(beanName, dependsOnBean)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
						}
						registerDependentBean(dependsOnBean, beanName);
						getBean(dependsOnBean);
					}
				}
                //有以下代码可见不管是singlton,prototype还是scope都使用createBean来创建对象
                //不同的是singlton有缓存 不用重复创建 而正因为singlton有缓存和提前暴露机制 singlton才得以解决循环依赖问题
                //创建singleton 
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							try {
                                //好 在这里完成了bean实例的真正的创建
								return createBean(beanName, mbd, args);
							}
							catch (BeansException ex) {
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
 
                //创建prototype
				else if (mbd.isPrototype()) {
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
                 //创建指定scope
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
							@Override
							public Object getObject() throws BeansException {
								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;
			}
		}
 
		//检测requiredType和beanInstance的实际类型是否匹配
		if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
			try {
				return getTypeConverter().convertIfNecessary(bean, requiredType);
			}
			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;
	}

3.AbstractAutowireCapableBeanFactory.createBean

@Override
	protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {
 
		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		//这一步确保BeanDefinition上已经可以获取的到beanClass
		resolveBeanClass(mbd, beanName);
 
		//这一步是准备方法重写
		try {
			mbd.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}
 
		try {
			//**代理切入的位置（Step1.让 实现了InstantiationAwareBeanPostProcessor 有机会返回一个代理而不是目标 bean 实例。）**
			Object bean = resolveBeforeInstantiation(beanName, mbd);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}
        //创建bean的任务又委托给了doCreateBean
		Object beanInstance = doCreateBean(beanName, mbd, args);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}

4.AbstractAutowireCapableBeanFactory.doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
            //继续创建实例// step2.创建bean通过反射构造器创建
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
 
		//允许post-processors修改merged过的beanDefinition 也即是RootBeanDefinition
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
			//Step3.让实现了MergedBeanDefinitionPostProcessor接口的类执行postProcessMergedBeanDefinition方法，允许修改合并的 bean 定义。
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				mbd.postProcessed = true;
			}
		}
        //这里暴露还没有populate的singleton 暴露到三级缓存里 协助循环引用
		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, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}
 
		
		Object exposedObject = bean;
		try {
		//step4.populateBean （自定义属性赋值，通过set方法）依赖注入发生的地方
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
			//step4.初始化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<String>(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.");
					}
				}
			}
		}
 
		try {
		step7.初始化bean的地方将给定的 bean 添加到该工厂中的一次性 bean 列表中，注册其 DisposableBean 接口和/或给定的 destroy 方法，以便在工厂关闭时调用（如果适用）。仅适用于单例。
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}
 
		return exposedObject;
	}

5.AbstractAutowireCapableBeanFactory.createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		//进一步确认beanClass
		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());
		}
        //如果有instanceSupplier则从instanceSupplier上直接获取实例
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}
        //如果有工厂方法 则走这一分支
		if (mbd.getFactoryMethodName() != null)  {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}
 
		//1.这一步方法会访问beanDefinition上的构造器,工厂方法,构造器参数 的缓存 如果有 则直接根据缓存创建实例 构造器的依赖注入发生在这
        //2.否则调用无参构造 如果存在方法重写 将会返回cglib生成的代理bean 这一步会构建构造器,工厂方法,构造器参数 的缓存 之所以构建缓存 是为了下次创建prototype可以直接利用缓存
		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);
			}
		}
 
		//step2.1如果存在SmartInstantiationAwareBeanPostProcessor，则使用determineCandidateConstructors方法返回的构造器创建Bean
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
		}
 
		//使用无参构造方法 创建bean 如果存在方法重写 将会返回cglib生成的代理bean
		return instantiateBean(beanName, mbd);
	}

6.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean

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 {
		step5.1 如果bean实现了Aware-通过Aware为bean注入属性（容器属性赋值）
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		step5.2 如果bean实现了BeanPostProcessors-执行BeanPostProcessors前置方法
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
		step5.3 如何bean实现了isInitializingBean,执行操作，如果@Bean注解定义了init方法,执行初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		step5.4 如果bean实现了BeanPostProcessors-执行BeanPostProcessors后置方法
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		boolean continueWithPropertyPopulation = true;
      //step4.1 实现了InstantiationAwareBeanPostProcessor 执行postProcessAfterInstantiation
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		if (!continueWithPropertyPopulation) {
			return;
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

bean的生命周期总结：

Step1 让实现了InstantiationAwareBeanPostProcessor接口的类,执行postProcessBeforeInstantiation直接返回一个bean，而不是经过doCreateBean流水创建bean
Step2 通过反射构造器创建bean
step2.1如果存在SmartInstantiationAwareBeanPostProcessor，则使用determineCandidateConstructors方法返回的构造器创建Bean
Step3.让实现了MergedBeanDefinitionPostProcessor接口的类执行postProcessMergedBeanDefinition方法，允许修改合并的 BeanDefinition(1.调用属性合并后置处理器, 进行属性合并(如果xml中也定义了依赖，@注解也定义了依赖，会进行合并) 2.这里会进行 一些注解 的扫描)。

Step4 populateBean （自定义属性赋值，通过set方法）依赖注入发生的地方
Step4.1 实现了InstantiationAwareBeanPostProcessor接口的类-执行postProcessAfterInstantiation方法（可以用于判断控制是否对Bean属性赋值进行跳过）
Step5 初始化bean的地方
Step5.1 如果bean实现了Aware-通过Aware为bean注入属性（容器属性赋值）
Step5.2 如果bean实现了BeanPostProcessors-执行postProcessBeforeInitialization前置方法
Step5.3 如何bean实现了isInitializingBean,执行初始化操作,如果@Bean注解定义了init方法,执行初始化方法
Step5.4 如果bean实现了BeanPostProcessors-执行postProcessAfterInitialization后置方法
Step6 使用bean
Step7 销毁bean

spring官方指定了三种初始化回调方法
　　1.1、@PostConstruct、@PreDestory
　　1.2、实现 InitializingBean DisposableBean 接口
　　1.3、设置init-method和destory-method（ @Bean（initMethod=“init” ， destroyMethod=“destroy”））
三种方式的优先级从高到低
1.1@PostConstruc 的调用
要将对象B注入到对象A，那么首先就必须得生成对象A和对象B，才能执行注入。

如果一个类A中有个成员变量b被@Autowried注解，那么@Autowired注入是发生在A的构造方法执行完之后的。
如果想在生成对象时完成某些初始化操作，而偏偏这些初始化操作又依赖于依赖注入，
那么就无法在构造函数中实现。
为此，可以使用@PostConstruct注解一个方法来完成初始化，
@PostConstruct注解的方法将会在依赖注入完成后被自动调用。


Component
public class A {

    @Autowired
    private B b;

    public A(){
        System.out.println("执行A的构造函数，此时b还未被注入，b=" + b);
    }

    @PostConstruct
    public void init(){
        System.out.println("@PostConstruct注解此方法，会在对象b注入完成之后自动调用此方法，b=" + b);
    }
}

在上述Step3中调用CommonAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法，调用了buildLifecycleMetadata()方法
方法添加了@PostConstruct注解，就添加到currInitMethods，
方法添加了@PreDestory注解，就添加到currDestroyMethod中，
在上述Step5.2中在spring生命周期的第七个后置处理器方法中，org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization
会尝试先从lifecycleMetadataCache中根据class，获取到元对象，然后调用元对象的 invokeInitMethods()方法
1.2 InitializingBean 的调用在上述Step5.3中
1.3、设置init-method和destory-method（ @Bean（initMethod=“init” ， destroyMethod=“destroy”））的调用也在上述Step5.3中

在这里插入图片描述

在这里插入图片描述

weixin_43653230
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
spring bean的创建过程
qq_40866844的博客
01-25 462
spring 中bean的生命周期<简单版本，后续待更新>
Spring Bean的创建过程
hyp1987的专栏
08-22 564
本文带着如下问题，分析下spring bean的创建过程，spring是怎么创建bean？ioc又体现在哪里，创建bean的过程中做了些什么，aop的代理对象是什么时候生成的？ 1、应用程序的启动 现在的工程大部分都是springboot工程，SpringBoot可以轻松创建独立的、生产级的、基于Spring的应用程序，SpringBoot应用程序可以通过main方法轻松启动，如下： public static void main(Strin...
揭秘Spring生命周期：Bean的创建过程超详细解析
最新发布
学而时习之，不亦说乎？温故而知新，可以为师矣！
05-12 817
Spring框架作为一个轻量级的容器，能够管理和创建大量的Java对象，其背后的Bean创建过程十分复杂而又神秘。本文将深入探讨Spring Bean的创建过程，从配置文件到实例化的全流程进行解析。我们将详细介绍BeanFactory的工作原理、BeanDefinition的加载和解析过程，以及对象的实例化、初始化和依赖注入等关键环节。
spring中Bean的创建的过程
qq_40132981的博客
08-07 225
1、从applicationContext的refresh入手 2、实例化所有不是懒加载的bean 3、 4、getbean() 5、调用dogetBean()方法 6、调用getSingleton()中的createBean()方法 7、调用doCreateBean() 8、创建bean源码如下 protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nu...
Spring Bean 创建过程
我想跟代码谈谈
03-31 5860
0. 通常，无论是DispatcherServlet、ContextLoaderListener还是ClassPathXmlApplicationContext，首次实例化bean的入口并不是在每次调用getBean的时候，而是在DefaultListableBeanFactory类的preInstantiateSingletons方法中：当配置文件加载完毕后，会预先将 非abstract、非延迟
Spring中Bean的创建流程
weixin_34452850的博客
03-14 4387
Spring中Bean的创建流程 一. 核心代码 BeanDefinition的解析在AbstractAutowireCapableBeanFactory的resolveBeforeInstantiation()中： @Nullable protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition m...
Spring Bean创建初始化流程.docx
03-04
以下是对Spring Bean创建初始化流程的详细解释： 1. **初始化ApplicationContext**： 开始时，通过`AnnotationConfigApplicationContext`类创建一个上下文实例，通常传入一个或多个配置类（`annotatedClasses`），...
Spring创建Bean的过程
08-10
Spring 框架中，Bean 的创建过程是通过 ApplicationContext 实现的，ApplicationContext 是 BeanFactory 的扩展，提供了更多的功能。下面将详细介绍 Spring 创建 Bean 的过程。 Bean 的创建过程 在 Spring 中，...
Spring-Bean创建对象的步骤方式详解
08-25
Spring-Bean 创建对象的步骤方式详解 Spring-Bean 创建对象是 Spring 框架中一个核心概念，它允许开发者通过配置文件或注解的方式来创建对象。下面我们将详细介绍 Spring-Bean 创建对象的步骤方式。 通过无参构造...
Spring如何使用注解的方式创建bean
08-25
在 Spring 框架中，Bean 的生命周期是指从 Bean 的创建到销毁的整个过程。 Bean 的生命周期可以分为以下几个阶段： 1. 实例化：创建 Bean 实例 2. setter 方法注入：对 Bean 的 setter 方法进行注入 3. 初始化：对 ...
Spring创建Bean的6种方式详解
08-25
在Spring框架中，创建Bean是实现依赖注入的关键步骤。以下是Spring创建Bean的6种主要方式的详细解释： 1. **XML配置**： XML配置是最传统的Spring创建Bean的方式。通过在XML配置文件中使用`<bean>`标签，指定Bean...
Spring 中 Bean 的创建流程
qq_53195681的博客
12-24 556
Spring 中 Bean 的创建流程
spring bean的创建过程二
蓝天的博客
05-20 229
我们知道bean的创建过程主要是getBean->doGetBean->createBean->doCreateBean 开始进入源码，断点查看 先从缓存中获取单例对象getSingleton 并没有，直接返回 为指定的Bean标记为已经创建（或将要创建） 下面将进入创建bean 此处需要注意：ObjectFactory接口 先来看下ObjectFactory源码 这个接口的定义非常简单，就是一个对象工厂，定义了一个返回.
Spring源码解析6-spring的bean创建流程实例化
weixin_43582204的博客
04-05 414
spring的bean创建流程实例化，通过获取构造器，反射创建bean，分配空间 refresh()中的finishBeanFactoryInitialization()， 完成此上下文bean工厂的初始化，初始化所有剩余的单例bean（非懒加载的） finishBeanFactoryInitialization() 1、为上下文初始化类型转换器，ConversionService有3种转换器实现类，1对1转换，1对N转换，N对N转换 2、beanFactory之前没有...
Spring的Bean创建过程
Yuan_Su_的博客
04-25 1640
spring将内部管理的诸多对象称为一个个bean，而这些bean的创建流程大致分为两个大阶段： 下面本人将从上述两个阶段来阐述bean的完整创建过程。 在对象进行创建之前，spring容器需要了解所创建的对象的信息，才能在后续阶段根据了解的信息创建bean对象。这些信息即是实际工作中我们为对象所写的配置信息，它们一般以xml文件、properties文件和注解的形式存在于我们的项目之中。 一个以xml文件为存储形式的bean配置文件如下： 因此，
spring 深入了解bean的创建过程
qq_36869100的博客
10-30 3582
一、创建bean之初 spring调用 beanFactory.preInstantiateSingletons()此方法完成整个bean生产以及依赖注入，那么在生成bean之前，spring做了哪些事呢？ 1.盘点bean定义是否是bean工厂 遍历所有beandefinition 非懒加载以及非抽象bean，单例，去执行AbstractBeanFactory.isFactoryBean(beanName) 方法判断是否是重写 SmartFactoryBean接口的isEagerI...
Spring之Bean创建过程
程序员小潘
12-30 3176
Spring提供了xml、注解、JavaConfig多种方式来配置bean，不论何种方式，Spring最终都会将bean封装成BeanDefinition对象，Spring创建bean的依据也是通过BeanDefinition来完成的。当我们调用getBean()方法获取bean实例时，不管是单例bean还是原型bean，首次调用时容器内都不存在可用的bean实例，这时就不得不去创建bean了，我们分析下Spring创建bean的过程。
一文搞定 Spring Bean 的创建全过程！
Java技术栈，分享最主流的Java技术
02-22 2276
点击关注公众号，Java干货及时送达作者：x1aoda1来源：www.cnblogs.com/darope/p/13917264.html1.1 Spring测试环境搭建Spring模块概...
Spring中bean创建的过程
04-03
Spring中bean创建的过程如下： 1. 加载Bean配置文件：Spring容器从Bean配置文件中读取Bean的定义信息，包括Bean的类名、属性、依赖关系等。 2. 解析Bean配置文件：Spring容器解析Bean配置文件，生成BeanDefinition对象，其中包括Bean的类名、属性、依赖关系等信息。 3. 创建Bean实例：根据BeanDefinition对象信息，Spring容器使用Java反射机制创建Bean的实例。 4. 设置Bean属性：Spring容器将Bean的属性值注入到Bean实例中，包括基本类型、引用类型、集合类型等。 5. 调用Bean的初始化方法：如果Bean定义了初始化方法，Spring容器会在Bean实例化之后调用该方法。 6. 将Bean实例化放入Bean容器中：Spring容器将Bean实例化放入Bean容器中，以供其他Bean依赖注入或调用。 7. 当容器关闭时，调用Bean的销毁方法：如果Bean定义了销毁方法，Spring容器在关闭时会调用该方法。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值