Spring源码 之 bean的创建
一、源码分析 - 大体方向
1、finishBeanFactoryInitialization
bean的创建是在refresh
的finishBeanFactoryInitialization
方法进行的
// org.springframework.context.support.AbstractApplicationContext
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// ...
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
// org.springframework.beans.factory.support.DefaultListableBeanFactory
/** List of bean definition names, in registration order. */
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
@Override
public void preInstantiateSingletons() throws BeansException {
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 循环get所有bean
for (String beanName : beanNames) {
// getBean中,如果没有,会创建bean
getBean(beanName);
// ...
}
}
2、getBean –> doGetBean
// org.springframework.beans.factory.support.AbstractBeanFactory
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
// 先根据beanName尝试获取bean
Object sharedInstance = getSingleton(beanName);
// 如果已存在,就直接获取bean(getObjectForBeanInstance主要是为了处理FactoryBean)
if (sharedInstance != null && args == null) {
// ...
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// 如果不存在,就创建并返回Bean
else {
// ...
// 先检查parentBeanFactory是否存在指定bean
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 存在,从parentBeanFactory获取bean....
}
try {
// 获取BeanDefinition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 先获取当前bean依赖的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 注册并获取bean
registerDependentBean(dep, beanName);
try {
getBean(dep);
} // ...
}
}
// 前面都没获取到,就开始创建bean了........
// 单例bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 多例bean
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 其他scope的bean
else {
// 先获取scope
String scopeName = mbd.getScope();
Scope scope = this.scopes.get(scopeName);
try {
// 根据scope获取bean
// Request、Session 等作用域,都是通过 Attribute 实现类似单例池的作用
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) {
// ...
}
}
} 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;
} catch (TypeMismatchException ex) {
// ...
}
}
return (T) bean;
}
3、小结
先明确 获取bean 和 创建bean 的关系:如果获取不到bean,会创建bean。
getBean方法的主体流程:
- 获取bean
- 先获取bean,如果bean不存在,会创建bean。
- 类型转换
- 获取到bean之后,判断与requiredType是否一致,如果一致,直接返回;如果不一致,通过 TypeConverter 转换再返回。
- 返回bean
获取bean的流程:
- 先通过
getSingleton(beanName)
从缓存中获取bean(缓存指的是Spring的三级缓存,即三个map)- 这里获取到了,进行类型转换,然后返回bean
- 没获取到,再到
parentBeanFactory
看有没有指定bean,如果有,则获取parentBeanFactory
里的bean- 这里获取到了,直接返回bean,不进行类型转换
- 前面都没获取到,就开始创建bean了(这里简单描述一下,细节在后面展开说明)
- 单例:通过
getSingleton(beanName, singletonFactory)
方法创建bean - 多例:通过
createBean(beanName, mbd, args)
方法创建bean - 其他scope:通过 实现
Scope
接口的get
方法创建bean
- 单例:通过
- 创建完各
scope
的Instance
,通过getObjectForBeanInstance
处理FactoryBean
,返回真正的bean
二、源码分析 - bean的获取
1、getSingleton(beanName)
getSingleton(beanName)
根据beanName从缓存中获取bean(缓存指的是Spring的三级缓存,即三个map)
// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
// 一级缓存:存储单例对象,Bean已经实例化,初始化完成,可以直接使用
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存:存储早期单例对象,Bean已经实例化,但还没填充属性和初始化
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 三级缓存:存储bean工厂对象,用于创建bean实例并放入二级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
@Override
@Nullable
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 1. 先从一级缓存中获取
Object singletonObject = this.singletonObjects.get(beanName);
// 一级缓存中没有 && 正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 2. 从二级缓存中获取
singletonObject = this.earlySingletonObjects.get(beanName);
// 二级缓存中也没有 && 是否允许循环依赖(默认为true)
if (singletonObject == null && allowEarlyReference) {
// 3. 从三级缓存获取Factory(注意:三级缓存存放的是ObjectFactory,不是bean)
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 4. 调用 ObjectFactory 的 getObject 获取bean
// 这里其实调用的是匿名内部类的 getEarlyBeanReference() 方法
singletonObject = singletonFactory.getObject();
// 从三级缓存放入二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
// 返回单例bean实例
return singletonObject;
}
2、getObjectForBeanInstance
doGetBean
方法中可以看到,获取不同scope
的Instance
之后,都会通过getObjectForBeanInstance
来获取bean
getObjectForBeanInstance
其实主要就是对FactoryBean
做一个处理。
因此在看这个方法之前,先了解一下 FactoryBean
/**
* 实现FactoryBean后,会生成2个bean对象
* 1、beanName = factoryBeanImpl ------ getObject()返回的类 FactoryBeanObject
* 2、beanName = &factoryBeanImpl ------ FactoryBean的实现类 FactoryBeanImpl
*/
@Component
public class FactoryBeanImpl implements FactoryBean<FactoryBeanObject> {
@Override
public FactoryBeanObject getObject() {
return new FactoryBeanObject();
}
@Override
public Class<?> getObjectType() {
return FactoryBeanObject.class;
}
}
这样再看getObjectForBeanInstance
方法就很容易理解了。
// org.springframework.beans.factory.support.AbstractBeanFactory
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 以&开头的bean
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// 不是以&开头的bean,可以是 普通Bean 或 FactoryBean
// 普通Bean -> 直接返回Bean实例
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
// FactoryBean -> 返回getObject方法得到的实例
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
} else {
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
三、源码分析 - 不同scope的处理
1、单例bean的处理
// org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
if (mbd.isSingleton()) {
// 通过 ObjectFactory的匿名内部类 调用 createBean 创建bean
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
}
1)getSingleton(beanName,factory)
我们看一下 getSingleton(beanName,factory)
方法
// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
/**
* 这里传入的singletonFactory是ObjectFactory的匿名内部类
*/
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 1. 先从一级缓存中获取
Object singletonObject = this.singletonObjects.get(beanName);
// 一级缓存中没有
if (singletonObject == null) {
// 准备创建bean
// 在 singletonsCurrentlyInCreation 集合中添加bean(表示bean正在创建)
beforeSingletonCreation(beanName);
// 是否是新创建的bean
boolean newSingleton = false;
// 2. 调用 ObjectFactory的匿名内部类 的 getObject方法
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {...}
catch (BeanCreationException ex) {...}
finally {
// 在 singletonsCurrentlyInCreation 集合中移除bean(bean创建完了)
afterSingletonCreation(beanName);
}
// 3. 是否是新创建的bean
if (newSingleton) {
// 是 --> 添加到一级缓存和已注册bean集合,从二级和三级缓存中删除
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
2)addSingleton
// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
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);
}
}
2、多例bean的处理
// org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
// 直接调用 createBean 创建bean
prototypeInstance = createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
3、其他bean的处理
// org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
else {
String scopeName = mbd.getScope();
Scope scope = this.scopes.get(scopeName);
try {
// Scope接口的get方法,也是通过 ObjectFactory的匿名内部类 调用 createBean 创建bean
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) {
// ...
}
}
这里我们关注一下 RequestScope
和 SessionScope
,它们都继承于 AbstractRequestAttributesScope
public abstract class AbstractRequestAttributesScope implements Scope {
@Override
public Object get(String name, ObjectFactory<?> objectFactory) {
// 通过 Attribute 实现类似单例池的作用
RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
// 先从 Attribute 中获取指定对象
Object scopedObject = attributes.getAttribute(name, getScope());
// Attribute没有,则创建bean,再放入Attribute
if (scopedObject == null) {
scopedObject = objectFactory.getObject();
attributes.setAttribute(name, scopedObject, getScope());
// ...
}
return scopedObject;
}
}
4、小结
AbstractBeanFactory
中的 doGetBean()
方法中,针对不同scope,处理的方式也有所不同
- 单例:通过
getSingleton(beanName,factory)
方法创建bean,调用addSingleton()
放入一级缓存。- 其中
getSingleton(beanName,factory)
也是通过createBean()
创建bean
- 其中
- 多例:直接调用
createBean()
创建bean。 - 其他:扩展
Scope
接口中的get()
方法,实现创建bean的逻辑(也是通过createBean()
创建bean)- 其中
request
和session
作用域都是通过 Attribute 实现类似单例池的作用
- 其中
殊途同归,不同的scope,最后都会调用 createBean(beanName, mbd, args)
方法来创建bean
四、源码分析 - bean的创建
1、createBean
前面我们讲到,不同的scope,最后都会调用 createBean(beanName, mbd, args)
方法来创建bean
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// clone the bean definition
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName,
"Validation of method overrides failed", ex);
}
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
try {
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName,
"Unexpected exception during bean creation", ex);
}
}
2、doCreateBean
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 单例直接从缓存取
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 1. 创建Bean实例(推断构造方法/工厂方法创建bean实例)
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// bean的实例(还未填充属性)
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// ......
// 单例 && 允许循环依赖 && 正在创建中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 2. 将 ObjectFactory的匿名实现类 放入三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 3. 填充属性
populateBean(beanName, mbd, instanceWrapper);
// 4. 初始化bean(这里返回的可能是代理对象)
exposedObject = initializeBean(beanName, exposedObject, mbd);
} catch (Throwable ex) {
// ....
}
// 单例 && 允许循环依赖 && 正在创建中
if (earlySingletonExposure) {
// 从一级缓存获取bean
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
// exposedObject不是代理对象
exposedObject = earlySingletonReference;
}
// exposedObject是代理对象
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
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
// 返回bean
return exposedObject;
}
1)createBeanInstance
推断构造方法/工厂方法,构建单例bean的Instance实例,封装到BeanWrapper中返回。
- 进行到这里还未进行属性的填充(也就是还没有进行依赖注入)
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// ...
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 调用FactoryMethod创建bean
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// ...
if (resolved) {
if (autowireNecessary) {
// 使用@Autowire标注的构造方法
return autowireConstructor(beanName, mbd, null, null);
} else {
return instantiateBean(beanName, mbd);
}
}
// Candidate constructors for autowiring?
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
2)addSingletonFactory
将 ObjectFactory 放入三级缓存(匿名实现类),用于解决循环依赖。(Bean实例化之后,填充成员属性之前)
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean
// 单例 && 允许循环依赖 && 正在创建中
if (earlySingletonExposure) {
// 将 ObjectFactory的匿名实现类 放入三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
// 一级缓存不存在
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory); // ObjectFactory 放入三级缓存
this.earlySingletonObjects.remove(beanName); // 移除二级缓存
this.registeredSingletons.add(beanName); // 加入已注册的单例bean
}
}
}
【1】getEarlyBeanReference
放入三级缓存
的ObjectFactory
的匿名实现类的getObject
方法,其实就是调用getEarlyBeanReference
方法。
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp =
(SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
【2】AbstractAutoProxyCreator
AbstractAutoProxyCreator
实现了SmartInstantiationAwareBeanPostProcessor
接口
- 调用三级缓存中
ObjectFactory
的getObject
方法时,会调用到这个方法。
// org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
// 记录已被代理的对象
this.earlyProxyReferences.put(cacheKey, bean);
// 返回的是代理对象
return this.wrapIfNecessary(bean, beanName, cacheKey);
}
3)populateBean
填充bean的成员属性(属性注入)
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 填充属性
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
} // ...
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// ...
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);
// 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;
}
// ...
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
4)initializeBean
初始化bean:这里会调用各接口实现类实现的方法(返回的可能是代理对象)
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
// 初始化bean(这里返回的可能是代理对象)
exposedObject = initializeBean(beanName, exposedObject, mbd);
} // ...
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
} else {
// 1. 调用 BeanNameAware 实现的 setBeanName 方法
// 2. 调用 BeanClassLoaderAware 实现的 setBeanClassLoader 方法
// 3. 调用 BeanFactoryAware 实现的 setBeanFactory 方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 调用 BeanPostProcessor接口实现 的 postProcessBeforeInitialization 方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 1. 调用 InitializingBean接口实现 的 afterPropertiesSet 方法
// 2. 调用 自定义的 InitMethod 方法
invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable ex) {
// throw new BeanCreationException
}
if (mbd == null || !mbd.isSynthetic()) {
// 调用 BeanPostProcessor接口实现 的 postProcessAfterInitialization 方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
【1】AbstractAutoProxyCreator
AbstractAutoProxyCreator
实现了 BeanPostProcessor
接口,实现了下面两个方法。
public Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
// 这里获取到的,是代理对象
Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
// 代理对象 != 当前对象
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// 判断是否需要代理,需要,返回代理对象;不需要,返回当前对象
return this.wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
3、bean的生命周期
1)概述
Bean 在 Spring容器 中从 创建 到 销毁 经历了若干个阶段:
# 实例化
1. Spring对bean进行实例化
推断构造方法/工厂方法,基于 BeanDefinition 对bean进行实例化,
实例化的Instance封装在 BeanWrapper 对象中。
# 属性填充
2. Spring将值和依赖的bean填充到bean对应的属性中
根据 BeanDefinition 获取 PropertyValues,填充属性到 BeanWrapper 中的 Instance。
# 初始化
3. 如果bean实现了 BeanNameAware 接口
-> Spring会调用 setBeanName(String beanName) 方法
4. 如果bean实现了 BeanClassLoaderAware 接口
-> Spring会调用 setBeanClassLoader(ClassLoader classLoader) 方法
4. 如果bean实现了 BeanFactoryAware 接口
-> Spring会调用 setBeanFactory(BeanFactory beanFactory) 方法
5. 如果bean实现了 ApplicationContextAware 接口
-> Spring会调用 setApplicationContext(ApplicationContext applicationContext) 方法
6. 如果bean实现了 BeanPostProcessor 接口
-> Spring会调用 postProcessBeforeInitialization(Object bean, String beanName) 方法
7. 如果bean实现了 InitializingBean 接口
-> Spring会调用 afterPropertiesSet() 方法
8. 如果bean定义时声明了初始化方法 initMethod()
-> Spring会执行 自定义的初始化方法 initMethod()
9. 如果bean实现了 BeanPostProcessor 接口
-> Spring会调用 postProcessAfterInitialization(Object bean, String beanName) 方法
# 销毁
10. 如果bean实现了DisposableBean接口
-> Spring会调用 destroy() 方法,进行bean的销毁。
11. 如果bean定义时声明了销毁方法 destroyMethod()
-> Spring会执行 自定义的销毁方法 destroyMethod()
2)案例演示
@Configuration
public class CycleConfig {
/**
* 指定 自定义初始化 & 自定义销毁 方法
*/
@Bean(initMethod = "customInit", destroyMethod = "customDestroy")
public BeanCycle beanCycle() {
return new BeanCycle();
}
}
/**
* Bean的生命周期
*/
public class BeanLifecycle implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,
ApplicationContextAware, BeanPostProcessor, InitializingBean, DisposableBean {
public BeanLifecycle() {
System.out.println("执行 构造方法");
}
@Override
public void setBeanName(String name) {
System.out.println("执行 BeanNameAware 的 setBeanName 方法");
}
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
System.out.println("执行 BeanClassLoaderAware 的 setBeanClassLoader 方法");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("执行 BeanFactoryAware 的 setBeanFactory 方法");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("执行 ApplicationContextAware 的 setApplicationContext 方法");
}
@PostConstruct
void postConstruct() {
System.out.println("执行 @PostConstruct 标记的方法");
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
// System.out.println("执行 BeanPostProcessor 的 postProcessBeforeInitialization 方法");
return bean;
}
@Override
public void afterPropertiesSet() {
System.out.println("执行 InitializingBean 的 afterPropertiesSet 方法");
}
public void customInit() {
System.out.println("执行 自定义的初始化方法 customInit");
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
// System.out.println("执行 BeanPostProcessor 的 postProcessAfterInitialization 方法");
return bean;
}
@PreDestroy
void preDestroy() {
System.out.println("执行 @PreDestroy 标记的方法");
}
@Override
public void destroy() {
System.out.println("执行 DisposableBean 的 destroy 方法");
}
public void customDestroy() {
System.out.println("执行 自定义的销毁方法 customDestroy");
}
}
执行结果
// 启动服务
执行 构造方法
执行 BeanNameAware 的 setBeanName 方法
执行 BeanClassLoaderAware 的 setBeanClassLoader 方法
执行 BeanFactoryAware 的 setBeanFactory 方法
执行 ApplicationContextAware 的 setApplicationContext 方法
执行 @PostConstruct 标记的方法
执行 InitializingBean 的 afterPropertiesSet 方法
执行 自定义的初始化方法 customInit
// 关闭服务
执行 @PreDestroy 标记的方法
执行 DisposableBean 的 destroy 方法
执行 自定义的销毁方法 customDestroy
五、小结
0、三级缓存
Spring通过三级缓存解决了单例bean的循环依赖问题。
三级缓存其实就是三个Map(注意:三级缓存的 value
是 ObjectFactory
类型的,即bean工厂)
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
缓存字段 | 级别 | 描述 |
---|---|---|
singletonFactories | 三级缓存 | 存储ObjectFactory对象,用于创建bean实例并放入二级缓存 |
earlySingletonObjects | 二级缓存 | 存储早期单例对象,Bean已经实例化,但还没填充属性和初始化 |
singletonObjects | 一级缓存 | 存储单例对象,Bean已经实例化,初始化完成,可以直接使用 |
1、只有 A
@Service
public class CircularServiceA {
private String fieldA = "字段 A";
}
2、A 依赖 B
@Service
public class CircularServiceA {
@Autowired
private CircularServiceB circularServiceB;
}
@Service
public class CircularServiceB {
}
3、A 和 B 循环依赖
@Service
public class CircularServiceA {
@Autowired
private CircularServiceB circularServiceB;
}
@Service
public class CircularServiceB {
@Autowired
private CircularServiceA circularServiceA;
}
4、只有 代理A
@Service
public class CircularServiceA {
private String fieldA = "字段 A";
public void methodA() {
System.out.println("方法 A 执行");
}
}
@Aspect
@Component
public class AspectA {
@Before("execution(public void com.example.demo.test.CircularServiceA.methodA())")
public void beforeA() {
System.out.println("beforeA 执行");
}
}
5、代理A 和 代理B 循环依赖
@Service
public class CircularServiceA {
private String fieldA = "字段 A";
@Autowired
private CircularServiceB circularServiceB;
public void methodA() {
System.out.println("方法 A 执行");
}
}
@Aspect
@Component
public class AspectA {
@Before("execution(public void com.example.demo.test.CircularServiceA.methodA())")
public void beforeA() {
System.out.println("beforeA 执行");
}
}
@Service
public class CircularServiceB {
@Autowired
private CircularServiceA circularServiceA;
public void methodB() {}
}
@Aspect
@Component
public class AspectB {
@Before("execution(public void com.example.demo.test.CircularServiceB.methodB())")
public void beforeB() {
System.out.println("beforeB 执行");
}
}