Spring得Bean生命周期
一、Spring生命周期
1.读取配置文件，解析成Document对象，将Document对象封装为BeanDefinition对象，然后注册该对象，将Definition对象添加到beanDefinitionMap中,beanName添加到beanDefinitionNames中
2.实例化Bean，反射的方式生成对象
3.填充bena的属性：populateBean(),循环依赖的问题(三级缓存)
4.调用aware接口相关的方法：invokeAwareMethod(完成BeanName可以获取容器bean的名称，BeanFactory获取当前bean factory这也可以调用容器的服务，BeanClassLoader对象的属性设置)
5.调用BeanPostProcessor中的前置处理方法：使用比较多的有(ApplicationContextPostProcessor设置ApplicationContext，Environment,ResourceLoader,EmbeddValueResolver等对象)
6.调用initmethod方法:invokeInitmethod(),判断是否实现了InitializingBean接口，如果有，调用afterPropertiesSet方法，
7.调用BeanPostProcessor的后置处理方法：spring的aop就是在此处实现的，AbstractAutoProxyCreator，注册Destuction相关的回调接口
8.获取到完整的对象，可以通过getBean的方式来进行对象的获取
9.销毁流程 ①判断是否实现了DispoableBean接口②调用destroyMethod方法
二、生命周期图解
refresh方法图解
二、源码
1.refresh()方法
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//前戏 做容器刷新前的准备工作
//1.设置容器的启动时间 2.设置活跃状态为true 3.设置关闭状态为false 4.获取Environment对象 加载当前系统的属性值到Environment对象中 5.准备监听器和事件的集合对象 默认为空集合
prepareRefresh();
// 创建容器对象：DefaultListableBeanFactory
//加载配置文件到工厂中 bean对象封装为BeanDefinition对象(很复杂的流程)
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//beanFactory的准备工作 对各种属性进行填充
prepareBeanFactory(beanFactory);
try {
//子类覆盖方法做额外的处理，此处我们自己一般不做任何扩展工作，但是可以看web的代码，有具体实现
postProcessBeanFactory(beanFactory);
//调用各种beanFactory处理器
invokeBeanFactoryPostProcessors(beanFactory);
//注册bean处理器，这里只是注册功能，真正调用的是getBean方法
registerBeanPostProcessors(beanFactory);
//为上下文初始化message源，即不同语言消息体，国际化处理
initMessageSource();
//初始化时间监听多播器
initApplicationEventMulticaster();
//留给子类来初始化其他bean 方便扩展，SpringBoot内嵌tomcat就是在这里实现的
onRefresh();
//在所有注册的bean中查找listener bean，注册到消息广播器中
registerListeners();
// 实例化剩下的单实例（非懒加载的）bean的声明周期（进行bean的对象创建工作，主要源码）
finishBeanFactoryInitialization(beanFactory);
// 完成刷新过程 通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
2.finishBeanFactoryInitialization()方法
代码如下（示例）：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 为上下文初始化类型转换器
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
//如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器，主要用于注解属性值的解析
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定义，说明注册的bean定义将不被修改活任何进一步的处理
beanFactory.freezeConfiguration();
//实例化剩下的单例对象
beanFactory.preInstantiateSingletons();
}
3.preInstantiateSingletons()方法
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
//将所有beanDefinition的名字创建一个集合
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//遍历集合对象 出发所有非延迟加载单例bean的初始化
for (String beanName : beanNames) {
//合并父类beanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//条件判断 抽象 单例 非懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断是否实现了FactoryBean接口
if (isFactoryBean(beanName)) {
//根据&+beanName来获取具体对象 beanName是获取具体容器对象 加&是获取FactoryBean对象
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 {
//普通bean获取
getBean(beanName);
}
}
}
//遍历beanNames 触发所有SmartInitializingSingleton的后初始化回调
for (String beanName : beanNames) {
//获取bean实例
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();
}
}
}
}
4.doGetBean()方法
public Object getBean(String name) throws BeansException {
//此方法是实际获取bean的方法
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 {
final String beanName = transformedBeanName(name);
Object bean;
//提前检查缓存中是否有手动注册的单例对象（循环依赖处理有关）
Object sharedInstance = getSingleton(beanName);
//如果找到了bean的单例对象 且没有创建bean实例时要使用的参数
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//返回对象的实例，
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 当对象都是单例的时候会尝试解决循环依赖的问题 但是原型模式下如果存在循环依赖的情况 直接抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//如果bean定义不存在 就检查父工厂是否有
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果beanDefinitionMap（已经加载的类）中不包含beanName,那么就尝试从父容器中获取
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 获取Name对应的规范名称（全类名）如果那么前面有‘&’则会返回‘&’+规范名称（全类名）
String nameToLookup = originalBeanName(name);
//如果父工厂是AbstractBeanFactory的实例
if (parentBeanFactory instanceof AbstractBeanFactory) {
//调用父工厂的doGetBean 递归
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 {
//使用父工厂获取bean 通过全类名
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
//如果不是做类型检查 那么表示要创建bean 此处在集合中做一个记录
if (!typeCheckOnly) {
//为beanName标记为已经创建（或将要创建）
markBeanAsCreated(beanName);
}
}
try {
//BeanDefinition对象转换，
//此处要做类型转换 如果子类是bean的话 会合并父类的相关属性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查mbd的合法性 不合格抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// 如果存在依赖的bean的话 那么则优先实例化依赖的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
//遍历实例化依赖的baen
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//注册各个bean的依赖关系 方便进行销毁
registerDependentBean(dep, beanName);
try {
//递归优先实例化被依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 创建bean的实例对象 单例对象
if (mbd.isSingleton()) {
//返回beanName的单例对象 如果未注册 则使用singletonFactory创建并注册一个对象
sharedInstance = getSingleton(beanName, () -> {
try {
//为给定的合并后的BeanDefinition创建一个bean实例
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);
}
//原型模式
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);
}
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;
}
}
5.getSingleton()方法
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从一级缓存中加载 bean
Object singletonObject = this.singletonObjects.get(beanName);
// 缓存中的 bean 为空，且当前 bean 正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从 二级缓存 获取，表示此bean正在创建，不进行后续处理
singletonObject = this.earlySingletonObjects.get(beanName);
// 二级缓存中没有，且允许提前创建
if (singletonObject == null && allowEarlyReference) {
// 从 三级缓存中获取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//实际上调用的是getEarlyBeanReference(beanName, mbd, bean)
singletonObject = singletonFactory.getObject();
//三级缓存中移除 加入到二级缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
6.getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
//保证线程同步
synchronized (this.singletonObjects) {
//从一级缓存中拿单例对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//创建单例之前的回调 默认实现将单例注册为当前正在创建中
beforeSingletonCreation(beanName);
//表示生成了新的单例对象的标记 默认false
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//函数式接口 会调用createBean方法
singletonObject = singletonFactory.getObject();
//表示生成了单例对象
newSingleton = true;
}
catch (IllegalStateException ex) {
// 同时 单例对象是否隐式出现 如果是 请继续操作 因为异常表明该状态
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
//如果生成了新对象 则加入到一级缓存中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
protected void addSingleton(String beanName, Object singletonObject) {
//创建对象成功后则将成品对象加入到一级缓存中 移除二级缓存和三级缓存
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
7.createBean()方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 根据bean定义信息和bean名称解析得到bean的Class类型
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
//验证并准备为此 bean 定义的方法覆盖
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//给InstantiationAwareBeanPostProcessor后置处理器一个机会，返回代理对象用来替换目标bean实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
// 如果bean不为空的话，则直接返回，不执行下面的doCreateBean创建bean实例操作
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
//返回创建好的bean实例
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
8.doCreateBean()方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 如果是单例bean，尝试从未完成创建的包装Bean缓存（factoryBeanInstanceCache）中获取BeanWrapper（bean的包装类）, 如果获取成功，还将清除这个缓存
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 如果缓存中不存在的话，则调用createBeanInstance创建一个BeanWrapper（bean的包装类）
if (instanceWrapper == null) {
// 完成bean的实例化的方法，根据指定bean使用的策略创建bean的实例，如工厂方法、构造方法自动注入、简单初始化
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 获取包装器里面刚创建好的bean实例
final Object bean = instanceWrapper.getWrappedInstance();
// 获取实例化对象的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// 允许后处理器修改合并的 bean 定义
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//应用合并后的BeanDefinition后置处理器：执行MergedBeanDefinitionPostProcessor后置处理器增强方法postProcessMergedBeanDefinition()
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 是否允许提前暴露bean对象(即半成品对象)
// earlySingletonExposure的值由三部分确定：单例bean && 允许循环依赖 && 当前bean正在创建中
// isSingletonCurrentlyInCreation(beanName)的作用：返回指定的单例 bean 当前是否正在创建中
// allowCircularReferences：是否允许循环依赖，默认为true
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 为避免循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂，将生成bean的工厂添加到三级缓存(singletonFactories)中
// 第二个参数同样是一个ObjectFactory，是一个函数式接口，当执行ObjectFactory的getObject()方法的时候，实际上执行的是getEarlyBeanReference(beanName, mbd, bean)
// getEarlyBeanReference(beanName, mbd, bean)的作用: 获取早期访问指定 bean 的引用
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//属性填充，对bean各个属性值进行注入，可能存在依赖于其它bean的属性，则会递归初始依赖的bean(循环依赖就在此进行)
populateBean(beanName, mbd, instanceWrapper);
//初始化Bean，如执行aware接口、执行init-method方法、BeanPostProcessor后置增强等等
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) {
// 能进入这里，说明Spring检测到发生了循环依赖
// exposedObject == bean：两者相等，说明bean在执行initializeBean()初始化的时候，没有被后置处理器增强，还是原来那个对象
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// allowRawInjectionDespiteWrapping: 表示是否允许在循环引用的情况下注入原始 bean 实例，即使注入的 bean 最终被增强器增强包装过，默认是false
// hasDependentBean(beanName)：是否存在其他bean依赖了当前bean
// 获取到依赖当前bean的所有bean的beanName
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
// 尝试移除bean实例，因为执行到这里，说明exposedObject != bean，也就是bean已经被后置处理器增强，不是原来的对象了，
// 他们依赖的是原来的对象，属于脏数据，所以需要移除掉
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
// 使用actualDependentBeans记录那些移除失败的dependentBean
actualDependentBeans.add(dependentBean);
}
}
// 如果存在移除失败的，则需要抛出异常，Spring不允许脏依赖的存在(通过allowRawInjectionDespiteWrapping设置)
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.");
}
}
}
}
// Register bean as disposable.
try {
// 注册DisposableBean的实现，在注销时执行来源于DestructionAwareBeanPostProcessors、实现的DisposableBean的destroy方法还有自己配置的destroy-method的处理
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
9.populateBean()方法
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 针对bean的包装器是否为空、是否存在为此 bean 定义的属性值，做不同的处理
if (bw == null) {
// 如果bean的包装器为空，但是又存在为此 bean 定义的属性值，Spring则会抛出BeanCreationException异常
// 因为属性填充就是要给BeanWrapper 中的 bean 实例中的属性进行赋值的过程，存在属性，但是BeanWrapper为空，也就是BeanWrapper 中的 bean 实例为空，那么显然不行
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
} else {
// 如果没有为此 bean 定义的属性值，即没有可填充的属性，则直接返回
// 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.
// InstantiationAwareBeanPostProcessor后置处理器：可以在属性设置前修改bean
// 如果bean定义不是合成的，并且工厂中存在创建时应用于单例 bean 的 InstantiationAwareBeanPostProcessor后置处理器，则需要处理执行它的postProcessAfterInstantiation()方法
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 获取到bean工厂所有已经注册的BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 判断是否属于InstantiationAwareBeanPostProcessor类型
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 如果类型匹配的话，将会执行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation()方法
// postProcessAfterInstantiation()方法：在bean实例化后，属性填充之前被调用，允许修改bean的属性，默认实现是返回true
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
// 如果postProcessAfterInstantiation()方法返回false，则跳过后面的属性填充过程
return;
}
}
}
}
// 获取到bean定义中封装好的属性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 根据设置的自动注入方式（名称或者类型）获取属性bean（递归getBean）存入PropertyValues中
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 根据名称自动注入
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
//根据类型自动注入
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// hasInstAwareBpps：工厂是否存在将在创建时应用于单例 bean 的 InstantiationAwareBeanPostProcessor后置处理器
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// needsDepCheck：是否需要进行依赖检查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
// 如果存在InstantiationAwareBeanPostProcessor后置处理器，需要执行InstantiationAwareBeanPostProcessor的postProcessProperties()以及postProcessPropertyValues()方法回调
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 执行InstantiationAwareBeanPostProcessor的postProcessProperties()以及postProcessPropertyValues()方法回调
// postProcessProperties(): 允许对填充前的属性进行处理（如对属性的验证）
// postProcessPropertyValues(): 对属性值进行修改，通过基于原始的PropertyValues创建一个新的MutablePropertyValues实例，添加或删除特定的值。
// 不过目前方法已经被标记为过期，在后续Spring版本中可能会被删除
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;
}
}
}
// 执行依赖检查，对应depend-on属性
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 依赖检查，对应depend-on属性
checkDependencies(beanName, mbd, filteredPds, pvs);
}
// 属性填充的具体过程，即将属性值赋值到beanWrapper中bean实例的具体属性中
if (pvs != null) {
// 开始填充属性值
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
10.initializeBean()方法
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
// 执行Aware方法，如BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
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()) {
// 执行BeanPostProcessor后置处理器的前置处理方法：postProcessBeforeInitialization()，允许对bean实例进行包装
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 执行初始化方法,包括InitializingBean的afterPropertiesSet()方法、自定义的初始化方法init-method
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()) {
// 执行BeanPostProcessor后置处理器的后置处理方法：postProcessAfterInitialization()，允许对bean实例进行包装
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
三.如何解决循环依赖
1.什么是循环依赖
例如往容器中注册一个bean实例A以及实例B，A中实例引用了实例B，B对象也引用了A，那么Spring创建单实例对象是一个一个来创建的，假设先创建A，那么在初始化A对象时发现A用到了B对象，那么这时候为了完成A对象的初始化，则要创建B对象，创建B对象后初始化时，发现B引用了A，那么这时候需要从容器中获取A，这时A未初始化完成，是半成品对象，那么就不能给B对象完成引用，这时候就又要创建A，此时就陷入了死循环
2.Spring是如何解决的
利用三级缓存
先看下三级缓存长什么样子
//一级缓存 存储的为成品对象 可暴漏出去
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//三级缓存 value是一个函数式接口 只有真正调用getObject时才会执行
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
//二级缓存 存储的为半成品对象
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
从源码分析画图流程图
3.为什么使用二级缓存，只用一级缓存可以解决问题么
一级缓存不能解决循环依赖，因为一级缓存存的是成品对象，是真正暴漏出去的对象，二级缓存中是存储的半成品对象，是不能对外暴漏的，如果对外暴漏出去，其他线程去引用的时候是个半成品对象的时候，可能会出现空指针异常
4.为什么用三级缓存
二级缓存可以解决循环依赖问题，但是加三级缓存时为了解决aop下的循环依赖 ，如果有a有代理对象 那么 a引用b ，b再引用a时候 返回的如果是a，而不是a的代理对象 那么会出问题，报错， 那么如果不加三级缓存也可以，那每次我创建对象的时候，都要判断是都要创建代理对象，这样就不符合spring的逻辑，spring的逻辑是创建对象后才会去生成代理对象；加个三级缓存，只是当在循环依赖下的时候 ，才会出现去判断是不是代理对象，因为是函数式接口，只有在循环依赖的情况下才会从三级缓存中获取，获取之后调用getObject方法才会真正判断该对象是否需要创建代理对象，如果需要，返回的就是一个代理对象，那么这时候再回到正常的逻辑之后，在beanpostprocessorAfter方法中不会再次创建该代理对象；
437
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
