相关源码注释
ApplicationContext
Spring 5 DefaultResourceLoader 源码注释
Spring 5 AbstractApplicationContext 源码注释
BeanFactory
Spring 5 SimpleAliasRegistry 源码注释
Spring 5 DefaultSingletonBeanRegistry 源码注释
Spring 5 FactoryBeanRegistrySupport 源码注释
Spring 5 AbstractBeanFactory 源码注释
Spring 5 AbstractAutowireCapableBeanFactory 源码注释
Spring 5 DefaultLisbaleBeanFactory 源码注释
initializeBean(String , Object , RootBeanDefinition )
初始化给定的Bean实例，应用工厂回调以及init方法和BeanPostProcessors
/**
* Initialize the given bean instance, applying factory callbacks
* as well as init methods and bean post processors.
* <p>初始化给定的Bean实例，应用工厂回调以及init方法和BeanPostProcessors</p>
* <p>Called from {@link #createBean} for traditionally defined beans,
* and from {@link #initializeBean} for existing bean instances.
* <p>对于传统定义的Bean，从createBean调用；对于现有的Bean实例，从initalizeBean调用</p>
* @param beanName the bean name in the factory (for debugging purposes)
* -- 工厂中的Bean名称（用于调试）
* @param bean the new bean instance we may need to initialize
* -- 我们可能需要初始化的新Bean实例
* @param mbd the bean definition that the bean was created with
* (can also be {@code null}, if given an existing bean instance)
* -- 创建Bean时使用的BeanDefinition（如果给定现有的Bean实例，也可以为null）
* @return the initialized bean instance (potentially wrapped)
* -- 初始化的Bean实例（可能已包装）
* @see BeanNameAware
* @see BeanClassLoaderAware
* @see BeanFactoryAware
* @see #applyBeanPostProcessorsBeforeInitialization
* @see #invokeInitMethods
* @see #applyBeanPostProcessorsAfterInitialization
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
//如果安全管理器不为null
if (System.getSecurityManager() != null) {
//以特权的方式执行 回调 bean 中 Aware接口 方法
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//回调 bean 中 Aware接口 方法
invokeAwareMethods(beanName, bean);
}
//初始化 包装后的Bean 为 bean
Object wrappedBean = bean;
//如果mdb不为null || mbd不是"synthetic"。一般是指只有AOP相关的prointCut配置或者Advice配置才会将 synthetic设置为true
if (mbd == null || !mbd.isSynthetic()) {
//将BeanPostProcessors应用到给定的现有Bean实例，调用它们的postProcessBeforeInitialization初始化 方法。
// -- 返回的Bean实例可能是原始Bean包装器
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//调用初始化方法，先调用bean的InitializingBean接口方法，后调用bean的自定义初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
//捕捉调用初始化方法时抛出的异常，重新抛出Bean创建异常：调用初始化方法失败
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
//如果mbd为null || mbd不是"synthetic"。一般是指只有AOP相关的prointCut配置或者Advice配置才会将 synthetic设置为true
if (mbd == null || !mbd.isSynthetic()) {
//将BeanPostProcessors应用到给定的现有Bean实例，调用它们的postProcessAfterInitialization方法。
// -- 返回的Bean实例可能是原始Bean包装器
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
//返回包装后的Bean
return wrappedBean;
}
invokeAwareMethods(beanName, bean);
回调 bean 中 Aware接口 方法
/**
* 回调 bean 中 Aware接口 方法
* @param beanName bean名
* @param bean 当前Bean对象
*/
private void invokeAwareMethods(final String beanName, final Object bean) {
//如果 bean 是 Aware 实例
if (bean instanceof Aware) {
//如果bean是BeanNameAware实例
if (bean instanceof BeanNameAware) {
//调用 bean 的setBeanName方法
((BeanNameAware) bean).setBeanName(beanName);
}
//如果bean是 BeanClassLoaderAware 实例
if (bean instanceof BeanClassLoaderAware) {
//获取此工厂的类加载器以加载Bean类(即使无法使用系统ClassLoader,也只能为null)
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
//调用 bean 的 setBeanClassLoader 方法
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
//如果bean是 BeanFactoryAware 实例
if (bean instanceof BeanFactoryAware) {
//调用 bean 的 setBeanFactory 方法。
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
将BeanPostProcessors应用到给定的现有Bean实例，调用它们的postProcessBeforeInitialization初始化 方法。返回的Bean实例可能是原始Bean包装实例。
applyBeanPostProcessorsBeforeInitialization 是 AutowireCapableBeanFactory 的抽象方法，由 AbstractAutowireCapableBeanFactory 实现具体逻辑。
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
//初始化返回结果为existingBean
Object result = existingBean;
//遍历 该工厂创建的bean的BeanPostProcessors列表
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//postProcessBeforeInitialization：在任何Bean初始化回调之前(如初始化Bean的afterPropertiesSet或自定义的init方法)
// 将此BeanPostProcessor 应用到给定的新Bean实例。Bean已经填充了属性值。返回的Bean实例可能时原始Bean的包装器。
// 默认实现按原样返回给定的 Bean
Object current = processor.postProcessBeforeInitialization(result, beanName);
// 如果 current为null
if (current == null) {
//直接返回result，中断其后续的BeanPostProcessor处理
return result;
}
//让result引用processor的返回结果,使其经过所有BeanPostProcess对象的后置处理的层层包装
result = current;
}
//返回经过所有BeanPostProcess对象的后置处理的层层包装后的result
return result;
}
invokeInitMethods(beanName, wrappedBean, mbd);
调用初始化方法，先调用bean的InitializingBean接口方法，后调用bean的自定义初始化方法
/**
* <p>调用初始化方法，先调用bean的InitializingBean接口方法，后调用bean的自定义初始化方法</p>
* Give a bean a chance to react now all its properties are set,
* and a chance to know about its owning bean factory (this object).
* This means checking whether the bean implements InitializingBean or defines
* a custom init method, and invoking the necessary callback(s) if it does.
* <p>现在让Bean有机会对它所有的属性进行反应，并有机会了解它所拥有的Bean工厂（这个对象）。
* 这意味着检查Bean是否实现了InitalizingBean或定义了一个自定以init方法，如果实现了，则
* 调用必要的回调</p>
* @param beanName the bean name in the factory (for debugging purposes)
* -- 工厂中的Bean名(用于调试)
* @param bean the new bean instance we may need to initialize
* -- 我们可能需要初始化的新Bean实例
* @param mbd the merged bean definition that the bean was created with
* (can also be {@code null}, if given an existing bean instance)
* -- 创建Bean时使用的合并BeanDefinition(如果给定现有Bean实例，也可以为null)
* @throws Throwable if thrown by init methods or by the invocation process
* -- 如果由init方法或调用进程抛出
* @see #invokeCustomInitMethod
*/
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
//InitialziingBean:当Bean的所有属性都被BeanFactory设置好后，Bean需要执行相应的接口：例如执行自定义 初始化，或者仅仅是检查所有强制属性是否已经设置好。
//bean是InitializingBean实例标记
boolean isInitializingBean = (bean instanceof InitializingBean);
//isExternallyManagedInitMethod是否外部受管理的Init方法名
//如果 bean是InitializingBean实例 && (mdb为null || 'afterPropertiesSet' 不是外部受管理的Init方法名)
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
//如果是日志级别为跟踪模式
if (logger.isTraceEnabled()) {
//跟踪日志：在具体名称的Bean上调用 afterPrpertiesSet()
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
//如果安全管理器不为null
if (System.getSecurityManager() != null) {
try {
//以特权方式调用 bean的 afterPropertiesSet 方法
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//调用 bean的 afterPropertiesSet 方法
((InitializingBean) bean).afterPropertiesSet();
}
}
//如果mbd不为null && bean不是 NullBean类
if (mbd != null && bean.getClass() != NullBean.class) {
//获取mbd指定的初始化方法名
String initMethodName = mbd.getInitMethodName();
//如果initMethodName不为null && (bean不是InitializingBean实例 && 'afterPropertiesSet'是初始化方法名）
// && initMethodName不是外部受管理的Init方法名
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
//在bean上调用指定的自定义init方法
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
对 existingBean 进行初始化后的后处理:
- 初始化结果对象为result,默认引用existingBean
- 遍历该工厂创建的bean的BeanPostProcessors列表:
- 回调BeanPostProcessor#postProcessAfterInitialization来对result进行包装【变量 current】
- 如果current为null,直接返回result，中断其后续的BeanPostProcessor处理
- 让result引用current,使其经过所有BeanPostProcess对象的后置处理的层层包装
- 返回经过所有BeanPostProcess对象的后置处理的层层包装后的result
/**
* 对 existingBean 进行初始化后的后处理
* @param existingBean the existing bean instance -- 现有的bean实例
* @param beanName the name of the bean, to be passed to it if necessary
* (only passed to {@link BeanPostProcessor BeanPostProcessors};
* can follow the {@link #ORIGINAL_INSTANCE_SUFFIX} convention in order to
* enforce the given instance to be returned, i.e. no proxies etc)
* Bean名称，必要时将传递给它(仅传递给BeanPostProcessor;可以遵循ORIGINAL_INSTANCE_SUFFIX
* 约定以强制返回给定的实例,即没有代理等)
* @return
* @throws BeansException
*/
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
//初始化结果对象为result，默认引用existingBean
Object result = existingBean;
//遍历该工厂创建的bean的BeanPostProcessors列表
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//回调BeanPostProcessor#postProcessAfterInitialization来对现有的bean实例进行包装
Object current = processor.postProcessAfterInitialization(result, beanName);
//一般processor对不感兴趣的bean会回调直接返回result，使其能继续回调后续的BeanPostProcessor；
// 但有些processor会返回null来中断其后续的BeanPostProcessor
//如果current为null
if (current == null) {
//直接返回result，中断其后续的BeanPostProcessor处理
return result;
}
//让result引用processor的返回结果,使其经过所有BeanPostProcess对象的后置处理的层层包装
result = current;
}
//返回经过所有BeanPostProcess对象的后置处理的层层包装后的result
return result;
}
扫一扫
285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
