getBean() 方法是顶层接口 BeanFactory 提供的，一共五个原型。AbstractBeanFactory作为抽象实现，复写了其中3个方法，
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@Override
public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
// 备注：此处的doGetBean，就是Bean实例化的核心逻辑
DefaultListableBeanFactory继承自 AbstractBeanFactory，复写了剩余的2个方法：
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
return getBean(requiredType, (Object[]) null);
}
// 上面那个方法是调用这个方法的逻辑。
@Override
public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {]
// resolveNamedBean里面的逻辑，也是根据requiredType去找的。若不止一个会抛错：NoUniqueBeanDefinitionException
NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args);
if (namedBean != null) {
return namedBean.getBeanInstance();
}
// 从这里我们可以看到，如果子容器里没有找到Bean，还回去父容器（若存在的话）里找找看
BeanFactory parent = getParentBeanFactory();
if (parent != null) {
return (args != null ? parent.getBean(requiredType, args) : parent.getBean(requiredType));
}
throw new NoSuchBeanDefinitionException(requiredType);
}
getBean方法的具体实现逻辑在 AbstractBeanFactory类里面的doGetBean方法中。那么接下里，我们就看看这里面最最核心的逻辑：doGetBean()，
AbstractBeanFactory#doGetBean
依赖注入主要有两个过程，一个是实例化Bean，另一个是将依赖关系注入到Bean中。
从命名上我们也可以看出：他是 doGetBean，是有 do 这个动作的。因此不是简单的 get 有就返回，没有就返回 null 这么简单的操作。而是里面做了实例化、依赖注入、属性赋值、解决循环依赖等一些列操作~
关于 Spring 中 getBean 的全流程源码解析 - 小傅哥 - 博客园
可以通过 ApplicationContext 的 getBean 方法来获取 Spring 容器中已初始化的 bean。getBean 一共有以下3种方法原型。首先定义一个 Person 类，接下来演示 getBean 的3种方法原型，
（1）getBean(String beanName)
（2）getBean(Class<T> type)
对getBean(String name)和getBean(Class<T> type)的异同点进行对比总结：
1. 相同点：都要求 id 或者 name 或者类型在容器中的唯一性。
2. 不同点：getBean(String name)获得的对象需要类型转换，而getBean(Class<T> type)获得的对象无需类型转换。
（3）getBean(String beanName, Class<T> type)
（4）getBean(String beanName, Object[] args)
这种方式本质还是通过 bean 的 id 或者 name 来获取 bean，通过第二个参数 Object[] args 可以给 bean 的属性赋值，赋值的方式有两种：构造方法和工厂方法。但是通过这种方式获取的 bean 必须把 scope 属性设置为 prototype，也就是原型模式。
getBean() 核心流程
源码位置：AbstractBeanFactory --> getBean() --> doGetBean()。
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
// getBean 就像你的领导其实没做啥，都在 doGetBean 里
return doGetBean(name, requiredType, null, false);
}
protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
// 处理别名BeanName、处理带&符的工厂BeanName
// 1.如果传入的是FactoryBean，则去掉Bean开头的&符号；
// 2.可能存在传入别名且别名存在多重映射的情况，这里会返回最终的名字。如存在多层别名映射A->B->C->D，传入D,最终会返回A
final String beanName = transformedBeanName(name);
Object bean;
// 先尝试从缓存中获取Bean实例，这个位置就是三级缓存解决循环依赖的方法。若获取不到，就走下面的创建
// getSingleton()方法的实现，在父类DefaultSingletonBeanRegistry中，请先移步下面，看详解
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) { // 获取到了
if (logger.isDebugEnabled()) {
// 这里虽然只是一句日志，但是能说明用意。
// 若条件为true，表示这个Bean虽然在缓存里，但是还并没有完全被初始化（循环引用）
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 在getBean方法中，getObjectForBeanInstance是个频繁使用的方法。因此为了更好的知道细节，下面会详解这个方法的。其实简单理解就是处理FactoryBean的getObject()方法
// 1. 如果sharedInstance是普通的Bean实例，则下面的方法会直接返回
// 2. 如果sharedInstance是工厂Bean类型，则需要获取getObject方法，可以参考关于FactoryBean的实现类
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else { // 没有获取到
// 循环依赖有三种，setter注入、多实例和构造函数，Spring 只能解决 setter 注入，所以这里是 Prototype 则会抛出异常。即原型对象不允许循环创建，如果是原型对象正在创建，那就抛异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 1. 若父bean工厂存在，就要检查父容器是否实例化过它，避免被重复实例化（若父容器实例化过，就以父容器实例化的为准）。Spring中的单例bean只会被实例化一次
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // 父容器存在且当前工厂中不存在
// 获取name对应的beanName，如果name是以&开头，则返回& + beanName
String nameToLookup = originalBeanName(name);
// 根据 args 参数是否为空，调用不同的父容器方法获取 bean 实例
if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// 1. typeCheckOnly，用于判断调用 getBean 方法时，是否仅是做类型检查
// 2. 如果不是只做类型检查，就会调用 markBeanAsCreated 进行记录
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 从容器 getMergedLocalBeanDefinition 获取 beanName 对应的 GenericBeanDefinition，转换为 RootBeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查当前创建的 bean 定义是否为抽象 bean 定义
checkMergedBeanDefinition(mbd, beanName, args);
//这里就重要了，因为我们会有属性注入等，故这里就要保证它依赖的那些属性先初始化才行
//这部分是处理循环依赖的核心，下面有大篇幅专门讲解这方面的以及原理解决方案
//@DependsOn注解可以控制Bean的初始化顺序~~~
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 监测是否存在 depends-on 循环依赖，若存在则会抛出异常
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 注册依赖记录
registerDependentBean(dep, beanName);
try {
// 加载 depends-on 依赖（dep 是 depends-on 缩写）
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 从这里开始，就正式开始着手创建单例 bean 实例了
if (mbd.isSingleton()) {
//也是一样先尝试从缓存去获取，获取失败就通过ObjectFactory的createBean方法创建。这个getSingleton方法和上面是重载方法，它支持通过ObjectFactory去根据Scope来创建对象，具体源码解析见下面
//把 beanName 和 new ObjectFactory 匿名内部类传入回调
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
// 这是创建Bean的核心方法，非常重要~~~~~~~~~~~~~~~下面会有
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 创建失败则销毁
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 创建其他类型的 bean 实例
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final 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, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
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",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 这里就比较简单了，就是requiredType，比如要求是Integer，获得的是String，俺么就会调用转换器转换过来。绝大多数情况下，没啥卵用
if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
// 返回 Bean
return (T) bean;
}
DefaultSingletonBeanRegistry#getSingleton详解（三级缓存原理）：
@Override
@Nullable
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 此处是先从已经缓存好了的singletonObjects的Map中，查看有木有（至于当前已经有哪些了，下面有个截图，相信什么时候进来的都应该有些印象吧）
Object singletonObject = this.singletonObjects.get(beanName);
// 若缓存里没有。并且，并且，并且这个Bean必须在创建中，才会进来。
// singletonsCurrentlyInCreation字段含义：会缓存下来所有的正在创建中的Bean，如果有Bean是循环引用的 会把这种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) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
DefaultSingletonBeanRegistry#getSingleton详解（根据ObjectFactory结合Scope来创建合适的对象）：
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 从缓存中获取（上面获取过一次的，这里是双从判定）
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 如果这个Bean正在被销毁，就抛异常了
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!)");
}
// 创建前置检查：1、若在inCreationCheckExclusions面校验名单里，是ok的
//2、singletonsCurrentlyInCreation把它添加进去，证明这个Bean正在创建中
beforeSingletonCreation(beanName);
// 此处先打标机为为false
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 把这个实例生成出来，并且标志位设为true
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
// in the meantime再次旗舰，若有人已经把这个Bean放进去了，那就抛出这个异常吧
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} catch (BeanCreationException ex) {
// 处理异常
// 比如我们经常遇到的UnsatisfiedDependencyException异常：@Autowired的时候找不到依赖的Bean就是这个异常(一般由NoSuchBeanDefinitionException这个异常导致)
// 这里会吧异常链接拼接起来，然后一起打印出来~~~~非常方便查找问题
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 创建完成后再检查一遍。做的操作为：从正在创建缓存中移除
afterSingletonCreation(beanName);
}
// 这里也非常重要：若是新的Bean，那就执行addSingleton这个方法，这个方法做了什么，就下面4步操作：
//this.singletonObjects.put(beanName, singletonObject); //缓存起来
//this.singletonFactories.remove(beanName); //把对应ObjectFactory的缓存移除
//this.earlySingletonObjects.remove(beanName);
//this.registeredSingletons.add(beanName);
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
开始创建Bean AbstractAutowireCapableBeanFactory#createBean 提供此方法的抽象类为：AbstractBeanFactory，由子类去实现创建的逻辑，
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
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.
// 确保对应BeanClass完成解析(已经加载进来了Class对象)具体表现是进行了ClassLoder.loadClass或Class.forName完成了类加载
// 主要根据传入的typesToMatch生成特定的ClassLoader，之后还要调用RootBeanDefinition#resolveBeanClass，根据特定的加载器或者默认加载器加载出class属性对应的Class对象
// 我们这里解析出来，显然就是class com.fsx.service.HelloServiceImpl这个Class了
// 判断需要创建的Bean是否可以实例化，这个类是否可以通过类装载器来载入（也就说它甚至可能来源于网络）
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
// 这里主要是解析<lookup-method name="getFruit" bean="bananer"/>类似这种方式的依赖注入（Spring支持lookup-method，replace-method两个依赖注入的方式）
// 它相当于调用指定类里面的指定方法进行注入，所以需要考虑到方法重载的情况，因此这个方法解析的就是这种情况
// 由于项目中一般这么使用，也非常的不大众，具体原理此处省略
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 从doc解释：给BeanPostProcessors一个机会来返回一个代理对象代替目标对象 什么动态代理之类的，都在这里实现的~~~~~~~~~~~~~~~~~~~
// 1、具体逻辑是判断当前Spring容器是否注册了实现了InstantiationAwareBeanPostProcessor接口的后置处理器如果有，则依次调用其中的applyBeanPostProcessorsBeforeInstantiation方法，如果中间任意一个方法返回不为null,直接结束调用。
// 2、然后依次所有注册的BeanPostProcessor的postProcessAfterInitialization方法（同样如果任意一次返回不为null,即终止调用。
// 这个方法也非常的重要，后续有详细讲解
// 容器里所有的InstantiationAwareBeanPostProcessors实例，都会在此处生效，进行前置处理~~~~~~~~~~
// 下面有解释：BeanPostProcessor和InstantiationAwareBeanPostProcessor的区别，可以分清楚他们执行的时机
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 如果不为空，说明提前生成了实例，直接返回
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
// 这里又是一个核心逻辑：doCreateBean 创建Bean
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
// 创建完成后 直接短路掉返回
return beanInstance;
// 这些都是可能出现的异常们~~~~~~~~~~~~~~~~~~~~
} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
简略总结下 getBean 整体的执行流程，
1. 根据传入的 beanName 获取 bean 的别名；
2. 尝试从缓存中获取之前被实例化了的单例 bean；
3. 根据上面获取到的实例进一步获取 bean（因为获取到的可能是工厂 bean）；
4. 若第2步中没有获取到 bean，那么就需要创建 bean 了；
5. 先根据缓存判断一下当前的 bean 是否正在被创建，如果是的话表示依赖循环了；
6. 尝试获取当前工厂的父工厂，并从当前工厂的 bean 定义缓存中获取 bean 定义委托父工厂去生成；
7. 若当前要获取的 bean 只是为了进行类型检查，就标记 bean 已被创建；
8. 同当前 bean 的父类合并 bean 定义，并检查获取到的 bean 定义是不是抽象的；
9.通过上面获取到的 bean 定义找到当前 bean 的依赖 bean，并递归调用 getBean 方法获取依赖 bean；
10. 判断 bean 的 scope 是单例的还是原型的或是其他类型的，接着创建 bean；
11. 根据要求返回的 bean 类型通过 convertService 来对 bean 进行转换；
12. 最后返回 bean。
下面是 getBean 方法的简要说明：
（1）如果缓存中能取得我们想要的Bean，取得那些已经被创建过的Singleton的Bean，对这种Bean的请求不需要重复创建；
（2）如果缓存中不能取得的话，并且有parentBeanFactory的话，就从parentBeanFactory中取；
（3）如果parentBeanFactory中也取不到的话，那就根据Bean的类型（Singlton或Prototype或其它）去创建我们Bean（createBean方法）。
2852
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
