标签：bean mbd Spring beanName getBean Bean 链路 return null
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {
// 转换名称,主要是处理FactoryBean的&
final String beanName = transformedBeanName(name);
Object bean;
// 先从单例池中看一下有没有
// 有两种情况:
// 一: 如果存在循环依赖,这个时候单例池没有,就会立刻从三级缓存中获取缓存的数据,创建依赖的对象,并返回
// 因为在创建Bean的时候,只要支持循环依赖,就会将当前bean的实例,BD,beanName组装成函数对象存在三级缓存中,需要提前创建对象随时启动,参数已经传递了
// 二: 如果不存在循环依赖,直接就是检查单例池中是否有
Object sharedInstance = getSingleton(beanName) {
return getSingleton(beanName, true) {
// 单例池获取
Object singletonObject = this.singletonObjects.get(beanName);
// 如果单例池不存在,并且该bean正在创建中,表示出现了循环依赖
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 再获取有没有被提前创建过,但是没有执行完成的生命周期
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果支持循环依赖
if (singletonObject == null && allowEarlyReference) {
// 从三级缓存中取出需要创建对象的参数
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 创建对象,可能是代理,也可能不是
// addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
singletonObject = singletonFactory.getObject(){
getEarlyBeanReference(beanName, mbd, bean){
// 执行SmartInstantiationAwareBeanPostProcessor类型的后置处理器
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
// 回调后置处理器的getEarlyBeanReference方法
// 这个原理详见文章"SpringAop原理,获取提前引用对象以及wrapIfNecessary是否需要创建代理对象原理"
// 创建代理对象如果有需要,因为出现循环依赖,万一需要注入的bean是代理对象,那绝对不能将原始对象注入给依赖的Bean
// 所以,出现了循环依赖的情况下,该bean一定要优先判断要不要进行AOP,因为后面依赖的全是这个代理对象
// 如果不进行AOP,循环注入的就是原始对象,就有问题
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
}
// 保存到提前引用的对象map中,因为该bean还在创建中,没有执行完所有的生命周期
// 所以不能保存到单例池中
this.earlySingletonObjects.put(beanName, singletonObject);
// 创建完了对象,这个缓存就没用了
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
}
// 如果单例池中存在,并且没有过构造函数参数的情况
if (sharedInstance != null && args == null) {
// 从实例对象中获取Bean,主要是处理FactoryBean的情况,因为该Bean已经存在
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null) {
// 当前bean是否正在创建
String currentlyCreatedBean = this.currentlyCreatedBean.get();
// 如果正在创建
if (currentlyCreatedBean != null) {
// 注册Bean的依赖关系,表示那个Bean依赖那个Bean
registerDependentBean(beanName, currentlyCreatedBean) {
String canonicalName = canonicalName(beanName);
// 被依赖关系
synchronized (this.dependentBeanMap) {
Set<String> dependentBeans = this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
// 依赖关系
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean = this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
}
// 从实例对象中获取Bean
return super.getObjectForBeanInstance(beanInstance, name, beanName, mbd) {
// 是不是以&开头的BeanName,主要是做一个校验,&不能随便乱用
// 如果beanName存在&的情况下,当前获取到的实例实际上就是目标实例
if (BeanFactoryUtils.isFactoryDereference(name)) {
// 如果bean实例存在,但是beanName是以&开头,但是类型又不是FactoryBean,抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
// 如果代理的BD是FactoryBean实例,标记当前BD为factoryBean
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// 如果实例不是FactoryBean,直接返回
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
// 这里处理的是BeanName不是以&开头,但又是一个FactoryBean
// 这里处理的事作用于代理的ScopedProxyFactoryBean这种情况
Object object = null;
// 如果是代理的BD
if (mbd != null) {
// 标记BD为FactoryBean
mbd.isFactoryBean = true;
} else {
// 不是代理的BD,直接从FactoryBean创建的对象缓存中获取
object = getCachedObjectForFactoryBean(beanName);
}
// 如果缓存中没有获取到
if (object == null) {
// 获取到BD
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// 如果不是代理的BD,并且当前容器包含这个Bean
if (mbd == null && containsBeanDefinition(beanName)) {
// 获取原始Bean的BD
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 从FactoryBean获取BD
object = getObjectFromFactoryBean(factory, beanName, !synthetic) {
//调用FactoryBean的方法获取对象
object = factory.getObject();
}
}
return object;
}
}
}
// 如果单例池不存在,获取创建对象需要构造参数
else {
// 当前Bean是否是原型的Bean,并且在创建中,创建的时候,会将原型BeanName保存到prototypesCurrentlyInCreation中
if (isPrototypeCurrentlyInCreation(beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
return (curVal != null && (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}){
// 抛出异常
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取Bean工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
// 查找父容器中是否存在该Bean,逻辑和当前正在执行的逻辑一样
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 获取bean的原始名称
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return (T) parentBeanFactory.getBean(nameToLookup);
}
// 是否只是对Bean进行一些检查,而不真的实例化,默认为false,只检查类型
if (!typeCheckOnly) {
// 标记该Bean正在创建,alreadyCreated保存至少创建过一次的Bean
markBeanAsCreated(beanName) {
// 该Bean是否已经创建了
if (!this.alreadyCreated.contains(beanName)) {
synchronized (this.mergedBeanDefinitions) {
// 加锁再次校验
if (!this.alreadyCreated.contains(beanName)) {
// 删除合并的Bean定义,下次获取重新创建新的Bean定义
clearMergedBeanDefinition(beanName);
// 保存
this.alreadyCreated.add(beanName);
}
}
}
}
}
try {
// 获取合并的Bean定义
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 校验当前BD是不是抽象的,抽象的抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// 获取当前Bean依赖的Bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
// 遍历所有依赖的Bean
for (String dep : dependsOn) {
// 检查dependentBeanMap中的存储的被依赖关系,是否有标识了循环设置的BeanName
// 这个这个循环依赖只是说当前Bean必须要在依赖的Bean之前初始化,所以需要优先初始化别Bean
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()) {
// 从单例池中获取Bean,如果没有获取到,回调这个lambda,创建Bean
sharedInstance = getSingleton(beanName, () -> {
try {
// 详见下面singletonFactory.getObject()
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
// 创建失败,销毁该该Bean
destroySingleton(beanName);
throw ex;
}
}) {
synchronized (this.singletonObjects) {
// 从单例池中获取
Object singletonObject = this.singletonObjects.get(beanName);
// 如果没有获取到
if (singletonObject == null) {
// 容器中的单例Bean正在销毁中的时候,是不允许创建对象
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName);
}
// 创建之前,记录该beanName,正在创建中
beforeSingletonCreation(beanName) {
// 如果该Bean没有设置创建中不需要校验的话,就标记该Bean正在创建,保存到singletonsCurrentlyInCreation
// 如果保存失败,表示singletonsCurrentlyInCreation已经存在该bean,抛出异常
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
// 标记是否是新创建的单例对象
boolean newSingleton = false;
// 记录被压制的异常信息,也就是它用来保存异常的集合
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 回调上面传递的lambad,创建对象的函数
singletonObject = singletonFactory.getObject() {
// 创建Bean,详见当前下面方法详解
return createBean(beanName, mbd, args);
}
}
// 标记该Bena为单例的
newSingleton = true;
} catch(IllegalStateException ex){
// 可能隐式的创建的Bean对象,从单例池获取一下
singletonObject = this.singletonObjects.get(beanName);
// 如果没有,再抛出异常
if (singletonObject == null) {
throw ex;
}
} catch(BeanCreationException ex){
throw ex;
} finally{
// 最后,将正在创建中的beanName标识移除
afterSingletonCreation(beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
}
// 如果为单例
if (newSingleton) {
// 保存当前bean为单例对象
addSingleton(beanName, singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
}
return singletonObject;
} ;
// 从对象实例中获取Bean,处理FactoryBean,上面有详解
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 如果是原型的Bean,用到的时候才会创建Bean
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
// 标记当前原型Bean正在被创建
beforePrototypeCreation(beanName) {
// 获取正在创建的原型Bean
Object curVal = this.prototypesCurrentlyInCreation.get();
// 如果为空,表示当前没有原型Bean正在当前线程创建
if (curVal == null) {
this.prototypesCurrentlyInCreation.set(beanName);
}
// 如果当前线程有原型Bean正在创建
else if (curVal instanceof String) {
// 将当前bean和保存到当前线程已存在的原型Bean合在一起,存入prototypesCurrentlyInCreation中
Set<String> beanNameSet = new HashSet<>(2);
beanNameSet.add((String) curVal);
beanNameSet.add(beanName);
this.prototypesCurrentlyInCreation.set(beanNameSet);
}
// 如果正在创建的原型Bean有多个
else {
// 继续将当前Bean加入
Set<String> beanNameSet = (Set<String>) curVal;
beanNameSet.add(beanName);
}
}
// 和单例bean创建的方法是同一个,详见上面解析
prototypeInstance = createBean(beanName, mbd, args);
} finally {
// 结束之后,将当前线程保存的正在创建的BeanName移除
afterPrototypeCreation(beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
if (curVal instanceof String) {
this.prototypesCurrentlyInCreation.remove();
} else if (curVal instanceof Set) {
Set<String> beanNameSet = (Set<String>) curVal;
beanNameSet.remove(beanName);
if (beanNameSet.isEmpty()) {
this.prototypesCurrentlyInCreation.remove();
}
}
}
}
// 处理FactoryBean情况,从FactoryBean中获取对象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 其他作用域
else {
// 获取自定义的作用域名称
String scopeName = mbd.getScope();
// 从当前BeanFactory中获取自己手动注册的Sope作用域
// Web对应的Context为内部的BeanFactory注册了Web相关的三个作用域
// 如果是自己定义的作用域,则需要手动注册到BeanFactory中
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
// 获取Scope实现的get方法,传递了创建Bean的必要参数,想怎么处理就怎么处理,在get方法中作逻辑,返回一个对象就行
Object scopedInstance = scope.get(beanName, () -> {
// 和Prototype的逻辑完全一样,都是用到的时候才会创建Bean,上面有解释
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
});
// 处理FactoryBean情况,从FactoryBean中获取对象
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
} catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 如果当前获取的Bean指定了类型,但是当前bean并不是指定类型的实例
// 可能需要类型转换
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 使用类型转换服务,对bean和指定的类型进行类型转换
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
// 如果转换不成功,抛出异常
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
// 返回转换后的Bean
return convertedBean;
} catch (TypeMismatchException ex) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
// 返回处理好的Bean对象
return (T) bean;
}
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 获取当前类的BD
RootBeanDefinition mbdToUse = mbd;
// 解析bean的Class,如果存在BeanClass,直接返回,如果不存在,需要使用类加载器加载,并forname
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
// 如果之前只设置了ClassName,没设置Class
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
// 将解析的Class设置到BD中
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
// 处理方法重写 xml中配置的lookup-method,或者replaced-method
// 标识当前bean要复写那个bean中的方法
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex);
}
try {
// 执行BeanPostProcessors,类型为InstantiationAwareBeanPostProcessors
// 就是给BeanPostProcessors一个执行的机会,让它在对象实例化之前就可以返回指定的对象(指代理对象)
Object bean = resolveBeforeInstantiation(beanName, mbdToUse) {
Object bean = null;
// 当前Bean如果开启了可以在实例化之前解析就可以创建该实例对象,默认为Null,表示可以
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// 判断是否存在InstantiationAwareBeanPostProcessor
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 确定Bean的类型
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 执行InstantiationAwareBeanPostProcessor的后置处理器
// 这个实在对象实例化之前执行的方法
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)
{
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 回调postProcessBeforeInstantiation方法
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
// 如果在实例化之前就指定了返回对象,那么按照自己设定的对象返回
if (result != null) {
return result;
}
}
}
return null;
}
// 如果已经创建好了对象
if (bean != null) {
// 执行BeanPostProcessor的后置方法
// 这个实在对象实例化之后执行的方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName)
{
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 回调BeanPostProcessor的postProcessAfterInitialization
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
}
}
}
// 标记该Bean是否在初始化之前就被解析创建好了
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 真的开始实例化对象
Object beanInstance = doCreateBean(beanName, mbdToUse, args) {
// Bean的包装器,它可以给属性赋值,类型转换
BeanWrapper instanceWrapper = null;
// 如果bean是单例的
if (mbd.isSingleton()) {
// 先查看在FactoryBean中是否缓存的该Bean
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 如果没有的FactoryBean中缓存
if (instanceWrapper == null) {
// 创建一个新的BeanWrapper
instanceWrapper = createBeanInstance(beanName, mbd, args) {
// 解析Bean的Class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 校验类的public修饰符
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName);
}
// 获取一个实例的提供者,默认为null,通过它可以指定实例对象
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
// 如果存在,进行包装一下
if (instanceSupplier != null) {
// 手动创建一个instanceSupplier
return obtainFromSupplier(instanceSupplier, beanName) {
Object instance;
// 获取当前正在创建的Bean,是TheadLocal,记录者当前正在创建的Bean的BeanName
// 获取当前记录的正在创建的BeanName
String outerBean = this.currentlyCreatedBean.get();
// 设置新的
this.currentlyCreatedBean.set(beanName);
try {
// 获取给定的实例对象
instance = instanceSupplier.get();
} finally {
// 恢复上一个记录的正在创建的Bean
if (outerBean != null) {
this.currentlyCreatedBean.set(outerBean);
}
// 如果之前没有bean正在被创建,将currentlyCreatedBean清空
// 因为实例已经被创建完成了
else {
this.currentlyCreatedBean.remove();
}
}
// 如果给定了是一个空的Supplier,返回一个NullBean
if (instance == null) {
instance = new NullBean();
}
// 包装成BeanWrapperImpl对象
BeanWrapper bw = new BeanWrapperImpl(instance);
// 初始化Bean的包装器,就是初始化类型转换器
initBeanWrapper(bw) {
// 注册Spring类型转换Service
bw.setConversionService(getConversionService() {
// 执行finishBeanFactoryInitialization方法的时候,设置的
// 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));
// }
}
});
// 注册自定义的JDk类型转换器
registerCustomEditors(bw) {
PropertyEditorRegistrySupport registrySupport = (registry instanceof PropertyEditorRegistrySupport ? (PropertyEditorRegistrySupport) registry : null);
if (registrySupport != null) {
// 激活JDK转换器
registrySupport.useConfigValueEditors();
}
// 注册JDK类型转换的两种方式
if (!this.propertyEditorRegistrars.isEmpty()) {
// 使用beanFactory.addPropertyEditorRegistrar注册,@Bean是没有用的
// beanFactory.addPropertyEditorRegistrar(propertyEditorRegistrar);
for (PropertyEditorRegistrar registrar : this.propertyEditorRegistrars) {
registrar.registerCustomEditors(registry);
}
}
// @Bean是无效的
// 手动使用beanFactory.registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass)
if (!this.customEditors.isEmpty()) {
this.customEditors.forEach((requiredType, editorClass) -> registry.registerCustomEditor(requiredType, BeanUtils.instantiateClass(editorClass)));
}
// 以上两种方法,Spring提供了一个后置处理器,我们可以通过配置这个后置处理来设置地址的转换器
// class CustomEditorConfigurer implements BeanFactoryPostProcessor
// @Bean
// public CustomEditorConfigurer customEditorConfigurer() {
// CustomEditorConfigurer configurer = new CustomEditorConfigurer();
// Map<Class<?>, Class<? extends PropertyEditor>> map = new HashMap<>();
// map.put(User.class, StringToUserPropertyEditor.class);
// configurer.setCustomEditors(map);
// configurer.setPropertyEditorRegistrars(new PropertyEditorRegistrar[]{});
// return configurer;
// }
// 后置处理器postProcessBeanFactory的执行逻辑,就是处理这个
// public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
// if (this.propertyEditorRegistrars != null) {
// for (PropertyEditorRegistrar propertyEditorRegistrar : this.propertyEditorRegistrars) {
// beanFactory.addPropertyEditorRegistrar(propertyEditorRegistrar);
// }
// }
// if (this.customEditors != null) {
// this.customEditors.forEach(beanFactory::registerCustomEditor);
// }
// }
}
}
return bw;
}
}
// 如果是@Bean方法
if (mbd.getFactoryMethodName() != null) {
// 通过Bean方法实例化,详见ConstructorResolver构造方法实例化解析以及注入
return instantiateUsingFactoryMethod(beanName, mbd, args) {
return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs)
}
}
// 当前Bean是否需被解析过,缓存过
boolean resolved = false;
// 是否需要自动注入
boolean autowireNecessary = false;
// 如果没有构造参数
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 如果BD中,已经缓存了处理过的构造方法或者@Bean方法,他们逻辑一样,使用的同一个变量标记
if (mbd.resolvedConstructorOrFactoryMethod != null) {
// 标记该Bean已经被解析过
resolved = true;
// 获取构造函数参数是否需要构造注入
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 如果解析过了
if (resolved) {
// 需要构造注入的话,直接调用构造注入方法
if (autowireNecessary) {
// 实例化并注入,详见ConstructorResolver构造方法实例化解析以及注入
return autowireConstructor(beanName, mbd, null, null) {
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
}
// 不过是构造注入,那么就直接使用对应的构造方法,或者@Bean方法执行就行
else {
return instantiateBean(beanName, mbd) {
Object beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent) {
// 如果没有方法覆盖的情况,只有@Looup,或者xml中配置了方法覆盖的情况下,才不为空
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
// 是否已经缓存了构造方法或者@Bean方法,这个是缓存
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
// 如果没有缓存过
if (constructorToUse == null) {
// 获取Class
final Class<?> clazz = bd.getBeanClass();
// 获取类的默认的构造函数
constructorToUse = clazz.getDeclaredConstructor();
// 缓存起来
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
}
// 反射通过构造函数执行
return BeanUtils.instantiateClass(constructorToUse);
} else {
// 如果存在方法覆盖,使用CGLIB生成子类对象
// Must generate CGLIB subclass.
// 详见ConstructorResolver构造方法实例化解析以及注入
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
// 包装成BeanWrapper
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
// 设置类型转换器
initBeanWrapper(bw);
}
}
}
// 如果当前Bean没有被缓存,没有解析过
// 执行SmartInstantiationAwareBeanPostProcessor的确定构造方法,他会根据@Autowired的情况选择必须得构造方法
// 详见文件Autowired注解AutowiredAnnotationBeanPostProcessor原理中的determineConstructorsFromBeanPostProcessors详解
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName) {
if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
// 执行determineCandidateConstructors方法,返回可用的构造函数集合
Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
if (ctors != null) {
return ctors;
}
}
}
}
return null;
}
// 如果SmartInstantiationAwareBeanPostProcessor指定了构造方法
// 获取要求构造注入,或者设置了构造参数,或者指定了构造参数
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
// 调用构造注入方法,详见ConstructorResolver构造方法实例化解析以及注入
return autowireConstructor(beanName, mbd, ctors, args);
}
// 如果getPreferredConstructors有设置首选的构造函数
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
// 调用构造注入方法,详见ConstructorResolver构造方法实例化解析以及注入
return autowireConstructor(beanName, mbd, ctors, null);
}
// 无需特殊处理:只需使用无参数构造函数,上面有这行代码解释,创建对象,初始化BeanWrapper
return instantiateBean(beanName, mbd);
}
}
// 对象已经实例化好了
final Object bean = instanceWrapper.getWrappedInstance();
// 获取bean的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
// 如果bean的类型为NullBean,就是返回的Bean为null
// 如果不为NullBean,表示解析到正常的Bean
if (beanType != NullBean.class) {
// 缓存解析到的目标类型
mbd.resolvedTargetType = beanType;
}
// 允许后处理器修改合并的bean定义
synchronized (mbd.postProcessingLock) {
// 如果MergedBeanDefinitionPostProcessor没有被执行
if (!mbd.postProcessed) {
// 最先执行Bean实例之后的接口MergedBeanDefinitionPostProcessor一般是Spring内部使用
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
// 标记MergedBeanDefinitionPostProcessor被执行了
mbd.postProcessed = true;
}
}
// 如果单例Bena,并且正在创建中,而且还支持循环依赖
// 是否支持提前暴露对象
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
// 添加三级缓存,一个回调函数getEarlyBeanReference,因为出现循环依赖之后,可能需要提前创建对象
// 并且可能需要创建代理,所有需要将beanName,BD和bean对象都传递过去,方便创建代理对象的时候能够获取到原始对象
if (earlySingletonExposure) {
// 详见objectFactory.getObject回调
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 需要暴露的Bean
Object exposedObject = bean;
try {
// 属性注入
// instanceWrapper = bw
populateBean(beanName, mbd, instanceWrapper) {
// 如果bean没有被包装过,正常情况下,创建的经过生命周期的Bean都会被BeanWrapper包装
// 除非手动调用,传入了null
if (bw == null) {
// 判断是否在BD设置了要给对象设置属性值
// 如果设置了,但是bean没有包装,就无法属性赋值
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
// 不处理任何事情,直接结束整个属性注入过程
return;
}
// 执行InstantiationAwareBeanPostProcessors后置处理器,可以对Bean进行修改,属性设置
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
// 获取在BD中给对象设置需要注入的属性值
// mbd.getPropertyValues()不可能返回null,但是可能没有元素
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 获取解析到的注入模式
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
// 总结一下下面两种情况
// 1. ByName和ByType这两种情况只会操作BD中设置的属性
// 而这两种情况只会在XML注册Bean(或者@Bean,其实和xml是一样的道理)的时候指定了注入类型,或者手动注入BeanDefinition指定了注入类型的情况下处理
// 例如
/**
* <bean id="a" class="luck.spring.A">
* <property name="b" ref="b"/>
* </bean>
* 或者
* registry.registerBeanDefinition("a", new RootBeanDefinition(A.class, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, true));
*/
// 如果使用@Component的Bean,它默认是没有在BD中设置需要注入的属性,而是通过@Autowired声明注入,所以它就不会有这两种情况
// 而下面具体要做的事情就是,将Bean中有set方法的对象属性(不能是简单类型)进行注入,这个时候,就不关@Autowired啥事了
// 通过指定了BeanName或者类型注入的情况
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
// 将属性值包装一下,变成一个可变的属性值
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 如果是通过beanName注入
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs){
// 或者Bean中,有set方法的对象属性(不能是简单类型)
// 说白了就是准备给给定了set方法的一些属性进行赋值,哪怕是自己没有指定要注入这个属性
// 它也会自己帮你去容器中找Bean来注入
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
// 遍历所有的属性名
for (String propertyName : propertyNames) {
// 如果当前属性名存在Bean
if (containsBean(propertyName)) {
// 从Spring容器中获取Bean
Object bean = getBean(propertyName);
// 先保存到pvs中,因为pvs中的属性键值对才是真正需要注入的属性
pvs.add(propertyName, bean);
// 维护Bean的依赖关系
registerDependentBean(propertyName, beanName);
}
}
}
}
// 通过类型注入
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs){
// 获取自定义的类型转换器
TypeConverter converter = getCustomTypeConverter();
// 如果没有自定义的类型转换器
if (converter == null) {
// 直接是有Bean包装类进行转换
converter = bw;
}
// 需要注入的beanName集合
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
// 或者Bean中,有set方法的对象属性(不能是简单类型)
// 说白了就是准备给给定了set方法的一些属性进行赋值,哪怕是自己没有指定要注入这个属性
// 它也会自己帮你去容器中找Bean来注入
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
// 获取所有的属性名
for (String propertyName : propertyNames) {
// 获取可以操作当前属性的类
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// 如果属性类型不是Object
if (Object.class != pd.getPropertyType()) {
// 获取set方法的参数
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// 判断该类是否需要立即初始化
boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
// 将所有依赖信息封装成DependencyDescriptor,它保存了set方法参数的所有信息
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
// 解析需要注入的参数,并将注入的BeanName保存
// 详见@Autowired,@Resource,@Value注入的核心逻辑原理
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
// 如果解析到了
if (autowiredArgument != null) {
// 先保存到pvs中,因为pvs中的属性键值对才是真正需要注入的属性
pvs.add(propertyName, autowiredArgument);
}
// 遍历所有依赖注入的BeanName
for (String autowiredBeanName : autowiredBeanNames) {
// 注册依赖关系
registerDependentBean(autowiredBeanName, beanName);
}
// 清空当前属性的注入信息
autowiredBeanNames.clear();
}
}
}
}
// 将注入的属性值返回给pvs
// 因为上面可能对ByName,ByType处理了特殊情况,就是某个Bean有setXXX方法,但是没有指明要注入这个XXX的情况
// Spring也会处理这种情况,即使没有添加@Autowired
pvs = newPvs;
}
// 是否存在InstantiationAwareBeanPostProcessor类型的处理器
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 判断是否需要依赖进行校验
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
// 获取属性操作的抽象对象
PropertyDescriptor[] filteredPds = null;
// 如果存在InstantiationAwareBeanPostProcessor,因为它提供了操作属性的后置方法
if (hasInstAwareBpps) {
// 如果为null,表示自己没有在BD中设置需要注入的属性,说白了就是没有手动操作BeanDefinition,而是直接被扫描的类的BD
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 遍历所有的InstantiationAwareBeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 回调postProcessProperties操作属性的方法,将需要注入的属性键值对集合对象已经实例对象都给了
// 可以由我们自己手动控制
// AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor注入都是这个方法处理
// 详见AutowiredAnnotationBeanPostProcessor原理,CommonAnnotationBeanPostProcessor原理
// 这个方法会调用 value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);解析这个Bean
// 然后注入
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
// 如果返回null,表示pvs之前就为空,没有手动设置,并且InstantiationAwareBeanPostProcessor后置处理器也没有处理
if (pvsToUse == null) {
// 默认是空的
if (filteredPds == null) {
// 过滤出可以被注入的属性对应的操作类
// 因为不是所有的属性都能注入,比如设置了A接口,或者B类,不能参数属性注入,这个时候就会排除
// 剩余的其他属性都能被注入
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 再次执行postProcessPropertyValues方法
// 因为filteredPds[]存入的是Bean对应的所有属性的操作
// 而pvs内部存入是手动设置的要注入的属性键值对,并且也是最终需要注入的属性键值对集合
// 所以,这个方法可以用来处理一些注入校验的操作
// 例如,某个属性是必须注入的,filteredPds中存在,但是pvs不存在,这个时候就可以报错了
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
// 如果还是没有属性需要注入,那么整个注入流程结束
if (pvsToUse == null) {
return;
}
}
// 将后置处理器处理之后的属性键值对返回出去
pvs = pvsToUse;
}
}
}
// 如果需要对注入的属性进行校验
if (needsDepCheck) {
// 过滤出可以被注入的属性对应的操作类
// 因为不是所有的属性都能注入,比如设置了A接口,或者B类,不能参数属性注入,这个时候就会排除
// 剩余的其他属性都能被注入
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 校验依赖,就是在所有的可以被注入的属性中,如果属性存在Set方法,就明确表示要注入
// 如果在pvs中,也就是真实需要注入的集合中不存在这个明确表示要注入的属性的时候,就要报错
checkDependencies(beanName, mbd, filteredPds, pvs);
}
// 如果存在需要注入的属性值
// 注入注解的情况下,在后置处理器postProcessProperties已经处理好了
// 这里只是处理单独对Bean设置了ByName,ByType的注入方式进行注入,以及在postProcessProperties回调中,扩展了pvs
// 所以还要对扩展的pvs进行注入
// 说白了,使用注入注入的情况,pvs是一个空的,只有在上面描述的三种情况下,才需要执行下面逻辑
if (pvs != null) {
// 进行属性注入
applyPropertyValues(beanName, mbd, bw, pvs){
List<PropertyValue> original;
// 获取到设置的注入属性的键值对集合
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
original = mpvs.getPropertyValueList();
}else{
original = Arrays.asList(pvs.getPropertyValues());
}
for (PropertyValue pv : original) {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
// 解析当前值,因为xml中可以配置ref,占位符,注解@Value也可以使用占位符,就需要解析到实际的值
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
// 解析到了值可能还需要类型转换,最终才能得到想要的值
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
// 将转换后的值保存到pv中
pv.setConvertedValue(convertedValue);
}
// 就是将pvs存储的键值对设置到属性中,可能是通过字段,也可能通过set方法
// 有多种不同的实现
bw.setPropertyValues(new MutablePropertyValues(original));
}
}
}
// 实例化Bean,执行Bean的生命周期方法
exposedObject = initializeBean(beanName, exposedObject, mbd) {
// 执行一些Aware回调接口
invokeAwareMethods(beanName, bean) {
if (bean instanceof 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);
}
}
}
// 执行需要在执行初始化方法之前调用的BeanPostProcessors
// @PostConstruct注解就是在这里处理的
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName) {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
// 执行@Bean的初始化方法
invokeInitMethods(beanName, wrappedBean, mbd) {
boolean isInitializingBean = (bean instanceof InitializingBean);
((InitializingBean) bean).afterPropertiesSet();
// 获取@Bean的初始化方法
String initMethodName = mbd.getInitMethodName();
// 执行自定义的init-method
if (StringUtils.hasLength(initMethodName) && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
// 反射执行方法
invokeCustomInitMethod(beanName, bean, mbd);
}
}
// 非循环依赖提前需要引用的对象也是在这里处理的
// 这里是Bean初始化之后执行的后置处理器
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
// 如果支持提前暴露对象
if (earlySingletonExposure) {
// 只从单例池或者提前引用的BeanMap中获取是否存在该Bean
Object earlySingletonReference = getSingleton(beanName, false);
// 如果存在
if (earlySingletonReference != null) {
// 那么earlySingletonReference这个bean才是需要对外暴露的bean
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
// allowRawInjectionDespiteWrapping: 仅将原始Bean对象对外暴露,这样代理对象对象不可用,默认为false
// 并且当前Bean被其他Bean依赖了
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// 那些Bean依赖于该Bean
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
// 遍历所有的依赖当前Bean的Bean
for (String dependentBean : dependentBeans) {
// 因为在创建Bean之前,就会在alreadyCreated保存beanName
// 现在创建完了,需要移除这个标记
// 如果移除成功,返回true,否则返会false
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
// 如果上面标记的bean没有删除成功,抛出异常
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
}
}
registerDisposableBeanIfNecessary(beanName, bean, mbd) {
// 如果不是原型的Bean
if (!mbd.isPrototype() && requiresDestruction(bean, mbd) {
return (bean.getClass() != NullBean.class
// 是否存在销毁方法,例如DisposableBean,AutoCloseabl
// 如果是(inferred)这种,表示推断出来的方法,例如lambda,有close,或者shutdown的方法
&& (DisposableBeanAdapter.hasDestroyMethod(bean, mbd)
// 获取存在DestructionAwareBeanPostProcessor并且requiresDestruction返回true,默认为true
|| (hasDestructionAwareBeanPostProcessors()
&& DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
}){
if (mbd.isSingleton()) {
// 将这些DisposableBean单独保存起来,到时候方便执行
registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
} else {
// 具有自定义作用域的bean,Web作用域
Scope scope = this.scopes.get(mbd.getScope());
// 保存到具体的map中,销毁的时候获取执行
scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
}
}
// 返回需要暴露的Bean
return exposedObject;
}
return beanInstance;
} catch(BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
} catch(Throwable ex){
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
标签：bean,
mbd,
Spring,
beanName,
getBean,
Bean,
链路,
return,
null
From： https://blog.csdn.net/JavaMyDream/article/details/136924349