前言
在上篇中，我们已经了解了Spring是如何读取我们配置的xml文件并把它转化为BeanDefinition对象并保存到容器中的。在BeanDefinition中保存了Bean的所有信息，有了它实例化Bean就变得轻而易举了。在本篇，我们会了解到Spring是如何根据BeanDefinition(以下简称bd)把bean实例化并返回给我们使用的。
正文
首先来到AbstractApplicationContext类中
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
this.prepareRefresh();
//在上篇中，我们通过该方法完成了bd的注册
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
this.prepareBeanFactory(beanFactory);
try {
this.postProcessBeanFactory(beanFactory);
this.invokeBeanFactoryPostProcessors(beanFactory);
this.registerBeanPostProcessors(beanFactory);
this.initMessageSource();
this.initApplicationEventMulticaster();
this.onRefresh();
this.registerListeners();
//以上都是都是在注册各种组件并对beanFactory做一些前置操作
//下面这个是我们需要研究的方法
this.finishBeanFactoryInitialization(beanFactory);
this.finishRefresh();
} catch (BeansException var9) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
}
this.destroyBeans();
this.cancelRefresh(var9);
throw var9;
} finally {
this.resetCommonCaches();
}
}
}
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//与类转换相关的逻辑，暂不过多解释
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
//解释器模式，解析Spring表达式
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);
});
}
//编制者，似乎与AOP相关，这里先不研究
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
String[] var3 = weaverAwareNames;
//省略aspectj相关的部分代码....
beanFactory.setTempClassLoader((ClassLoader)null);
beanFactory.freezeConfiguration();
//预实例化单例bean
beanFactory.preInstantiateSingletons();
}
来到DefaultListableBeanFactory类，即在上篇所提到的图纸工厂类
public void preInstantiateSingletons() throws BeansException {
//首先获取bd的所有名字，并用迭代器遍历
List<String> beanNames = new ArrayList(this.beanDefinitionNames);
Iterator var2 = beanNames.iterator();
//非抽象，非懒加载，且为单例的bean执行该循坏
while(true) {
String beanName;
Object bean;
do {
while(true) {
RootBeanDefinition bd;
do {
do {
do {
if (!var2.hasNext()) {
var2 = beanNames.iterator();
while(var2.hasNext()) {
beanName = (String)var2.next();
Object singletonInstance = this.getSingleton(beanName);
//该实例对象是否该SmartInitializingSingleton的实例
//我们可以手动实现该实例，来对bean进行一些操作，这里不过多讨论
if (singletonInstance instanceof SmartInitializingSingleton) {
//省略...
}
}
}
return;
}
//此时bdNames的size为1即person，beanName为person
beanName = (String)var2.next();
//这里通过beanName获得了包装后的bean对象
bd = this.getMergedLocalBeanDefinition(beanName);
} while(bd.isAbstract());
} while(!bd.isSingleton());
} while(bd.isLazyInit());
//是否是工厂Bean，即是否实现类BeanFactory接口，若实现了则走另一套逻辑(实际上就是通过反射获得你实现的getObject()方法)
//我们这里显然没有实现
if (this.isFactoryBean(beanName)) {
bean = this.getBean("&" + beanName);
break;
}
//普通Bean，通过该方法获取
this.getBean(beanName);
}
} while(!(bean instanceof FactoryBean));
FactoryBean<?> factory = (FactoryBean)bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = (Boolean)AccessController.doPrivileged(() -> {
return ((SmartFactoryBean)factory).isEagerInit();
}, this.getAccessControlContext());
} else {
isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
}
if (isEagerInit) {
this.getBean(beanName);
}
}
}
来到AbstractBeanFactory类
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
//转换bean名称，即若以&开头，则将&去除
String beanName = this.transformedBeanName(name);
//尝试从容器中获取Bean实例
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if (sharedInstance != null && args == null) {
//第一次创建，我们这里显然获取不到bean实例，这部分代码省略....
} else {
//是否正在创建Bean，存在循环引用时会抛出该异常
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//获取父工厂，这里获取不到
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
//省略部分逻辑....
}
//这里是将正在创建的Bean放入一个Set中，防止别的线程重复创建
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
try {
//获取包装后的Bean定义信息
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
//检查Bean是否为抽象类，是则抛出异常
this.checkMergedBeanDefinition(mbd, beanName, args);
//获取依赖对象的名字，这里为空
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
//省略这部分逻辑....
}
}
//是否为单例
if (mbd.isSingleton()) {
//得到单例bean实例
//从方法签名我们可以知道，第二个参数是singletonFactory的实现
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else {
//其他情况，这里暂不讨论....
}
}
//requriedType为null，这是调用该方式时传的参数的默认值
if (requiredType != null && !requiredType.isInstance(bean)) {
//省略...
} else {
return bean;
}
}
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized(this.singletonObjects) {
//从单例池中获取Bean，第一次创建显然无法获取到
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//当前对象是否正在被销毁
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction (Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
//省略部分打印日志相关代码....
//检查目前Bean是否正在被创建或被排除，也是防止循环依赖的机制
this.beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = this.suppressedExceptions == null;
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet();
}
try {
//调用getObject()方法，即上面的lambda表达式
/**
() -> {
try {
//调用创建Bean方法
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
})
*/
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException var16) {
} catch (BeanCreationException var17) {
}
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
this.afterSingletonCreation(beanName);
}
if (newSingleton) {
this.addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
来到AbstractAutowireCapableBeanFactory类，它为AbstrcatBeanFactory的子类
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
//获取bd信息
RootBeanDefinition mbdToUse = mbd;
//获取类对象
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//包装，向bd中填入类信息
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
//准备方法覆盖，重现指定方法，显然我们这里没有需要重写的方法
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var10) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var10);
}
Object beanInstance;
try {
//利用后置增强器来实例化Bean，目前暂且不用考虑
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var11) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var11);
}
try {
//真正创建对象的方法
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException var7) {
//省略部分处理异常的代码...
}
}
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//因为我们要创建对象，所有要先从缓存中移除它
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
//初次创建，缓存中显然获取不到对象
if (instanceWrapper == null) {
//创建Bean对象
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
//后面这些代码暂失不做解读，待我们实例化Bean后再回头来看
/**
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//后置处理器增强
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
this.populateBean(beanName, mbd, instanceWrapper);
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
*/
}
//创建Bean的方法
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
//获取Bean的Class
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
//检查权限
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());
} else {
//是否有提供器，若有，则直接通过提供器获取
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return this.obtainFromSupplier(instanceSupplier, beanName);
//是否有工厂方法，我们显然没有配置
} else if (mbd.getFactoryMethodName() != null) {
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
//普通Bean的创建
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized(mbd.constructorArgumentLock) {
//是否有解析方法或工厂方法，若有则通过这些方法进行实例化
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
//没有则走这个逻辑
//依旧是通过后置处理器获取构造函数，我们这里没有配置后置处理器所以ctors为null
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
//ResolvedAutowireMode()共有4中模式
//0 默认情通过注解或手动注入
//1 set方法 通过Name进行注入
//2 set方法 通过类型进行注入
//3 通过构造函数进行注入
//这里我们没有配置相关的参数，所以autowiredMode = 0,且此时args也为null(传入时的默认值)
//所以进入this.instantiateBean(beanName, mbd)方法
return ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args) ? this.instantiateBean(beanName, mbd) : this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
}
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(() -> {
return thisx.getInstantiationStrategy().instantiate(mbd, beanName, this);
}, this.getAccessControlContext());
} else {
//策略模式 在此初始化bean
beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
this.initBeanWrapper(bw);
return bw;
} catch (Throwable var6) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var6);
}
}
来到SimpleInstantiationStrategy类
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
//是否有方法重写
if (!bd.hasMethodOverrides()) {
Constructor constructorToUse;
synchronized(bd.constructorArgumentLock) {
//依旧是先查看是否有工厂方法，如果有直接在这里得到构造器
constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
//获取类对象
Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
//如果是接口，则抛出异常
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
//依旧是安全相关
if (System.getSecurityManager() != null) {
constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
return clazz.getDeclaredConstructor();
});
} else {
//获取了类的构造方法
constructorToUse = clazz.getDeclaredConstructor();
}
//将其放入bd中
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable var9) {
throw new BeanInstantiationException(clazz, "No default constructor found", var9);
}
}
}
//在这里调用构造方法返回方法实例
return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
} else {
return this.instantiateWithMethodInjection(bd, beanName, owner);
}
}
//这是BeanUtil中的方法
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
//开启暴力反射
ReflectionUtils.makeAccessible(ctor);
//如果是kotlin类型，使用kotlin的委托者来实例化bean
//若不是，则通过Java反射来获得类
return KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ? BeanUtils.KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args);
} catch (InstantiationException var3) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", var3);
} catch (IllegalAccessException var4) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", var4);
} catch (IllegalArgumentException var5) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", var5);
} catch (InvocationTargetException var6) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", var6.getTargetException());
}
}
通过层层调用，终于使用了我们写的构造方法来创建对象。
继续来看看获得了Bean对象后，Spring是怎么将结果返回给我们的
回到AbstractAutowireCapableBeanFactory类的instantiateBean方法
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
} else {
//我们已经获得了该Bean的实例
beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
}
//包装一下
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
//初始化BeanWrapper，将bw注册进一个自定义编辑器，本人也不清楚是干什么的
//不过不影响整体流程
this.initBeanWrapper(bw);
return bw;
} catch (Throwable var6) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var6);
}
}
回到AbstractAutowireCapableBeanFactory类的doCreateBean方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
//省略...
//我们在这里获得了bean实例对象
Object bean = instanceWrapper.getWrappedInstance();
//获取bean类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
//设置进bd中
mbd.resolvedTargetType = beanType;
}
synchronized(mbd.postProcessingLock) {
//是否被后置处理过，若为处理，则进行后置处理
//我们可以实现MergedBeanDefinitionPostProcessor接口，来在此时对bean进行一些处理
if (!mbd.postProcessed) {
try {
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
//标记以下
mbd.postProcessed = true;
}
}
//判断是否需要在这个时刻暴露该单例对象，与循环依赖相关
//条件是:为单例Bean&&允许循环依赖&&正在创建该单例Bean
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
//放入单例Bean工厂中()
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
//在这个方法中进行依赖注入，这里不多做展开
this.populateBean(beanName, mbd, instanceWrapper);
//调用后置处理器做一些事情，这里不多做展开
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
//省略异常捕获的部分代码....
}
if (earlySingletonExposure) {
//从bean工厂中获取bean实例，这里我们已经对bean进行依赖注入，所以在第三级缓冲中
//的bean应该已经被移除，所以这里获取的是null
/**
这里的getSingleton方法与解决循环依赖息息相关
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//一级缓存 单例池
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
synchronized(this.singletonObjects) {
//二级缓存，保存了提前暴露的未进行属性注入的Bean
singletonObject =
this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
//三级缓存，保存的是BeanName与对应创建Bean方法的lambda表达式
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
*/
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
//省略这部分代码....
}
try {
//将Bean注册进可丢弃工厂中，当工厂关闭时，调用其销毁方法
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
//返回依赖注入完成后的bean对象
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
//省略前面已经1分析过的代码....
try {
//获取了Bean实例
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Finished creating instance of bean '" + beanName + "'");
}
//返回
return beanInstance;
} catch (BeanCreationException var7) {
//省略异常处理方法
throw var7;
}
}
来到AbstrcatBeanFacotry的方法
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
if (mbd.isSingleton()) {
sharedInstance = this.getSingleton(beanName, () -> {
try {
//在此处返回
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//非单例类型的bean的处理逻辑，省略....
来到DefaultSingletonBeanRegistry类的getSingleton方法
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
//省略
try {
//在这里获取到了Bean
singletonObject = singletonFactory.getObject();
//将该标志设置为true，标识bean'是刚创建的
newSingleton = true;
} catch (IllegalStateException var16) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw var16;
}
} catch (BeanCreationException var17) {
//异常处理，省略....
}
//后置处理Bean，检查该Bean是否被排除创建
this.afterSingletonCreation(beanName);
}
if (newSingleton) {
//将Bean加入单例池中
this.addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
来到AbstratBeanFactory中的doGetBean方法
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
if (mbd.isSingleton()) {
//目前在这里
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
//再次调取，主要是检查该Bean是否为工厂Bean等。
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
//非单例的情况
}
if (requiredType != null && !requiredType.isInstance(bean)) {
} else {
//返回
return bean;
}
}
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
DefaultlistableBeanFactory类的preInstantiateSingletons方法在执行完getBean方法后继续遍历来实例化/获取下一个Bean，直到容器中没有再需要创建的Bean执行结束
同样的AbstractApplicationContext的finishBeanFactoryInitialization方法也执行结束，此时IoC容器才真正初始化完成，当我们需要获取容器中的对象时，只需调用getbean方法从SingletonObjects中获取即可
扫一扫
241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
