一 概述
createBean顾名思义是创建bean对象的实例，但是实际干活还是调用doCreateBean去实例化对象。如果对应的bean是单例的，则会被添加到一级缓存中，并将二三级缓存的数据删除。
这里有个两个重要的概念，一个是循环依赖，说简单点就是两个Bean存在相互引用的情况，在Sspring中当且仅当Bean的类型为单例且属性注入存在对其他Bean的引用的情况下，Spring通过三级缓存解决了循环依赖问题，其他场景（Bean非单例，构造函数存在对其他Bean的依赖等）都会抛出异常！
另外一个就是Bean的生命周期，就是从Bean对象被实例化直至Bean被销毁的流程。
本文主要从解决循环依赖和讲述Bean生命周期的角度去撰写，其他不次要的类和方法不会详细展开。
二 Spring Bean循环依赖的例子
定义两个bean：ServiceA（服务A）和ServiceB（服务B），且服务A和服务B存在属性值的相互依赖
2.1 修改配置文件
<bean id="serviceA" class="com.service.ServiceA">
<property name="serviceB" ref="serviceB"/>
</bean>
<bean id="serviceB" class="com..service.ServiceB">
<property name="serviceA" ref="serviceA"/>
</bean>
2.2 服务A代码
public class ServiceA {
private ServiceB serviceB;
public ServiceB getServiceB(){
return serviceB;
}
public void setServiceB(ServiceB serviceB){
this.serviceB = serviceB;
}
public ServiceA(){
System.out.println("---ServiceA created success");
}
}
2.3 服务B代码
public class ServiceB {
private ServiceA serviceA;
public ServiceA getServiceA(){
return serviceA;
}
public void setServiceA(ServiceA serviceA){
this.serviceA = serviceA;
}
public ServiceB(){
System.out.println("---ServiceB created success");
}
}
2.4 测试代码
public class BeanLifeCycle{
public static void main(String[] args) throws Exception{
System.out.println("现在开始初始化容器");
ApplicationContext factory = new ClassPathXmlApplicationContext("beans.xml");
System.out.println("容器初始化成功");
ServiceA serviceA = (ServiceA)factory.getBean("serviceA");
ServiceB serviceB = serviceA.getServiceB();
ServiceB serviceB2 = (ServiceB)factory.getBean("serviceB");
System.out.println("serviceB == serviceB2: " + (serviceB == serviceB2));
System.out.println("现在开始关闭容器！");
((ClassPathXmlApplicationContext) factory).close();
}
}
2.5 日志
现在开始初始化容器
---ServiceA created success
---ServiceB created success
容器初始化成功
serviceB == serviceB2: true
现在开始关闭容器！
三 Spring Bean循环依赖流程分析
图片中红色字体的部分是关键，通过三级缓存机制，完美解决Spring Bean的循环依赖。
四 Spring Bean生命周期对应的方法
虚线左边流程图是根据《Spring实战》中提供的Spring Bean生命周期的流程，但是美中不足的是没把每一步对应的大致方法对应上去。在后面分析createBean源码的过程中，基本涵盖了Spring Bean生命周期的发部分源码（除了销毁部分），因此在这类系统性总结Spring Bean生命周期每一步对应的方法调用，后面读者看代码就清楚了。
另外这个生命周期流程还有个缺点是没有涉及容器销毁。当容器关闭时候（调用close()方法，会依次执行
1）回调DestructionAwareBeanPostProcessor接口实现类的postProcessBeforeDestruction方法
2）回调DiposibleBean接口实现类的destory()方法
3）回调配置文件的destroy-method属性指定的销毁方法
五 源码
createBean方法方法主要为真正创建bean对象（调用doCreateBean）前后做铺垫，了解下就可以。
5.1 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对象的类型
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
//类型为null 且 mbd的beanClass属性为空 且 全类名为空
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//使用mbd为入参，新创建一个RootBeanDefinition
mbdToUse = new RootBeanDefinition(mbd);
//mbdToUse的BeanClass赋值为resolvedClass
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
//验证并准备当前 bean定义的覆盖方法。 检查具有指定名称的方法是否存在。
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
//抛出异常
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//用于bean实例化前的后处理器，解决指定 bean 是否有实例化前的快捷方式。让 BeanPostProcessors 有机会返回一个代理而不是目标 bean 实例。
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//bean不为空
if (bean != null) {
//快速返回bean对象
return bean;
}
}
catch (Throwable ex) {
//抛出异常
}
try {
//真正动手创建Bean的实例
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
//返回bean的实例化对象
return beanInstance;
}
//异常
}
5.2 doCreateBean方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
//Bean的包装类
BeanWrapper instanceWrapper = null;
//bean为单例
if (mbd.isSingleton()) {
//从缓存中移除factoryBean，如果当前bean属于factoryBean，则instanceWrapper不为空
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
//instanceWrapper为空
if (instanceWrapper == null) {
//bean对象的实例化
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取bean对象
final Object bean = instanceWrapper.getWrappedInstance();
//获取bean对象的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
//不为空bean
if (beanType != NullBean.class) {
//记录bean的类型
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//判断作用于当前bean的后置处理器是否实现MergedBeanDefinitionPostProcessor接口。若是则调用postProcessMergedBeanDefinition方法。主要是处理 @PreDestory 、@PostConstruct、@Autowire、@Value和@Resource等注解
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 是单例 && 支持循环依赖 && Bean正在创建
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");
}
//添加到三级缓存中
//这一步是解决循环依赖的关键，因为先将服务A放入三级缓存中， 后期服务B的属性注入阶段，发现自己依赖服务A，就可以通过三级缓存获取服务A，从而完成属性注入
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
//bean的实例
Object exposedObject = bean;
try {
//属性注入
populateBean(beanName, mbd, instanceWrapper);
//初始化
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) {
//从一级或者二级缓存中获取bean对象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
//省略
}
}
// Register bean as disposable.
try {
//检查bean对象）否需实现DisposableBean接口2）是否有配置属性“destroy-method”3）是否有作用于当前Bean的实现Destruction接口的后置处理器。如果有满足的条件，则注册到相应的容器中，当bean销毁/Spring工厂关闭时，则会回调相关方法。
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
//返回bean对象
return exposedObject;
}
5.3 createBeanInstance方法
通过createBeanInstance方法完成Bean对象的实例化，此时属性还没有注入
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
//获取beanName对应的Class类的对象
Class<?> beanClass = resolveBeanClass(mbd, beanName);
//beanClass不为空
//eanClass非公开类
//没有权限访问公共非公共的构造函数和方法
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());
}
//省略
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
//安全相关
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
//调用反射完成bean对象的实例化
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
//封装Bean对象到包装类
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
//返回包装类
return bw;
}
//异常处理
5.4 addSingletonFactory
beanName对应的bean对象已经实例，但是还没有完成Bean的初始化。通过addSingletonFactory将此beanName添加到三级缓存中。
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);
//从二级缓存中移除
this.earlySingletonObjects.remove(beanName);
//添加到单例注册表中
//记录单例Bean添加的顺序
this.registeredSingletons.add(beanName);
}
}
}
5.5 populateBean方法
使用populateBean方法进行属性赋值，即将bean定义中的属性值填充BeanWrapper中的bean实例中。此时如果遇到Bean A中的属性依赖Bean B这种情况，则会从尝试从缓存中获取Bean B的实例，获取不到则触发Bean B的实例化。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//包装类为空
if (bw == null) {
//mdb中存在相关属性，即bean的属性值不为空
if (mbd.hasPropertyValues()) {
//抛出异常
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
//终止当前方法、
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
//msb不是合成且存在InstantiationAwareBeanPostProcessors
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//变量beanPostProcessors
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//bp是InstantiationAwareBeanPostProcessor的实例
if (bp instanceof InstantiationAwareBeanPostProcessor) {
//转型
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
//终止属性注入
return;
}
}
}
}
//获取待注入的bean的属性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//自动装配相关
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
//resolvedAutowireMode为1或者2
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
//resolvedAutowireMode = 1,根据名称进行注入
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
// resolvedAutowireMode = 2,根据类型进行注入
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
//覆盖旧的配置
pvs = newPvs;
}
//判断InstantiationAwareBeanPostProcessors属性是否注册到工厂中
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
//是否需要检查依赖
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
//属性为空
if (pvs == null) {
//属性赋值
pvs = mbd.getPropertyValues();
}
//遍历后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//判断bp是否为InstantiationAwareBeanPostProcessor的实例
if (bp instanceof InstantiationAwareBeanPostProcessor) {
//转型
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//调用nstantiationAwareBeanPostProcessor的postProcessProperties方法
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
//过滤出所有需要进行依赖检查的属性编辑器
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
//调用nstantiationAwareBeanPostProcessor的postProcessPropertyValues方法
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
//对属性值pvs进行重新赋值
pvs = pvsToUse;
}
}
}
//依赖检查
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
//属性值不为空
if (pvs != null) {
//将pvs包含的属性值填充给BeanWrapper中的bean实例
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
//省略
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
//pvs属于MutablePropertyValues的实例
if (pvs instanceof MutablePropertyValues) {
//强制转型
mpvs = (MutablePropertyValues) pvs;
//mpvs中是包含转换中的值
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
//添加mpvs到包装类中
bw.setPropertyValues(mpvs);
//返回
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
//mpvs中的没有包含转换的值
//将mpvs中包含的属性信息赋值给original
original = mpvs.getPropertyValueList();
}
else {
//pvs不属于MutablePropertyValues的实例
//将pvs中包含的属性信息赋值给original
original = Arrays.asList(pvs.getPropertyValues());
}
//获取用户自定义类型转换器
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
//创建BeanDefinitionValueResolver解析器
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
//存放实际解析后的属性值
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
//遍历原始属性
for (PropertyValue pv : original) {
//已经转换
if (pv.isConverted()) {
//添加到deepCopy中
deepCopy.add(pv);
}
else {
//原始属性名
String propertyName = pv.getName();
//原始属性值
Object originalValue = pv.getValue();
//解析并获取实际的属性值，添加到deepCopy容器中
if (originalValue == AutowiredPropertyMarker.INSTANCE) {
Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
if (writeMethod == null) {
throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
}
originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
}
//使用解析器解析原始属性值，获取依赖的bean对象
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
//将mpvs标记为已经转换过
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
//使用deepCopy构造MutablePropertyValues对象并填充到BeanWrapper中
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
// We must check each value to see whether it requires a runtime reference
// to another bean to be resolved.
if (value instanceof RuntimeBeanReference) {
//RuntimeBeanReferences是用于属性值对象不可变的占位符类，，当它对工厂中另一个 bean存在引用时，将在运行时解析
RuntimeBeanReference ref = (RuntimeBeanReference) value;
return resolveReference(argName, ref);
}
//省略
}
//这个方法主要是解析当前Bean A中存在对另外一个Bean B的引用，如果Bean B不存在缓存中，则调用Bean B的实例化；如果Bean B存在缓存中，则直接返回
//解决了Bean之间的循环依赖
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
try {
Object bean;
//引用Bean B的类型
Class<?> beanType = ref.getBeanType();
//是否引用父工厂
if (ref.isToParent()) {
//获取父工厂
BeanFactory parent = this.beanFactory.getParentBeanFactory();
//父工厂为空
if (parent == null) {
//抛出异常，不能解析一个不可用的工厂
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot resolve reference to bean " + ref +
" in parent factory: no parent factory available");
}
//引用Bean B的类型不为空
if (beanType != null) {
//通过类型获取Bean B，如果缓存没有则触发Bean B实例化
bean = parent.getBean(beanType);
}
else {
//通过beanName从父工厂中获取Bean B，如果缓存没有则触发Bean B实例化
bean = parent.getBean(String.valueOf(doEvaluate(ref.getBeanName())));
}
}
else {
//没有引用父工厂
//通过beanType或者beanName，从工厂中获取Bean的实例
String resolvedName;
if (beanType != null) {
NamedBeanHolder<?> namedBean = this.beanFactory.resolveNamedBean(beanType);
bean = namedBean.getBeanInstance();
resolvedName = namedBean.getBeanName();
}
else {
resolvedName = String.valueOf(doEvaluate(ref.getBeanName()));
bean = this.beanFactory.getBean(resolvedName);
}
//注册依赖关系
this.beanFactory.registerDependentBean(resolvedName, this.beanName);
}
//判断是否为空Bean
if (bean instanceof NullBean) {
bean = null;
}
//完成属性填充，返回bean对象
return bean;
}
catch (BeansException ex) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
}
}
5.6 initializeBean方法
Bean的初始化
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//检测Aware相关接口并设置相关依赖
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//初始化之前，调用后置处理器的前置处理方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//调用初始化方法
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()) {
//初始化后，调用后置处理器的后置处理方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
5.7 invokeAwareMethods方法
invokeAwareMethods方法执行时间在Bean对象属性注入之后，主要作用是检查Aware相关接口并设置相关依赖
private void invokeAwareMethods(final String beanName, final Object bean) {
//判断bean对象是否实现实现Aware接口
if (bean instanceof Aware) {
//如果实现Aware接口，则进一步判断具体属于Aware的哪个子类，调用子类接口的实现
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
5.8 applyBeanPostProcessorsBeforeInitialization方法
调用Bean后置处理器的前置处理方法postProcessBeforeInitialization。
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//遍历后置处理器
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//调用后置处理器的前置处理方法
Object current = processor.postProcessBeforeInitialization(result, beanName);
//非空，直接返回
if (current == null) {
return result;
}
result = current;
}
return result;
}
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//判断bean是否属于这6中Aware子类的实例
if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
//不是，直接返回
return bean;
}
AccessControlContext acc = null;
if (System.getSecurityManager() != null) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareInterfaces(bean);
return null;
}, acc);
}
else {
//Aware接口检查
invokeAwareInterfaces(bean);
}
return bean;
}
private void invokeAwareInterfaces(Object bean) {
// 进一步判断具体属于Aware的哪个子类，调用子类接口的实现
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
5.9 invokeInitMethods方法
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
//检查bean是否实现InitializingBean接口
boolean isInitializingBean = (bean instanceof InitializingBean);
//实现InitializingBean接口 && （mbd为空 null 或者 mbd
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//调用InitializingBean接口实现类的afterPropertiesSet实现方法
((InitializingBean) bean).afterPropertiesSet();
}
}
//mbd不为空 && bean的类型不为 NullBean
if (mbd != null && bean.getClass() != NullBean.class) {
//获取初始化方法
//init-method属性中配置的名称
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
5.10 invokeCustomInitMethod方法
检查是否配置有自定义得init-method，如果有则调用初始化方法
protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd)
throws Throwable {
//获取初始化方法名称
String initMethodName = mbd.getInitMethodName();
Assert.state(initMethodName != null, "No init method set");
//通过bean得类型和方法名，获取到待执行得方法/Method
Method initMethod = (mbd.isNonPublicAccessAllowed() ?
BeanUtils.findMethod(bean.getClass(), initMethodName) :
ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
//获取不到方法
if (initMethod == null) {
//如果配置文件中已经配置该方法，则抛出异常
if (mbd.isEnforceInitMethod()) {
throw new BeanDefinitionValidationException("Could not find an init method named '" +
initMethodName + "' on bean with name '" + beanName + "'");
}
else {
if (logger.isTraceEnabled()) {
logger.trace("No default init method named '" + initMethodName +
"' found on bean with name '" + beanName + "'");
}
// Ignore non-existent default lifecycle methods.
return;
}
}
if (logger.isTraceEnabled()) {
logger.trace("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'");
}
//尝试通过自身或者父类获取接口方法
Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.makeAccessible(methodToInvoke);
return null;
});
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
methodToInvoke.invoke(bean), getAccessControlContext());
}
catch (PrivilegedActionException pae) {
InvocationTargetException ex = (InvocationTargetException) pae.getException();
throw ex.getTargetException();
}
}
else {
try {
//允许调用私有方法
ReflectionUtils.makeAccessible(methodToInvoke);
//通过反射调用初始化方法
methodToInvoke.invoke(bean);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
5.11 applyBeanPostProcessorsAfterInitialization方法
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//调用BeanPostProcessor的后置处理方法
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
5.12 registerDisposableBeanIfNecessary
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
// mdb非原型 && bean对象需要在关闭时销毁
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
//单例
if (mbd.isSingleton()) {
// Register a DisposableBean implementation that performs all destruction
// work for the given bean: DestructionAwareBeanPostProcessors,
// DisposableBean interface, custom destroy method.
//使用DisposableBean接口的实现类DisposableBeanAdapter包装需要销毁的bean对象，以beanName为键，DisposableBean为值注册到disposableBeans容器中
/
registerDisposableBean(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
else {
// A bean with a custom scope...
//非单例条件下，自定义scope处理
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));
}
}
}
protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
//bean是否为空bean && （是否拥有销毁方法 || （是否注册Destruction AwareBeanPostProcessor到工厂中 && 检查给定的bean是否有适配它的DestructionAwareBeanPostProcessor处理器）
return (bean.getClass() != NullBean.class &&
(DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() &&
DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
}
//判断当前bean是否用于销毁方法
public static boolean hasDestroyMethod(Object bean, RootBeanDefinition beanDefinition) {
//检查是否实现DisposableBean或者AutoCloseable接口
if (bean instanceof DisposableBean || bean instanceof AutoCloseable) {
return true;
}
//获取销毁方法的名称
String destroyMethodName = beanDefinition.getDestroyMethodName();
//如果销毁方法的名称等于"(inferred)"，则推测是否存在销毁方法
if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName)) {
//判断ban对象中是否存在名为close或者shutdown的方法
return (ClassUtils.hasMethod(bean.getClass(), CLOSE_METHOD_NAME) ||
ClassUtils.hasMethod(bean.getClass(), SHUTDOWN_METHOD_NAME));
}
//判断销毁方法的名称长度是否大于1，即有销毁方法
return StringUtils.hasLength(destroyMethodName);
}
private List<DestructionAwareBeanPostProcessor> beanPostProcessors;
public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
...//省略
//过滤出实现DestructionAwareBeanPostProcessor接口的后置处理器，并注册到beanPostProcessors容器中
this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
}
private List<DestructionAwareBeanPostProcessor> filterPostProcessors(List<BeanPostProcessor> processors, Object bean) {
List<DestructionAwareBeanPostProcessor> filteredPostProcessors = null;
if (!CollectionUtils.isEmpty(processors)) {
filteredPostProcessors = new ArrayList<>(processors.size());
for (BeanPostProcessor processor : processors) {
//判断是否实现DestructionAwareBeanPostProcessor接口
if (processor instanceof DestructionAwareBeanPostProcessor) {
//转型
DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
//requiresDestruction默认返回true
if (dabpp.requiresDestruction(bean)) {
//将实现DestructionAwareBeanPostProcessor接口的后置处理器添加到filteredPostProcessors
filteredPostProcessors.add(dabpp);
}
}
}
}
return filteredPostProcessors;
}
六 参考文献
1）JDK7在线文档
https://tool.oschina.net/apidocs/apidoc?api=jdk_7u4
2) JDK8在线文档
https://docs.oracle.com/javase/8/docs/api/
3）Spring Framework 5 中文文档
https://www.cntofu.com/book/95/index.html
4) Bruce Eckel. Java编程思想，第4版，2007，机械工业出版社
5）方腾飞，魏鹏，程晓明. Java并发编程的艺术，第1版，2015年，机械工业出版社
6）克雷格.沃斯. Spring实战，第5版，2020年，人民邮电出版社
扫一扫
639
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
