IOC 单例Bean初始化

最新推荐文章于 2023-03-05 23:13:28 发布
最新推荐文章于 2023-03-05 23:13:28 发布
阅读量190 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wq5350/article/details/107541733
版权
本文深入解析Spring框架中Bean的生命周期，从实例化单例对象开始，详细讲解了doGetBean方法如何初始化单例bean，包括从缓存获取单例对象、处理别名和循环依赖，以及createBean方法创建bean实例的过程。探讨了属性装配、初始化回调和销毁方法注册等关键步骤。
摘要由CSDN通过智能技术生成

文章目录

组件

SimpleAliasRegistry

提供别名注册

public class SimpleAliasRegistry implements AliasRegistry {
	// 存放bean的别名  格式：(别名:Bean的ID名)
	// 未定义id，定义了多个Name，以第一个name为value
	// 未定义id和name，以类全限制名称+#0为value，全限制名称为key
	private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
}

Converter

转换器，将传入的source转换为对应target

public interface Converter<S, T> {
	T convert(S source);
}

TypeConverter

定义类型转换方法的接口

public interface TypeConverter {
	// 将值转换为所需的类型
	<T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType) throws TypeMismatchException;
}

PropertyAccessor

属性访问器，用来存取Bean对象的属性

public interface PropertyAccessor {
	// 获得对应属性类型
	Class<?> getPropertyType(String propertyName) throws BeansException;
	// 获得对应属性值
	Object getPropertyValue(String propertyName) throws BeansException;
	// 设置对应属性值
	void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException;
}

PropertyEditorSupport

属性编辑器，使用户可以通过给定类型来编辑属性

public interface PropertyEditorSupport {
	private Object value;
	private Object source;
	// 属性变动的监听器
	private java.util.Vector<PropertyChangeListener> listeners;

	void setValue(Object value);
	// 通过给定string值设置属性值
	void setAsText(String text) throws java.lang.IllegalArgumentException;
	
	Object getValue();
	// 获得属性值的string表示
	String getAsText();
}

PropertyEditorRegistrySupport

提供对默认编辑器和自定义编辑器的管理

public class PropertyEditorRegistrySupport implements PropertyEditorRegistry {
	// 持有的属性编辑器
	@Nullable
	private Map<Class<?>, PropertyEditor> defaultEditors;
	@Nullable
	private Map<Class<?>, PropertyEditor> overriddenDefaultEditors;
	@Nullable
	private Map<Class<?>, PropertyEditor> customEditors;
	@Nullable
	private Map<String, CustomEditorHolder> customEditorsForPath;
	@Nullable
	private Map<Class<?>, PropertyEditor> customEditorCache;
	
	// 注册属性编辑器
	void registerCustomEditor(Class<?> requiredType, PropertyEditor propertyEditor);
	// 获得属性编辑器
	PropertyEditor findCustomEditor(@Nullable Class<?> requiredType, @Nullable String propertyPath);
}

BeanWrapper

Spring底层JavaBeans基础设施的中央接口

public interface BeanWrapper extends ConfigurablePropertyAccessor {
	// 返回这个对象包装的bean实例
	Object getWrappedInstance();
	// 指定数组和集合自动增长的限制
	void setAutoGrowCollectionLimit(int autoGrowCollectionLimit);
}

源码解析

1. 实例化单例对象(DefaultListableBeanFactory)

  • 遍历所有xml中定义的bean，bean为单例、非抽象、非懒加载
  • 对于普通bean直接调用getBean(name),对于工厂bean调用getBean(&+name)
  • 完成初始化后，如果bean实现了SmartInitializingSingleton则执行其afterSingletonsInstantiated方法
public void preInstantiateSingletons() throws BeansException {
	···日志

	// 获得IOC容器中beanNames(也就是xml中<bean id="XX">的id)
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// 触发所有非延迟单例bean的初始化
	for (String beanName : beanNames) {
		// 获得合并后的bd
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 单例、非抽象、非懒加载
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 如果是工厂bean实例则添加&前缀,调用getBean实例化
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				// 判断是否为SmartFactoryBean
				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 {
				// 普通bean初始化
				getBean(beanName);
			}
		}
	}

	// 遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
	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();
			}
		}
	}
}

2. doGetBean初始单例bean(AbstractBeanFactory)

  • beanName转换,首先如果为工厂名先从transformedBeanNameCache中获取真实beanName,然后从AliasMap中取真实beanId
  • 从缓存中获得单例bean的引用，如果引用不为空且参数传入为空，直接使用缓存中的实例作为返回值
  • 存在父工厂且当前工厂不包含改beanName则调用父工厂的doGetBean来获得实例
  • 判断typeCheckOnly将当前beanName放入alreadyCreated集合中(用来判断bean是否正在创建中)
  • 检查是否存在depends-on，优先加载
  • 判断是否为singleton和prototype，分别执行createBean方法创建bean实例
  • 如果requiredType存在，则检查返回实例是否满足requiredType
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
	// 对传递进来的beanName转换(处理别名和带&的工厂bean名)
	final String beanName = transformedBeanName(name);
	Object bean;

	// 检查单例缓存中注册的单例
	Object sharedInstance = getSingleton(beanName);
	// 如果缓存不存在引用且传递参数为空(为空表示获取，不为空表示希望创建bean)
	if (sharedInstance != null && args == null) {
		···日志打印
		// 普通bean直接返回，工厂bean返回工厂创建的实例对象
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}
	// 进入bean创建逻辑
	else {
		// 如果当前线程创建的prototype类型的bean已在创建中，抛出异常
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		
		BeanFactory parentBeanFactory = getParentBeanFactory();
		// 检查bd是否在父工厂中存在且当前工厂不包含beanName
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// 获得原始的bean名称
			String nameToLookup = originalBeanName(name);
			// 父工厂调用doGetBean获得实例
			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 if (requiredType != null) {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}
		// 将当前beanName放入alreadyCreated中
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}

		try {
			// 获得bd，并检查mbd是否为抽象类
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);

			// 确保当前bean所依赖的bean都已经初始化好了
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					// 从dependentBeanMap中检查是否存在循环的depends-on
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					// 在dependentBeanMap注册依赖
					registerDependentBean(dep, beanName);
					try {
						// 获得依赖实例
						getBean(dep);
					}
					···异常抛出
				}
			}

			// 创建bean实例,如果bean为单例createBean
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, () -> {
					try {
						return createBean(beanName, mbd, args);
					}
					catch (BeansException ex) {
						// Explicitly remove instance from singleton cache: It might have been put there
						// eagerly by the creation process, to allow for circular reference resolution.
						// Also remove any beans that received a temporary reference to the bean.
						destroySingleton(beanName);
						throw ex;
					}
				});
				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
			// 如果为prototype
			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);
			}
			// 如果不为prototype和singleton则委托给相应的实现类来处理
			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;
		}
	}

	// 检查要求类型是否与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;
		}
		···打印日志抛出异常
	}
	return (T) bean;
}
2.1 获得单例对象缓存(从3级缓存获取)

singletonFactories：存放刚初始化的单例对象工厂，解决循环依赖
earlySingletonObjects：存放刚初始化还未配置属性和初始化的bean
singletonObjects：存放初始好的bean
Set singletonsCurrentlyInCreation：存放正在创建中的bean名称

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	// 从1级缓存获取已经初始化完成的bean
	Object singletonObject = this.singletonObjects.get(beanName);
	// 如果1级缓存不存在，且当前bean正在创建中
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		// 多线程同步锁，一个线程进入后，其他线程就能直接从缓存取
		synchronized (this.singletonObjects) {
			// 从2级缓存从获取对象实例
			singletonObject = this.earlySingletonObjects.get(beanName);
			// 如果仍为空且创建早期引用标识为true，从3级缓存获取
			if (singletonObject == null && allowEarlyReference) {
				// 获得单例工厂
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				// 工厂不为空将3级缓存升级到2级缓存
				if (singletonFactory != null) {
					singletonObject = singletonFactory.getObject();
					this.earlySingletonObjects.put(beanName, singletonObject);
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject;
}

3. createBean(AbstractAutowireCapableBeanFactory)

  • 首先确保beanclass被加载
  • 处理 lookup-method 和 replace-method
  • InstantiationAwareBeanPostProcessor实现类处理
  • 调用doCreateBean创建实例
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
	···日志打印
	RootBeanDefinition mbdToUse = mbd;

	// 确保beanclass被加载
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	// 准备方法复写，就是处理 lookup-method 和 replace-method
	// lookup-method:解决注入的prototype类型被缓存(p1==p2返回true，不符合prototype定义) <lookup-method name="方法名(抽象)" bean="bean引用名"/>
	// replace-method:通过实现MethodReplacer接口完成对原类方法的替换  <replaced-method name="方法名" replacer="替换类引用名"/>
	try {
		mbdToUse.prepareMethodOverrides();
	}
	···异常抛出

	try {
		// 实现InstantiationAwareBeanPostProcessor的类型在这可以返回代理对象
		// 如果postProcessBeforeInstantiation方法返回值不为null，则直接调用postProcessAfterInstantiation方法，不为空跳过doCreateBean(AOP生成代理对象)
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	···异常抛出

	try {
		// 创建bean实例
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		···日志打印
		return beanInstance;
	}
	···异常抛出
}

4. doCreateBean创建bean实例(AbstractAutowireCapableBeanFactory)

  • createBeanInstance创建bean实例
  • MergedBeanDefinitionPostProcessor接口处理
  • 解决循环依赖
  • 完成实例属性装配和初始完成后的回调
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

	// 定义Bean实例
	BeanWrapper instanceWrapper = null;
	// 如果为单例从工厂Bean缓存缓存移除实例
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		// 创建bean实例
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 获得bean实例及其类型
	final Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// MergedBeanDefinitionPostProcessor接口处理(@Autowired和@Value解析会用到)
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}

	// 解决循环依赖，如果为单例、允许循环依赖且bean正在创建中
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		···日志
		// 如果beanName不存在singletonObjects中，singletonFactories添加对象，earlySingletonObjects移除
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// 初始bean实例
	Object exposedObject = bean;
	try {
		// 完成实例的属性装配
		populateBean(beanName, mbd, instanceWrapper);
		// 处理bean初始化完成后的各种回调, init-method BeanPostProcessor InitializingBean 
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	···异常抛出

	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		// 存在循环依赖，如A->B,B->A，A在创建中依赖B，A在populateBean实例化B，B实例化完成持有A的初始引用XXX1
		// 如果经过initializeBean方法A对象实例改变为XXX2，导致B中持有A的依赖XXX1与当前A的依赖不一致则抛出异常
		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.");
				}
			}
		}
	}

	// 注册bean自定义销毁方法，DisposableBean destroy-method @PreDestroy
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	···异常抛出

	return exposedObject;
}
4.1 获得实例属性值，装配属性
  • InstantiationAwareBeanPostProcessors判断该bean属性是否需要被注入
  • 如果设置了自动装配采用自动装配获得属性
  • InstantiationAwareBeanPostProcessors注入属性(@Autowired和@Value注解实现)
  • 依赖检查
  • applyPropertyValues为实例填充属性(对属性值进行解析类型转换)
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	// 实例为null则直接返回(存在属性则抛出异常)
	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;
		}
	}

	// InstantiationAwareBeanPostProcessors修改属性值(在注入属性前)
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					return;
				}
			}
		}
	}
	// 获得需要注入的属性
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	int resolvedAutowireMode = mbd.getResolvedAutowireMode();
	// 如果为类型或名称自动装配
	if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		// 根据名称装配属性(遍历属性名，getBean)
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		// 根据类型装配属性
		if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		pvs = newPvs;
	}
	// 如果存在InstantiationAwareBeanPostProcessor
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	// 需要依赖检查
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

	PropertyDescriptor[] filteredPds = null;
	// 如果存在InstantiationAwareBeanPostProcessor 
	if (hasInstAwareBpps) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			// @Autowired和@Value注解就是通过AutowiredAnnotationBeanPostProcessor实现属性注入的
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				// 先调用postProcessProperties方法
				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					if (filteredPds == null) {
						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
					}
					// 未找到再调用deprecate方法postProcessPropertyValues
					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);
	}
}
4.2 实例初始化完成后的回调
  • 3个Aware接口设置
  • BeanPostProcessor处理，调用postProcessBeforeInitialization方法
  • init-method或InitializingBean接口afterPropertiesSet方法调用
  • BeanPostProcessor处理，调用postProcessAfterInitialization方法
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	// 如果bean实现了这三个接口BeanNameAware、BeanClassLoaderAware和BeanFactoryAware，则设置对应值
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	// BeanPostProcessor处理，如果返回null后续BeanPostProcessor都不处理
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// init-method方法处理
		// InitializingBean接口调用afterPropertiesSet方法
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	···异常抛出
	// BeanPostProcessor处理，如果返回null后续BeanPostProcessor都不处理
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}
4.3 注册销毁方法
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
	AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
	// 如果当前bean不为原型且存在销毁方法
	if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
		// 为单例
		if (mbd.isSingleton()) {
			// 注册DisposableBean实例来处理DestructionAwareBeanPostProcessors,
			// DisposableBean接口, destroy-method.
			registerDisposableBean(beanName,
					new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
		}
		else {
			// 其他范围
			Scope scope = this.scopes.get(mbd.getScope());
			if (scope == null) {
				throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
			}
			scope.registerDestructionCallback(beanName,
					new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
		}
	}
}

5. createBeanInstance创建bean实例(AbstractAutowireCapableBeanFactory)

  • 确保beanclass被加载，校验类访问权限
  • 通过supplier接口获得实例，通过工厂方法获得实例(优先加载factory-bean类)
  • 重复加载快捷方式
  • SmartInstantiationAwareBeanPostProcessor接口处理
  • 默认构造注入，如果有method override使用cglib生成代理类，否则使用java反射通过默认构造方法创建类实例
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable 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());
	}
	// 通过Supplier接口获得实例
	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}
	// 通过工厂方法获得实例,factory-method,factory-bean,如果factory-bean还没实例化则先实例化
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// 重新创建同一个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);
		}
		 // 默认构造注入，如果有method override使用cglib生成代理类，否则使用java反射通过默认构造方法创建类实例
		else {
			return instantiateBean(beanName, mbd);
		}
	}

	// 判断是否采用有参构造函数，SmartInstantiationAwareBeanPostProcessor接口处理
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// 默认构造的首选构造函数，子类实现
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	// 采用默认构造
	return instantiateBean(beanName, mbd);
}

总结

在这里插入图片描述

King77777777777
关注
专栏目录
【Spring6源码・IOC】Bean的初始化 - 终结篇
梵高
01-12 6604
上一篇，我们实例化了bean之后，将bean放入了第三级缓存，看一下这个addSingletonFactory方法，如果一级缓存中没有对应的bean，那么会将未初始化的bean放入三级缓存，会将bean提前暴露出来。我们来一起看一下这个处理属性的doWithLocalFields方法，首先通过getDeclaredFields方法获取类的属性集合，然后进行遍历调用函数去处理。这里主要有两点，一个是针对属性上的注解，一个是针对方法上的注解，大部分的时候会放在属性上，也有时候会放在方法上，比如set方法上。
IOC容器初始化流程
最新发布
CuteFruit的博客
08-06 747
了解过spring的都知道，spring是通过一个IOC容器管理应用中的bean对象的。本文讨论springboot应用在初始化IOC容器时的主要操作都有哪些。中提到refreshContext(context)实际会调用到AbstractApplicationContext的refres()方法。准备beanFactory，为其设置一些属性，如类加载器等。标记状态，校验必填属性，重置监听器状态等。提供先进的推理，复杂的指令，更多的创造力。为刷新上下文做一些准备工作，修改上下文的。
beanfactory中单例bean的初始化过程（一）
qq_36090711的博客
11-01 442
Date 10.06 pm Point 完成beanfactory中单例bean的初始化 beanFactory.preInstantiateSingletons() 拿到所有的bean定义信息（在 beanDefinitionNames中，遍历list 获取到bean的定义信息 如果这个bean不是抽象，是单例，不是懒加载的 判断这个bean是否factorybean（判断这个...
Spring源码（4）单例Bean的创建及初始化过程
weixin_45062785的博客
08-25 323
前言 在前面的三篇文章中，我们了解IOC的初始化流程 Spring源码（1）IOC的初始化流程（构造器篇，基于注解） Spring源码（2）IOC的初始化流程（register篇） Spring源码（3）IOC的初始化流程（refresh篇） 这一篇，我们开始refresh方法中的finishBeanFactoryInitialization(beanFactory)方法。直接上代码： /** * Finish the initialization of this context's bean fac
Spring 为啥默认把bean设计成单例详解
weixin_45342958的博客
04-21 182
熟悉Spring开发的朋友都知道Spring提供了5种作用域scope分别是singleton、prototype、request、session、global session。 Bean简介： 在Spring中，那些组成你应用程序的主体(backbone)及由SpringIoC容器所管理的对象，被称之为bean。简单地讲，bean就是由Spring容器初始化、装配及管理的对象，除...
Spring IOC容器中只存放单例Bean吗？
陈挖机的博客
07-31 240
https://mp.weixin.qq.com/s/nUBa7PAyyqii0Uk2rPs74A
Spring Ioc之初始化
weixin_34349320的博客
08-10 90
引言 spring加载xml的对象信息解析实例化成各个bean的过程我在这里就不细讲了，毕竟从头开始看很容易绕晕大家，反而让大家觉得这并不需要写。我们姑且认为spring已经加载好了各类对象信息封装成BeanDefinition，并已经实例化存储在了某个地方。不管是懒汉还是饿汉，都要经历反射出对象实例，然后初始化，我们先从spring中比较好理解的地方来入手IOC，那就是IOC中的bean在实例化...
Spring Bean创建初始化流程.docx
03-04
9. **Bean初始化**： 最后，`initializeBean(beanName, exposedObject, mbd)`对创建好的Bean进行初始化，包括调用初始化方法（如果有`@PostConstruct`注解的方法），以及执行AOP代理等操作。 整个流程中，Spring...
SpringIOC refresh()初始化代码实例
08-24
SpringIOC refresh()初始化代码实例的主要作用是实例化所有不需要延迟初始化的单例bean，这些bean是在应用程序启动时需要初始化的。在 Spring 框架中，bean 的实例化是通过 BeanFactory 来完成的，而 refresh() 方法...
Spring源码阅读-IOC容器初始化过程
软件工程探索之旅
03-05 315
BeanDefinition 就是POJO对象在IOC容器中的抽象。通过BeanDefinition 这个数据结构，使IOC容器能够方便的对POJO对象也就是Bean进行管理。将BeanDefinition 注册到hashmap中，也就是一个IOC容器中。Spring IOC容器的初始化过程：Resource定位，BeanDefinition载入，向IOC容器注册BeanDefinition。整个过程由refresh()方法触发，三个过程由不同的模块完成，使用户更加灵活的对这三个过程剪裁和扩展。
Spring框架IOC容器初始化核心源码解析之五：单例Bean循环依赖解决和自动注入机制
老周（重庆）的博客
12-11 244
填充属性 结合spring源码和 https://www.processon.com/view/link/5dec9a96e4b0c080dba0305b 上总结的流程图一起看，效果会更好。 书接上篇，继续分析populateBean(beanName, mbd, instanceWrapper);这个方法。 protected void populateBean(String beanName,...
单例bean什么时候初始化？
weixin_45143430的博客
07-03 1274
当bean被设置为单例非懒加载时，在spring容器创建时就已经初始化 例如 public class TestService{ public TestService(){ super(); System.out.println("-----------------testService创建完成-----------------------"); ...
spring ioc 单例 和多例模式学习
var1994的博客
05-09 3632
spring ioc中默认为单例，当scope设置为prototype的时为多例，设置为多例时，对象的创建时发生改变，无论lazy-init为什么值，都是在context.getBean();时创建对象多例模式例子：package zju_001.maven_test_1; import org.springframework.context.ApplicationContext; impor...
Spring：IOC中对象的多例和单例
SirouW的博客
09-12 1534
验证bean工厂创建的是否是单例对象，简述IOC生成单实例对象和多实例对象的方法
Spring框架(IOC&DI)xXML形式和注解形式
qq_42059426的博客
03-17 791
IOC Spring的依赖包 pom.xml <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5...
spring ioc 容器启动，创建bean，getBean流程
qq_42394457的博客
03-17 1131
本篇文章的目的 是 了解 spring ioc 启动 ，创建bean 到获取bean的时候，ioc 都做了些什么 文章很长，并且我能力有限，慎看， 之前 看过知乎上有 大佬说过， 带着目的看源码才是学习的正确方法，不要为了 看源码而看源码， 这样的学习是无效的 测试工具 idea 测试准备: 测试类 （javabean） : Person Person 实现 public class Pe...
SpringBoot源码初学者（四）：单例bean实例化
敲代码的旺财的博客
05-25 1857
ps：bean初始化相关的内容实在太多，不得已只好将其分成上下两篇来讲 上篇：主要讲解BeanFactory的相关内容，包括后置处理器的相关内容 下篇：主要讲解Bean的实例化 此篇为下篇，各位看客最好先去读一下上篇再来看，不然有可能很迷糊 系列文章链接： 《SpringBoot源码初学者（一）：SpringBoot功能扩展接口的使用与源码分析》 《SpringBoot源码初学者（二）：SpringBoot事件监听器》 《SpringBoot源码初学者（三）：真·用SpringBoot“new”女朋友的九
Spring Bean的实例化时机与ApplicationContext中单例bean的延迟初始化
拈花的专栏
08-26 1113
Spring Bean的实例化时机 Spring什么时候实例化bean，分两种情况： 如果使用BeanFactory做为bean容器，则所有bean都是在第一次使用时才实例化； 如果使用的是ApplicationContext，则： 如果bean的scope是singleton的，并且lazy-init为false(默认是false，所以可以不用设置)，则 ApplicationConte...
Spring 源码阅读 BeanFactory(三) 对象的初始化 singleton 草稿
weiythi的Blog
09-09 766
前言 前几篇文章已经说明Spring对BeanDefinition的解析与维护，在beans->bean标签定义下的bean 默认会通过 org.springframework.beans.factory.support.DefaultListableBeanFactory.registerBeanDefinition(String beanName, BeanDefinition beanDe
SpringIOC初始化：refresh()方法深度解析
8. **完成bean初始化**：所有单例bean都被实例化后，Spring会调用它们的初始化方法（如果有的话），这可以通过`@PostConstruct`注解的方法或`init-method`属性指定。 9. **发布初始化事件**：最后，`refresh()`方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值