详解Spring的GetBean方法

Spring容器提供了五种获取Bean的方式，可以根据beanName获取Bean，也可以根据classType来获取Bean，所有根据beanName来获取Bean的方式，底层都会通过调用下面的doGetBean()来获取Bean对象

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)

一、根据beanName获取Bean

Spring容器提供了三种根据beanName获取Bean的方式：

// 启动Spring容器
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// 直接根据beanName来获取
UserService userService = (UserService) context.getBean("userService");
// 根据beanName获取Bean后,判断该Bean是否属于UserService类型
UserService userService1 = (UserService) context.getBean("userService",UserService.class);
// 指定构造方法参数,使用指定的构造方法的生成Bean,如果UserService是单例的,则容器启动的过程中就会去自行推断构造方法然后创建单例Bean;如果UserService是原型的，则每次都会getBean()时,会根据后面提供的构造方法参数使用指定的构造方法创建Bean
UserService userService2 = (UserService) context.getBean("userService",new OrderService());

上面三种方式都会调用doGetBean()来获取Bean对象，下面将详细介绍doGetBean()的实现

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {// name有可能是 &xxx 或者 xxx，如果name是&xxx，那么beanName就是xxx// name有可能传入进来的是别名，那么beanName就是idString beanName = transformedBeanName(name);Object beanInstance;// Eagerly check singleton cache for manually registered singletons.Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {// 如果sharedInstance是FactoryBean，那么就调用getObject()返回对象beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);}

上述代码在《实例化单例Bean》的FactoryBean创建部分有大概介绍过，下面将详细介绍核心的代码方法

1.1 name转换，获取真正的beanName

transformedBeanName()主要将传进来的name转换成真正的beanName，具体实现如下：

protected String transformedBeanName(String name) {return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

先看里面的BeanFactoryUtils.transformedBeanName()实现，下面代码在FactoryBean的创建中已经讲过，想要获取一个FactoryBean的对象，那么传进来的name是以“&”前缀开头，可以只有一个“&”，也可以有多个“&”，下面的代码只是将前缀的“&”去掉而已

public static String transformedBeanName(String name) {Assert.notNull(name, "'name' must not be null");if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {return name;}return transformedBeanNameCache.computeIfAbsent(name, beanName -> {do {beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());}while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));return beanName;});
}

接下来看canonicalName()实现了怎样的功能，调用BeanFactoryUtils.transformedBeanName()返回的可能还不是最终的beanName，可能是Bean的一个别名，使用@Bean注解创建Bean的时候，可以为Bean指定多个名称，如下所示：

Spring会把第一个名字即“userService”作为真正的beanName，而后面的名字作为Bean的别名进行存储

@Bean({"userService","userService1"})
public UserService userService(){return new UserService();
}AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
//根据别名也能获取Bean
UserService userService = (UserService) context.getBean("userService1");

Bean的别名存放在一个aliasMap中，其中KEY=别名，VALUE=beanName/别名，根据别名从aliasMap中拿到的可能是真正的beanName，也可能还是一个别名，所以用do-while循环，直到拿出来的名字从aliasMap再找不到对应的值，那么该名字就是真正的beanName了

public String canonicalName(String name) {String canonicalName = name;// Handle aliasing...String resolvedName;do {resolvedName = this.aliasMap.get(canonicalName);if (resolvedName != null) {canonicalName = resolvedName;}}while (resolvedName != null);return canonicalName;
}

1.2 父BeanFactory创建Bean对象

获取到真正的beanName之后，不论是单例Bean还是原型Bean，都会调用getSingleton(beanName)去单例池中查找是否有单例Bean。如果从单例池中取出对象了，接下来的getObjectForBeanInstance()主要根据原始name判断当前Bean是否是FactoryBean，以及获取FactoryBean对象。如果单例池中不存在，则需要创建Bean实例

如果当前BeanFactory的beanDefinitionMap中不存在该beanName，且存在parentBeanFactory，则让parentBeanFactory去创建Bean

BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {// Not found -> check parent.// &&&&xxx---->&xxxString nameToLookup = originalBeanName(name);if (parentBeanFactory instanceof AbstractBeanFactory) {return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);}else if (args != null) {// Delegation to parent with explicit args.return (T) parentBeanFactory.getBean(nameToLookup, args);}else if (requiredType != null) {// No args -> delegate to standard getBean method.return parentBeanFactory.getBean(nameToLookup, requiredType);}else {return (T) parentBeanFactory.getBean(nameToLookup);}
}

originalBeanName(name)方法用于将别名和"&&&"格式的名字进行转换真正的beanName或FactoryBean的beanName

protected String originalBeanName(String name) {String beanName = transformedBeanName(name);if (name.startsWith(FACTORY_BEAN_PREFIX)) {beanName = FACTORY_BEAN_PREFIX + beanName;}return beanName;
}

1.3 当前BeanFactory来创建Bean

从mergedBeanDefinitions中根据beanName获取RootBeanDefinition，《实例化单例Bean》中提到过真正创建Bean的时候，用的是合并后的RootBeanDefinition而不是普通的BeanDefinition

然后判断当前RootBeanDefinition是否是抽象的，如果是抽象的将会抛出异常

接着获取该Bean的@DependsOn注解依赖的beanName

创建@DependsOn注解依赖Bean对象

RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查BeanDefinition是不是Abstract的
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();

DependsOn注解的使用如下：

DependsOn注解指明在创建UserServicce的Bean之前，需要先创建orderService和user，在Spring生成BeanDefinition的时候，就回去解析@DependsOn，然后将依赖的beanName存放在BeanDefinition的字符串数组dependsOn中

@Component
@DependsOn({"orderService","user"})
public class UserService {}

如果DependsOn数组不为空，将遍历数组，首先判断是否存在@DependsOn的循环依赖(这个地方的循环依赖不同于依赖注入的循环依赖)，即UserService依赖于user，而User的@DependsOn又依赖于userService，对于这种情况，将直接抛出异常

如果不存在循环依赖，则把这种依赖关系存放在dependentBeanMap中，它的key表示被依赖Bean的beanName，而value是一个Set，存放依赖该Bean的beanName集合，然后调用getBean(dep)来创建依赖的Bean对象

if (dependsOn != null) {// dependsOn表示当前beanName所依赖的，当前Bean创建之前dependsOn所依赖的Bean必须已经创建好了for (String dep : dependsOn) {// beanName是不是被dep依赖了，如果是则出现了循环依赖if (isDependent(beanName, dep)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}// dep被beanName依赖了，存入dependentBeanMap中，dep为key，beanName为valueregisterDependentBean(dep, beanName);// 创建所依赖的beantry {getBean(dep);}catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);}}
}

创建单例Bean

如果RootBeanDefinition的scope属性是单例的，则调用getSingleton创建单例Bean

if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);}catch (BeansException ex) {destroySingleton(beanName);throw ex;}});// 前面讲过,主要用于获取FactoryBeanbeanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

getSingleton(beanName, ObjectFactory<?> singletonFactory)先从单例池中根据beanName来获取单例Bean，如果单例池中没有，则再通过createBean来创建单例Bean

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {synchronized (this.singletonObjects) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {……try {// 通过lambda表达式调用createBean方法singletonObject = singletonFactory.getObject();newSingleton = true;}……// 添加到单例池if (newSingleton) {addSingleton(beanName, singletonObject);}}return singletonObject;}
}

创建原型Bean

如果RootBeanDefinition的scope属性是原型的，则直接调用createBean方法创建原型Bean

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);}beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

创建其他作用域Bean

除了单例和原型Bean，Spring还支持request、session和application作用域的Bean

首先获取scopeName，然后根据scopeName获取对应的Scope对象，比如：RequestScope和SessionScope

Scope对象的get方法都会去调用AbstractRequestAttributesScope类的get()，RequestScope和SessionScope都继承该类

String scopeName = mbd.getScope();
Scope scope = this.scopes.get(scopeName);
if (scope == null) {throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {  // session.getAttriute(beaName)  setAttriObject scopedInstance = scope.get(beanName, () -> {beforePrototypeCreation(beanName);try {return createBean(beanName, mbd, args);}finally {afterPrototypeCreation(beanName);}});beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}

getScope()返回Scope对象对应的Scope值，然后调用getAttribute方法，如果request和session中都没有Bean实例，

public Object get(String name, ObjectFactory<?> objectFactory) {RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();Object scopedObject = attributes.getAttribute(name, getScope());if (scopedObject == null) {// lambda表达式调用createBean创建实例scopedObject = objectFactory.getObject();// 并将Bean设置到对应的属性中attributes.setAttribute(name, scopedObject, getScope());……}return scopedObject;
}

getAttribute根据传进来的Scope值，判断从request还是session去根据name获取对应属性的对象

public Object getAttribute(String name, int scope) {if (scope == SCOPE_REQUEST) {if (!isRequestActive()) {throw new IllegalStateException("Cannot ask for request attribute - request is not active anymore!");}return this.request.getAttribute(name);}else {HttpSession session = getSession(false);if (session != null) {Object value = session.getAttribute(name);if (value != null) {this.sessionAttributesToUpdate.put(name, value);}return value;}return null;}
}