Spring3.x源码分析(5)-bean加载2-创建bean实例

最新推荐文章于 2024-12-17 23:59:12 发布
最新推荐文章于 2024-12-17 23:59:12 发布
阅读量242 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： # spring 源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/it_freshman/article/details/85081336
本文深入剖析Spring3.x框架中Bean的加载机制，重点讲解singleton、prototype及其他scope类型的Bean实例创建过程。从源码层面解读Bean实例化、属性填充、初始化及销毁等关键环节，揭示Spring框架内部Bean管理的核心原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Spring3.x源码分析(5)-bean加载

《Spring源码深度解析》spring-framework-reference

bean的加载

接下来分析上一张跳过的内容创建bean实例,分别针对singleton,prototype,其他scope类型bean进行创建。

创建singleton实例

创建singleton的入口代码逻辑如下：

if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
        //重写接口方法
        public Object getObject() throws BeansException {
            try {
                return createBean(beanName, mbd, args);
            } catch (BeansException ex) {
                destroySingleton(beanName);
                throw ex;
            }
        }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

getSingleton(beanName ,objectFactory)

//org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	
	protected static final Object NULL_OBJECT = new Object();
	
	/** 被抑制的异常集合： 不抛出的异常Set*/
	private Set<Exception> suppressedExceptions;
	
	//标识当前容器是否正在销毁singletons
	private boolean singletonsCurrentlyInDestruction = false;
	
	/**缓存 singleton objects: bean name --> bean instance */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);

	/** 排除创建bean列表*/
	private final Map<String, Boolean> inCreationCheckExclusions = new ConcurrentHashMap<String, Boolean>(16);
	
	/** 当前正在创建bean列表 */
	private final Map<String, Boolean> singletonsCurrentlyInCreation = new ConcurrentHashMap<String, Boolean>(16);
	
	
	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "'beanName' must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				
				//1. 检测当前容器是否正处于销毁singletons装填
				if (this.singletonsCurrentlyInDestruction) {
					//如果当前正处于 销毁singletons 阶段，在此阶段创建singleton 会抛出异常.....
					throw new BeanCreationNotAllowedException(beanName,"xxx...");
				}
			
				//2.创建前检查，将beanName注册到当前创建bean集合中
				beforeSingletonCreation(beanName);

				//省略suppressedExceptions.....
				try {
					//3.最终是通过 singletonFactory.getObject();来进行对象创建
					singletonObject = singletonFactory.getObject();
				}  finally {
					//4.创建后检测,，将beanName从当前创建bean集合中移除
					afterSingletonCreation(beanName);
				}
				
				//5.创建singleton
				addSingleton(beanName, singletonObject);
			}
			
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}
	
	//2.Singleton创建前检测
	protected void beforeSingletonCreation(String beanName) {
		// 排除创建bean列表 不包含beanName
		// 将beanName设置为 当前正在创建缓存 != null 的含义：表示当前singletonsCurrentlyInCreation 不包含beanName
		if (!this.inCreationCheckExclusions.containsKey(beanName) &&
				this.singletonsCurrentlyInCreation.put(beanName, Boolean.TRUE) != null) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}
	
	//4.Singleton创建后检测
	protected void afterSingletonCreation(String beanName) {
		// 排除创建bean列表 不包含beanName
		// 将beanName从正在创建缓存中移除，
		// 如果singletonsCurrentlyInCreation.remove(beanName) == false,则会触发异常
		// 如果== true,则正常。 此时表示当前创建列表中存在 beanName -> true的记录。 即当前beanName正在创建中。
		if (!this.inCreationCheckExclusions.containsKey(beanName) &&
				!this.singletonsCurrentlyInCreation.remove(beanName)) {
			throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
		}
	}
	
	//5.创建singleton
	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// singletonObjects缓存添加  beanName
			this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
			
			//从singletonFactories ， earlySingletonObjects 缓存中移除。
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			
			// registeredSingletons缓存添加  beanName
			this.registeredSingletons.add(beanName);
		}
	}
}

分析上述代码，最终bean的创建的核心代码是调用了//3. singletonFactory.getObject();来完成的，

而这段代码的逻辑中的singletonFactory是有方法入参传入的，最终创建bean的逻辑，是交由createBean(beanName, mbd, args);完成的。

上述代码流程如下图：在这里插入图片描述

createBean(beanName, mbd, args);

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {

    // 确保bean class 在此处已经解析了。
    resolveBeanClass(mbd, beanName);
    
    //1. 设置MethodOverride的 重载标识。
    mbd.prepareMethodOverrides();

    //2.执行BeanPostProcessors，当执行结果返回bean != null时，则程序短路，不在进行后续的创建操作
    Object bean = resolveBeforeInstantiation(beanName, mbd);
    if (bean != null) {
        return bean;
    }
	
    //最终交由doCreateBean()，来创建bean....
    Object beanInstance = doCreateBean(beanName, mbd, args);
    return beanInstance;
}

1. mbd.prepareMethodOverrides()

//org.springframework.beans.factory.support.AbstractBeanDefinition

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
	//获取配置的 <lookup-method > ,<replaced-method > 方法清单
	MethodOverrides methodOverrides = getMethodOverrides();
	if (!methodOverrides.isEmpty()) {
        //for-each 遍历所有的 overrides 方法..
		for (MethodOverride mo : methodOverrides.getOverrides()) {
			prepareMethodOverride(mo);
		}
	}
}

protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
	//计算同名方法的个数(是否重载)
	int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
	if (count == 0) {
		//如果为0，则说明没有该名称的方法，与上面逻辑不符，抛出异常
		throw new BeanDefinitionValidationException(
				"Invalid method override: no method with name '" + mo.getMethodName() +
				"' on class [" + getBeanClassName() + "]");
	} else if (count == 1) {
		//如果只有1个同名方法， 说明该方法没有被重载
		mo.setOverloaded(false);
	}	
}

2. resolveBeforeInstantiation

//org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	//默认为null,第一次都能进入if{}语句块
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		
		//synthetic:合成的，用户定义的bean都为false,AOP自动创建的会为true
		//hasInstantiationAwareBeanPostProcessors()  --- 注
		if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			//1.
			bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
			if (bean != null) {
				//2.
				bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
			}
		}
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}

//1. 执行 InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		//遍历所有的BeanPostProcessor,寻找到InstantiationAwareBeanPostProcessor类型
		if (bp instanceof InstantiationAwareBeanPostProcessor) {
			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
			
			//执行postProcessBeforeInstantiation方法，并找到第一个执行结果不为空的结果，返回
			Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
			if (result != null) {
				return result;
			}
		}
	}
	return null;
}

//2. 执行所有BeanPostProcessor.postProcessAfterInitialization()
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) {
	Object result = existingBean;
	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
		//遍历所有的BeanPostProcessor,执行postProcessAfterInitialization方法，当执行结果为null时，不再往下执行.
		result = beanProcessor.postProcessAfterInitialization(result, beanName);
		if (result == null) {
			return result;
		}
	}
	return result;
}

注1

之前文章介绍了BeanPostProcessor相关知识，当使用factory.addBeanPostProcessor(processor)时，

如果存在processor是InstantiationAwareBeanPostProcessor类型的时候，则设置hasInstantiationAwareBeanPostProcessors为true;

在这里插入图片描述

doCreateBean

最终bean的创建委托给doCreateBean()来完成.

//org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

/** 未完成FactoryBean实例缓存: FactoryBean name --> BeanWrapper */
private final Map<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<String, BeanWrapper>(16);

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {

		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			//从获取缓存中 未完成FactoryBean
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			//1. 如果instanceWrapper为空，则通过createBeanInstance创建BeanWrapper，并返回
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		
		//获取bean, beanType
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				//2. 执行 MergedBeanDefinitionPostProcessors ， 执行完成之后将标识置为true
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				mbd.postProcessed = true;
			}
		}

		// 此时bean刚刚创建完成，还没有完成初始化以及属性的注入等。
		//判断是否需要 提前曝光此bean，用来解决在singleton循环依赖的问题
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));	
		if (earlySingletonExposure) {
             //3.
			//3.1 避免后期循环依赖，可以在bean初始化完成前将创建示例的ObjectFactory假如缓存
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				public Object getObject() throws BeansException {
                     //3.2 
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		Object exposedObject = bean;
		
		//4.从mbd获取属性信息，填充到instanceWrapper中的 bean实例。
		populateBean(beanName, mbd, instanceWrapper);
		if (exposedObject != null) {
			//5.执行初始化方法
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		
    	//6.
		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
            //earlySingletonReference只有在检测到有循环依赖的情况下才不为空
			if (earlySingletonReference != null) {
                 //if true,表明exposedObject没有在初始化方法中被改变，即没有被增强
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                     //所有依赖该bean的集合
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
                     //检测依赖
					for (String dependentBean : dependentBeans) {
                         //如果依赖beanName 的 bean先一步创建完成，即alreadyCreated.contains(dependentBean),则返回false,取 "非"后 为true
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                              //添加 出现错误依赖的dependentBean
							actualDependentBeans.add(dependentBean);
						}
					}
                    	
                     //因为bean创建后，它所依赖的bean也一定已经创建了
                     //但是如果actualDependentBeans不为空，则说明bean所依赖的bean并没有创建完，则说明存在循环依赖
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,"xxxxxx....");
					}
				}
			}	
		}

		//7. 注册销毁方法...
		registerDisposableBeanIfNecessary(beanName, bean, mbd);

		return exposedObject;
	}

1.createBeanInstance

分三种方式创建bean实例

1.1 instantiateUsingFactoryMethod 工厂类创建

最终调用ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);来完成创建.

创建的大致步骤如下，后续会专门针对此类来进行详细分析

  • 创建bw = new BeanWrapperImpl();
  • 初始化beanFactory.initBeanWrapper(bw);
  • 判断是否为静态工厂方法:isStatic
  • 构造函数参数的确定argsToUse
  • 根据isStatic和方法名称获取候选方法清单
  • 确定构造函数
  • 根据实例化策略实例化bean.(如果有动态覆盖则需要使用cglib动态代理，如果没有，则直接使用反射即可)

1.2 autowireConstructor-带参数的实例化

最终调用ConstructorResolver(this).autowireConstructor(beanName, mbd, explicitArgs);来完成创建.

步骤参上上述instantiateUsingFactoryMethod

1.3 instantiateBean-不带参数的实例化

没有上述两种方法来确定构造函数和参数的复杂逻辑，直接调用最后一步：

  • 根据实例化策略实例化bean.

2.applyMergedBeanDefinitionPostProcessors

//2.执行MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(),执行bean定义的合并
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);
		}
	}
}

3.addSingletonFactory

//3.1 addSingletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
	synchronized (this.singletonObjects) {
		//必须满足 singletonObjects不包含beanName, 即beanName没有创建完成
		if (!this.singletonObjects.containsKey(beanName)) {
			//singletonFactories添加缓存
			this.singletonFactories.put(beanName, singletonFactory);
			
			//earlySingletonObjects移除缓存
			this.earlySingletonObjects.remove(beanName);
			
			//registeredSingletons添加缓存
			this.registeredSingletons.add(beanName);
		}
	}
}

//3.2
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                     //AOP通过此方法将advice织入bean中
					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
					if (exposedObject == null) {
						return exposedObject;
					}
				}
			}
		}
		return exposedObject;
	}

4.populateBean – 属性填充

//4. 填充属性
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
	PropertyValues pvs = mbd.getPropertyValues();

	//判断条件省略.....

	//是否继续属性填充标识
	boolean continueWithPropertyPopulation = true;
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				
				//通过构造函数或工厂方法实例化bean之后执行操作，但是在Spring属性入口（来自显式属性或自动装配）之前发生。
				//如果返回false,随后的InstantiationAwareBeanPostProcessor以及Spring属性注入都会被skipped
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}

	if (!continueWithPropertyPopulation) {
		return;
	}

	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			//4.1 按照名称填充属性 -- 提取依赖的bean,并统一装入newPvs
			autowireByName(beanName, mbd, bw, newPvs);
		}

		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			//4.2 按照类型填充属性 -- 提取依赖的bean,并统一装入newPvs
			autowireByType(beanName, mbd, bw, newPvs);
		}

		pvs = newPvs;
	}

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

	if (hasInstAwareBpps || needsDepCheck) {
		//剔除 bw属性中 且在 ignoredDependencyTypes 类型的参数;
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		if (hasInstAwareBpps) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					//InstantiationAwareBeanPostProcessor.postProcessPropertyValues(), 典型的应用如 @Required 注解属性进行验证
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); 
					if (pvs == null) {
						return;
					}
				}
			}
		}
		if (needsDepCheck) {
			//再次验证
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}
	
	//将MutablePropertyValues 应用到BeanWraper中
	applyPropertyValues(beanName, mbd, bw, pvs);
}

5.5. 执行初始化方法

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
	//5.1.执行Aware接口方法
	invokeAwareMethods(beanName, bean);

	Object wrappedBean = bean;	
	if (mbd == null || !mbd.isSynthetic()) {
		//5.2. BeanPostProcessor.postProcessBeforeInitialization()
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}
	
	//5.3 执行init方法
	invokeInitMethods(beanName, wrappedBean, mbd);
	
	if (mbd == null || !mbd.isSynthetic()) {
		//5.4. BeanPostProcessor.postProcessAfterInitialization
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;
}
	
//5.1 执行aware接口方法
private void invokeAwareMethods(final String beanName, final Object bean) {
	if (bean instanceof Aware) {
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		if (bean instanceof BeanClassLoaderAware) {
			((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
		}
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

//5.3. 执行各渠道定义的init-method
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
			 {
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        //如果实现了InitializingBean接口， 则执行  afterPropertiesSet();
        ((InitializingBean) bean).afterPropertiesSet();
    }

    if (mbd != null) {
        String initMethodName = mbd.getInitMethodName();
        if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
            //执行bean定义的 init-method 属性定义的方法
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

5.6. 注册销毁方法

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
	AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
	// requiresDestruction(bean, mbd)最终调用逻辑
	//(bean != null && (bean instanceof DisposableBean || mbd.getDestroyMethodName() != null || hasDestructionAwareBeanPostProcessors()));
	if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
		if (mbd.isSingleton()) {
			//单例模式下注册：会处理实现DisposableBean接口 || 配置destroy-method || 声明有DestructionAwareBeanPostProcessors 的bean.
			registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
		}
		else {
			// A bean with a custom scope...
			Scope scope = this.scopes.get(mbd.getScope());

			//SimpleThreadScope此方法是空实现， 需要手动设置，执行callback
			scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));				
		}
	}
}

在这里插入图片描述

创建prototype实例

与创建singleton实例的总体流程大致相同，不在赘述。

创建其他scope实例

//org.springframework.beans.factory.support.AbstractBeanFactory
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
						public Object getObject() throws BeansException {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						}
					});


//org.springframework.context.support.SimpleThreadScope
public Object get(String name, ObjectFactory objectFactory) {
    Map<String, Object> scope = threadScope.get();
    Object object = scope.get(name);
    if (object == null) {
        object = objectFactory.getObject();
        scope.put(name, object);
    }
    return object;
}
Spring5 源码阅读笔记（1.4.3）getObjectForBeanInstance(sharedInstance, name, beanName, mbd) 获取Bean实例的对象
日有寸进
02-24 408
回顾 if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance fr...
Spring源码——bean的加载
等一杯咖啡的博客
09-26 4634
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第五章的部分，依照书中内容以及个人理解对Spring进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 在前几篇文章中，我们已经完成了将XML配置文件的信息转换为 B...
Spring源码解析二十四
qq_35873436的博客
03-17 661
前面我们通过getBean的方法，分析了Spring是如何创建一个单例bean的，我们到现在为止只是看到了一些准备工作。比如检查是否存在prototype类型的bean正在创建，标记下当前的bean开始创建了，获取bean对应的BeanDefinition依赖提前初始化bean依赖的那些bean等。今天我们来分析下Spring的单例bean是如何创建的。 我们找到bean的实例化入口： 通过方法getSinleton获取单例bean的实例sharedInstance，然后进一步通过方法getObjectF
Spring源码解析：Bean实例的创建与初始化
weixin_34082177的博客
06-09 1610
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring 源码解析：（五）IOC-Spring bean 的初始化过程（四）
03-17 307
解析单例中获取bean以及解决循环依赖前言正文后话 前言 前文中解析Spring的preInstantiateSingletons 大体流程，接下来详细展开从单例池中获取bean 正文 直接追getSingleton /** * Return the (raw) singleton object registered under the given name. * <p>Ch...
spring 5.2.9 07 源码分析-spring的bean工厂准备工作 测试用例
06-23
在Spring框架中，Bean工厂是核心组件之一，它负责管理所有Bean的生命周期，包括实例化、配置、装配以及销毁。本章将详细分析Spring 5.2.9版本中Bean工厂的准备工作，特别是通过测试用例来理解其实现细节。 在Spring...
5.Springboot2启动过程源码分析-Bean的实例化
万般皆苦，唯有自渡
09-16 5607
系列文章目录 1.Springboot2启动过程源码分析-SpringApplication初始化 2.Springboot2启动过程源码分析-SpringApplication#run 3.Springboot2启动过程源码分析-prepareContext方法 4.Springboot2启动过程源码分析-refresh方法 5.Springboot2启动过程源码分析-Bean的实例化 6.Springboot2启动过程源码分析-总结 文章目录 系列文章目录 前言 一、Bean的生命
spring学习(spring-bean实例化(实例工厂))
岁岁岁平安的博客
12-17 954
本篇博客的内容：spring容器实例化bean的几种方式。spring容器使用实例工厂方式实例化bean的基本概念与具体操作(属性：factory_method与factory_bean)。最后总结了spring容器的静态工厂实例化bean与实例工厂实例化bean的联系与区别......
Spring工厂方法创建（实例化）bean实例代码
08-28
Spring工厂方法创建（实例化）bean实例代码 Spring框架中提供了多种方式来创建bean实例，包括通过构造器、静态工厂方法和实例工厂方法等。这种方式可以让开发者更好地控制bean的创建过程，实现更多的自定义需求。 ...
【框架源码篇 04】Spring源码手写篇-Bean定义配置化
10-21
Bean的类名则指定了Bean的实现类，Spring将根据这个类名创建Bean实例。 其次，Bean的初始化方法和销毁方法允许我们自定义Bean的生命周期。初始化方法在Bean创建后且所有依赖注入完成之前调用，而销毁方法在Bean被...
spring源码深度解析---bean的加载（下）
渔潭的博客
04-17 1700
spring源码深度解析—bean的加载（下） 我们继续接着之前的两篇bean的加载继续分析bean的实例创建 1. 创建bean实例 上面介绍了循环依赖还后置处理器处理的操作后接下来就到了创建bean的操作了，创建bean是在方法doCreateBean(beanName, mbdToUse, args)完成的，我们看下方法体： protected Object doCreateBe...
十、Spring 源码解析之 bean 的加载流程五： 准备创建bean
panchang199266的博客
09-23 247
我们不可能
《Spring源码深度解析 郝佳 第2版》bean的加载、循环依赖的解决
xiaosi的博客
03-01 784
目录 往期博客： 《Spring源码深度解析 郝佳 第2版》容器的基本实现与XML文件的加载 《Spring源码深度解析 郝佳 第2版》XML标签的解析 往期博客完成了xml文件加载和内容解析，将BeanDefinition相关信息保存在容器中，接着就是bean的加载 BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("beanFactory.xml")); // 就是对下面语句的分析，手动getBean流程 //注意
Spring IOC加载全过程（转）
weixin_39713838的博客
03-04 826
本文章以ClassPathXmlApplicationContext为切入口，常用的还有ContextLoaderListener类 首先 **一般开始都是这样一句代码： ApplicationContext context = new ClassPathXmlApplicationContext(“classpath:application.xml”); 1 意思是加载xml文件创建一个A...
Spring bean的生命周期，对比源码详解
Jeff的专栏
02-28 5414
为了更加熟悉spring的总体流程，看了spring的源码。 看了很多网上的资料写的spring的bean的生命周期，但是感觉和看到的源码有部分出入，这里再总结下。 正文： spring获取bean的时候有两种方式： BeanFactory bf = new XmlBeanFactory(new ClassPathResource("appli...
Spring 初探（四）（Spring autowire 相关）
斯温的博客
12-20 572
autowire相关 spring bean配置的一致性表现在get set 方法与bean当中的值的一致性上。 在使用byName标签进行属性配置时是可以看出的，使用byName后属性bean的相应 id与get set方法中的名称是相匹配的（小驼峰） 使用byType进行配置标注时可以看做是寻找唯一符合属性配置type的类作为 对应属性。 使用constructor
Spring源码解析-bean加载
Bingo!
05-06 410
本文介绍bean的加载，对应着代码： Cat cat = (Cat) bf.getBean(&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;testCat&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;a
Spring实战之Cache
yaasshole
08-31 128
这里假定我们已经有了一些现成的类和接口，比如说 1&gt; 一个现成的User POJO对象 2&gt; 一个UserDao接口和UserDaoHibernateImpl实现类 3&gt; 一个UserService接口和UserServiceImpl实现类 1. 这是使用的是Maven做的项目管理工具，在使用cache（这里使用的是ehcache）之前，需要引入以下依赖 ...
spring IOC和DI源码分析
wyl6019的博客
04-27 6439
引言先看下最基本的启动 Spring 容器的例子：public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationfile.xml"); }以上代码就可以利用配置文件来启动一个 Spring 容器了，请...
spring.main.allow-bean-definition-overriding+顺序
最新发布
03-18
### Spring Boot 中 `spring.main.allow-bean-definition-overriding` 属性的作用 在 Spring Boot 应用程序中，`spring.main.allow-bean-definition-overriding=true` 是一个用于控制 Bean 定义覆盖行为的关键属性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值