主要就是介绍了getBean（）以及doGetBean（）方法
我们已经从ioc容器的系列表中可以了解到：BeanDefinition数据的载入以及分析，以及注册等等，以及从前面来说标志一个Ioc容器完成初始化的事情就是BeanDefinition的注册事件，其实在Ioc容器完成初始化的一整个过程中，都只是完成BeanDefinition的数据映射功能呢，并没有将Bean的依赖关系注入Ioc容器中去，同时也是没有将Bean的依赖关系注入Ioc容器中去
依赖注入触发的时机：第一种：就是ioc容器索要Bean时触发的。
第二种：就是当控制BeanDefinition的lazy-init属性让容器完成对Bean的预实例化
这两者最大的区别：就是索要bean是在Ioc容器初始化之后才进行的，但是控制BeanDefinition的lazy-init属性是ioc容器初始化过程中完成的
具体的方法标志着ioc容器依赖注入的开始-BeanFactory接口中的getBean（）方法
下面就是具体的分析getBean（）源码
//可以看见getBean（）方法位于AbstractBeanFactory类
//在getBean（）方法中就是调用了doGetBean（）方法
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return this.doGetBean(name, requiredType, (Object[])null, false);
}
下面解析doGetBean（）方法中的源码
//这里是实际获取到bean对象的方法所在
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
String beanName = this.transformedBeanName(name);
//从缓存中获取到Bean，处理那些已经被创建过的单件模式的bean，有点类似于从Redis中取数据
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//这里取得结果就是FactoryBean的生产结果
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//这是从BeanFactory容器中去查看是否存在bean进行检查，如果当前BeanFactory中并存在，那么就往双亲工厂中去查找
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return parentBeanFactory.getBean(nameToLookup);
}
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
try {
//创建BeanDefintion对象的地方
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
//获取Bean的所有的依赖对象
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dep = var11[var13];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//注册依赖的Bean对象，根据dep以及beanName两个属性
this.registerDependentBean(dep, beanName);
try {
//getBean方法的递归调用
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var24) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
}
}
}
//这里是通过判断创建出的BeanDefintion是否为Singleton类型，如果是将调用getSingleton方法根据beanName获取到对象
if (mbd.isSingleton()) {
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
//在这里是根据BeanName进行摧毁
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
//在这里是调用了createBean方法进行创建bean对象
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
//获取到Scope属性的值
String scopeName = mbd.getScope();
Scope scope = (Scope)this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
this.beforePrototypeCreation(beanName);
Object var4;
try {
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var23) {
throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
}
}
} catch (BeansException var26) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var26;
}
}
//在这里是对Bean类型进行校验，如果没有问题就返回新创建的bean，这个bean是已经包含了依赖关系的bean
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
} else {
return convertedBean;
}
} catch (TypeMismatchException var25) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
} else {
return bean;
}
}
以上就是doGetBean方法的源码解析了，这也是相当于是依赖注入的入口，在这里触发依赖注入，发生的前提就是BeanDefintion已经建立好
