概要
过度
我们在2-XXX中介绍了从 XML 中读取 Spring 配置，并完成相关 BD 注册的操作。我们是以一个例子开头的：
public static void main(String[] args){
XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource(""));
beanFactory.getBean("");
}
我们之前的所有介绍都是围绕着第一句，创建XmlBeanFactory来展开的，在创建实例时完成所有配置文件的扫描和解析。
现在我们开始进行第二句——指定 bean 并获取相关实例。
内容简介
本文主要介绍指定 bean 并获取相关实例这个大环节中的整体思路。后面几节会逐渐深入完成介绍。
所属环节
指定 bean 并获取相关实例。整体思路介绍。
上下环节
上文： 创建 Spring 上下文并读取配置文件解析生成 BD。
下文：用户自己拿着 bean 实例玩。
源码解析
入口
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
设计思路很常见，提供一个入参复杂的专门用来做逻辑封装，然后针对不同情况用方法重载构造出方便使用的方法。
获得实例的具体逻辑
/**
* 返回对应的 bean 实例
*
* @param name 用来获得 bean 实例的 id/alias
* @param requiredType 将 Bean 实例转换成这个类穿出来
* @param args 不使用配置的入参，用传入的参数
* ()
* @param typeCheckOnly whether the instance is obtained for a type check,
* not for actual use
* 意思是不用构建，我只是check 一下我要的 beanName 对应的 bean
* 是不是我传入的 type
*
* 在后面如果发现单例解决循环失败后会查看已经依赖此单例的是否可删除来挽回
* 【如果只是用来校验 type 说明可挽回，就抢救一下，如果是有用的，不好意思，
* 直接报错退出程序】
* @return an instance of the bean
* @throws BeansException if the bean could not be created
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 将入参的别名真正映射到指向某个 Bean 的唯一id【beanName】
// 在这一步中，将所有试图指向 FactoryBean 的前缀都删掉了
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 提前检查单例中是否有 beanName 指向的 bean 。如果有，返回其实例
// 【不一定完成初始化，但是这个地址引用一定是对的，如果是错的后面会有人收场】
// 如果返回空，表示这个 beanName 指向的 bean 不是单例，或者这个单例还没创建，总之，接下来就得创建一番了。
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// beanName 指向的是单例，同时，使用配置好的参数进行初始化，不再额外指定参数。
if (logger.isDebugEnabled()) {
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 + "'");
}
}
// 根据入参的 name 、处理后的 beanName、beanName 得到的单例 bean ，得到我们最后需要的结果
// 最后一个参数传 null， 表示默认先从缓存取
// 注意了，这里是为了预防遇到了 FactoryBean 所以包装了一个函数
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
// isPrototypeCurrentlyInCreation(beanName) 返回 true 表示：
// 1. 我们要创建的是原型生命周期的东西
// 2. 这个东西正在创建中
// 因为我们只解决单例的循环依赖问题
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//到这里，我们已经确定 beanName 对应的 bean 不是已经缓存好的单例。接下来开始尝试构建
// Check if bean definition exists in this factory.
// 多级 BeanFactory 加载的顺序：
// 1. 先从本级 BeanFactory 中尝试加载bean，如果加载成功则返回
// 2. 如果本级 BeanFactory 中没有对应的 BeanDefination【或者其他】，就委托给父工厂
// 这里正好和 ClassLoader 的委托模型相反
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 本工厂无法加载 bean 定义，委托给父工厂
// Not found -> check parent.
// 获得要加载的原始bean名称
// TODO 感觉有点脱裤子放屁，但是如果非要说的话，应该是将 "&&&&&&&name"这样的极端情况排除了，如果有需要就只留下一个`&`
// 也算是简化了一下
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 {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// 如果 typeCheckOnly 为 true ，则表示只是检测，如果为 false 则表示要创建出 bean
// 这个是一种约定，即：
//
// 如果你指明了这次 Bean 的实例化只是检测类型，不是要用来做正事的话，后面万一在解决冲突提前
// 暴露出去地址，后来在修饰时发现被代理导致实例地址变了，可以方便的删了
//
// 如果你指明这个就是用来用的，不是仅检测类型，后面发现后处理器给改变了实例地址，直接报错说
// 解决循环依赖失败
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 根据 beanName 得到 BeanDefinition ，因为 BD 有继承关系，顺手把 bd 拍平
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// bd 不能为抽象的，这样没法实例化
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 看看有没有手动设置循环依赖，指定实例化、初始化顺序的那种，如果有是无法解决的
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// dep 在 mbd 的 dependsOn 中表示， mbd 对应的 bean 依赖 dep
// 如果 dep 也依赖 mbd 对应的 bean 则表明有循环依赖
// TODO: 注意了，这里和单例 Bean 的解决循环依赖没有关系
// 单例 Bean 解决的循环依赖是创建完实例后填充属性的循环依赖，针对一下两种情况没有办法解决：
// 1. 配置 dependsOn 手动指定实例化先后顺序
// 2. 使用构造函数实例化
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 注册依赖关系： beanName 对应的 bean 依赖 dep bean
registerDependentBean(dep, beanName);
try {
// 将 beanName 依赖的 bean 都初始化了
// 实例化、初始化完成，能正常使用的
// 递归调用嘛
getBean(dep);
} catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 到这里，完成了对 bean 依赖的准备，开始构建我们需要的这个 bean 实例了
// Create bean instance.
if (mbd.isSingleton()) {
// 完成对应 bean 实例的创建
// 单例 bean 需要一系列工序，例如加锁、缓存、注册单例等等
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建 bean 实例
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
// 构建失败记得清一下你预存的引用，防止出错
destroySingleton(beanName);
throw ex;
}
});
// 转化成我们需要的实例类型 【 FactoryBean ?Bean?】
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
// 原型 bean 保存一下就行，不是为了解决循环依赖，只是为了在创建时发现正在创建中，能快速失败
Object prototypeInstance = null;
try {
// 这个保存操作我真 TM 醉了，真的是一切靠约定
// 好在是 ThreadLocal ，不会出现多个线程同时创建多个导致最后访问出现问题
// TODO： 这个和单例一样的缓存标记不清楚有什么扩展作用，后面注意一下
// 至少能确定的是，可以用来做监视器扩展。。。。
beforePrototypeCreation(beanName);// 存一下，在创建中
// 原型模式，不用 getSingleton（） 那样加锁了，直接创建
prototypeInstance = createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);// 创建完，删了标记
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
// TODO 如果设置了多个 scope ，它是怎么搞的，没看到拆分呀。看看他怎么实现的
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) { // scope 不符合
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
// TODO： scope 里面可能做了缓存，实现了 同请求下/同session下 的对象实例复用
Object scopedInstance = scope.get(beanName, () -> {
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;
}
}
// 对上面获得的 bean 实例进行判断看是否需要类型转换
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
} 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());
}
}
return (T) bean;
}
小方法
处理入参name的不规范，去掉前面的所有&。
同时直接获得name对应的 Bean 的 Id。
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
String beanName = name;
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
return beanName;
}
总结
其实看明白这个函数，基本就搞明白 bean 实例创建的思路了，我们直接用流程图表示：
1.png
扩展
通过我们上面梳理，我们基本对整个获得 bean 实例的思路流程有了一些大概的了解。
接下来我们关注的重点是：
- 根据入参的前缀和我们取得的实例，看返回
FactoryBean还是里面的东西。 - 三种情况下的创建都是调用的
createBean，只是根据生命周期的不同，在外面包了一些东西而已。
这两个点也是接下来我们要详细介绍的地方。
问题遗留
暂无
网友评论