我的这篇文章是在系统学习Spring源码之后,基于自己对Spring源码的理解，来详细分析Spring之getBean()方法底层的实现。
一.Spring之getBean()方法常见的三种用法
1.getBean(String name)，通过名字从Spring容器中获取bean,那么这个name可以是BeanFactory中bean真正的名字、也可以是在定义bean时指定的别名、还可以是带&符号的名字;
说明：如果一个bean是FactoryBean,那通过name获取到的bean是FactoryBean中getObject()方法返回的对象，想要获取到真正的FactoryBean对象,需要在name前面加&符号。
2.getBean(String name, Class<T> requiredType)，通过名字和指定的类型从Spring容器中获取bean,参数requiredType相当于一个限定条件,如果根据name拿到的bean对象,不是requiredType类型并且不能进行类型转化，则会报错
<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
//检查实际得到的bean实例与指定类型是否匹配
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
//如果不匹配并且不能进行类型转换，则会抛异常
Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return (T) convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}说明：此方法在AbstractBeanFactory中,位于doGetBean方法的最后,用于检查根据name获取到的bean对象是否与指定的requiredType适配。
3.getBean(String name, Object... args),Object... args与构造方法有关系,Spring创建对象默认会用无参的构造方法,如果name对应的bean是单例的并且是非懒加载的，那么Object... args是不会用到的,如果name对应的bean是原型的,并且bean所属的类里面有有参的构造方法，那么Spring在创建对象的时候就会将Object... args传给有参的构造方法,并且调用有参的构造方法创建对象。
二、Spring之getBean()方法底层执行流程
1.解析调用getBean()方法时指定的name,还原成真正的beanName
Spring源码中真正执行获取bean的是doGetBean方法,因为在调用getBean()方法时,参数name会对应很多种情况(可能是beanName、也可能是别名、也能是加了&符号的名称)，如果在用到name的时候才会做相应的处理,那么势必很多地方会有处理name的逻辑,同时也会造成大量的代码重复，所以Spring在doGetBean方法开始的地方就对各种情况的name做了统一的处理；
//处理各种情况的name
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}说明：BeanFactoryUtils.transformedBeanName(name)用来处理带&符号的名字，canonicalName(String name)用来处理别名的情况,最终transformedBeanName方法会把name还原成真正的beanName；
2.根据beanName从单例池获取bean实例,根据能否获取到bean实例，执行不同的分支处理逻辑
根据真正的beanName去单例池去获取，如果能获取到，那么此时会有两种情况：获取到的有可能是普通bean,也有可能是FactoryBean，所以还不能将获取到的bean直接返回，因为返回的bean实例有可能不是真正想要获取的bean,还需要根据name,beanName，以及从单例池中拿到的bean实例,去进一步判断想要获得的是FactoryBean还是普通bean,以下是判断的方法
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
// 从factoryBeanObjectCache中直接拿对象,factoryBeanObjectCache存的是getObject()方法返回的对象
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
// synthetic为true，表示这个Bean不是正常的一个Bean，可能只是起到辅助作用的，所以这种Bean就不用去执行PostProcessor了
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
如果根据beanName从单例池中没有获取到bean实例，则会进入其它条件分支去判断,这里就要回顾下Spring的扫描,Spring在扫描的时候针对每一个符合条件的bean，都会生成一个相应的BeanDefinition，用于后续bean的创建；如果进入其它条件分支判断,首先看本容器里有没有beanName对应的BeanDefinition(通过beanDefinitionMap来检查),如果没有同时又有父BeanFactory,就调用父BeanFactory的getBean()方法来获取到bean实例，如果没有，则执行真正的创建bean的逻辑
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String 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);
}
}3.执行真正的创建bean的逻辑，前提是步骤2中的条件均不满足
3.1.Spring在真正的创建bean之前，还会有一些准备及检查工作
1）合并BeanDefination,Spring在定义bean的时候有可能会为当前bean对应的BeanDefination指定一个父BeanDefination
<bean id="mySchool" class="com.bj.study.School" scope="prototype abstract="true"/> <bean id="myStudent" class="com.bj.study.Student" parent="mySchool"/>
2) 检查BeanDefination是不是抽象的
3) 检查有没有加 @DependsOn(),如果有，则需进一步检查会不会出现循环依赖
3.2.根据BeanDefination的标识：单例、原型、还是其它作用域的bean,分别执行不同的逻辑去创建bean
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
//对BeanDefinition进行合并,会将child的属性与parent的属性进行合并,当有相同属性时,以 child 的为准
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查BeanDefinition是不是Abstract的(抽象的BeanDefinition是不能创建bean的)
checkMergedBeanDefinition(mbd, beanName, args);
String[] dependsOn = mbd.getDependsOn();
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为value
registerDependentBean(dep, beanName);
// 创建所依赖的bean
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
//不管创建的是单例bean、原型bean还是其它作用域的bean,都有可能创建出来的是一个FactoryBean,要再去调getObjectForBeanInstance()方法才能够得到真正的bean对象
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {//实现其它的作用域的逻辑:例如SpringMVC中的request、session这些作用域
//例如request,在同一个请求里面,根据同一个beanName拿到的bean对象应该是同一个,想要拿到的是同一个也得通过缓存来实现
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
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, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}
catch (BeansException ex) {
beanCreation.tag("exception", ex.getClass().toString());
beanCreation.tag("message", String.valueOf(ex.getMessage()));
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
finally {
beanCreation.end();
}
}
以下是关于创建bean的源码实现的链接
扫一扫
740
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
