Spring IOC 源码学习4 getBean
1 容器的初始化
1.1 SpringIoc 容器的工做流以下图所示
1.2 实现流程
1.2.1 容器初始化
- 经过Resource ResourceLoader 加载 Configuration Metadata
- 解析 Configuration Metadata信息，封装成 BeanDefinition 并注册到 BeanDefinitionRegistry 中
1.2.2 加载bean
- 经过BeanFactory.getBean() 加载bean
- 对bean信息进行初始化
2 源码解析
2.1 源码警告
- 当显示或者隐式地调用 BeanFactory.getBean(String name) 方法时，则会触发加载 Bean 阶段。代码以下：
2.1.1 getBean
// 方法位于AbstractBeanFactory.java
public Object getBean(String name) throws BeansException {
// getBean 是一个空壳方法，全部的逻辑都封装在 doGetBean 方法中
return doGetBean(name, null, null, false);
}
复制代码
2.1.2 doGetBean
- 内部其实调用的doGetBean(Spring 套路都是这样子哈哈，包括事物那里)
protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
/*
* 经过 name 获取 beanName。这里不使用 name 直接做为 beanName 有两点缘由：
* 1. 若是 name 是 alias ，则获取对应映射的 beanName 。
* 2. 剥离工厂引用前缀&
*/
final String beanName = transformedBeanName(name);
Object bean;
/*
* 从缓存中或者实例工厂中获取 Bean 对象
* 从缓存中获取单例 bean。Spring 是使用 Map 做为 beanName 和 bean 实例的缓存的，因此这
* 里暂时能够把 getSingleton(beanName) 等价于 beanMap.get(beanName)。固然，实际的
* 逻辑并不是如此简单，后面再细说。
*/
Object sharedInstance = getSingleton(beanName);
/*
* 若是 sharedInstance = null代表这个实例还没建立。
* BeanFactory 只会在调用 getBean 获取 bean 时再实例化，也就是懒加载。
* BeanFactory 不会屡次实例化单例 bean。
*/
if (sharedInstance != null && args == null) {
//记录日志 没啥可说的
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 + "'");
}
}
/*
* 完成 FactoryBean 的相关处理，并用来获取 FactoryBean 的处理结果
* 若是 sharedInstance 是普通的单例 bean，下面的方法会直接返回。但若是
* sharedInstance 是 FactoryBean 类型的，则需调用 getObject 工厂方法获取真正的bean 实例。
*/
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
/*
* sharedInstance 为空，此时 beanName 对应的 bean 实例可能还未建立。也有可能父容器里已经实例化，须要先去父容器查找 这里有些不明白，先标注下而后后续查看
*/
else {
// BeanFactory 不缓存 Prototype 类型的 bean ，Spring 只解决单例模式下得循环依赖，在原型模式下若是存在循环依赖则会抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 若是 sharedInstance = null，则到父容器中查找 bean 实例 getParentBeanFactory 后续在研究
BeanFactory parentBeanFactory = getParentBeanFactory();
//containsBeanDefinition 方法实际就是判断 org.springframework.beans.factory.support.DefaultListableBeanFactory#beanDefinitionMap 是否有key beanName
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);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 合并父 BeanDefinition 与子 BeanDefinition，后面会单独分析这个方法
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 检查是否有 dependsOn 依赖，若是有则先初始化所依赖的 bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
/*
* 检测是否存在 depends-on 循环依赖，若存在则抛异常。好比 A 依赖 B，
* B 又依赖 A，他们的配置以下：
* <bean id="beanA" class="BeanA" depends-on="beanB">
* <bean id="beanB" class="BeanB" depends-on="beanA">
*
* beanA 要求 beanB 在其以前被建立，但 beanB 又要求 beanA 先于它
* 建立。这个时候造成了循环，对于 depends-on 循环，Spring 会直接
* 抛出异常
*/
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 注册依赖记录
registerDependentBean(dep, beanName);
try {
// 加载 depends-on 依赖
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 建立 bean 实例
if (mbd.isSingleton()) {
/*
* 这里并无直接调用 createBean 方法建立 bean 实例，而是经过
* getSingleton(String, ObjectFactory) 方法获取 bean 实例。
* getSingleton(String, ObjectFactory) 方法会在内部调用
* ObjectFactory 的 getObject() 方法建立 bean，并会在建立完成后，
* 将 bean 放入缓存中。关于 getSingleton 方法的分析，本文先不展开，我会在
* 后面的文章中进行分析
*/
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 是 FactoryBean 类型，则调用工厂方法获取真正的 bean 实例。不然直接返回 bean 实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 建立 prototype 类型的 bean 实例
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 建立其余类型的 bean 实例
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;
}
}
// 若是须要进行类型转换，则在此处进行转换。类型转换这一块我没细看，就很少说了。
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;
}
复制代码
主要步骤java
- 转换 beanName
- 从缓存中获取实例
- 若是实例不为空，且 args = null。调用 getObjectForBeanInstance 方法，并按 name 规则返回相应的 bean 实例
- 若上面的条件不成立，则到父容器中查找 beanName 对有的 bean 实例，存在则直接返回
- 若父容器中不存在，则进行下一步操做 – 合并 BeanDefinition
- 处理 depends-on 依赖
- 建立并缓存 bean
- 调用 getObjectForBeanInstance 方法，并按 name 规则返回相应的 bean 实例
- 按需转换 bean 类型，并返回转换后的 bean 实例。
2.1.3 transformedBeanName 源码
- 为何要 transformedBeanName 呢？Spring 确定不会作无用功，主要有如下几个缘由
- 处理以字符 & 开头的 name，防止 BeanFactory 没法找到与 name 对应的 bean 实例
- 处理 别名 经过别名找到最终的beanName
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
复制代码
2.1.4 BeanFactoryUtils.transformedBeanName
- 逻辑很简单就是去除入参中的 &
/**
* beanName 的缓存
*/
private static final Map<String, String> transformedBeanNameCache = new ConcurrentHashMap<>();
/**
* 去除 FactoryBean 的修饰符 & 若是 name 以 “&” 为前缀，那么会去掉该 "&" 。
* 例如，name = "&HelloService" ，则会是 name = "HelloService"。
*/
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) { // BeanFactory.FACTORY_BEAN_PREFIX = &
return name;
}
// computeIfAbsent 方法，分红两种状况：
// 1. 未存在，则进行计算执行，并将结果添加到缓存、
// 2. 已存在，则直接返回，无需计算。
return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
do {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
//BeanFactory.FACTORY_BEAN_PREFIX = "&"
} while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
return beanName;
});
}
复制代码
2.1.5 SimpleAliasRegistry.canonicalName
- 从aliasMap 获取最终的beanName, 采用了循环主要是考虑到多层别名
<bean id="hello" class="service.Hello"/>
<alias name="hello" alias="aliasA"/>
<alias name="aliasA" alias="aliasB"/>
复制代码
- 上面的别名指向关系为 aliasB -> aliasA -> hello，对于上面的别名配置
- aliasMap 中数据视图为：aliasMap = [<aliasB, aliasA>, <aliasA, hello>]。经过下面的循环解析别名 aliasB 最终指向的 beanName
// alias -> beanName 的缓存
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
public String canonicalName(String name) {
String canonicalName = name;
String resolvedName;
/*
* 循环，从 aliasMap 中，获取到最终的 beanName
*/
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
复制代码
2.1.6 getSingleton(String beanName)
- 代码位于 /org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java
/** singleton 缓存map 格式为 bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
/** singleton factory 缓存 map, 格式为 bean name --> ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
/** Cache of early singleton objects: bean name --> bean instance */
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
/** Set of registered singletons, containing the bean names in registration order */
private final Set<String> registeredSingletons = new LinkedHashSet<String>(256);
/** 建立中的bean */
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
/** Names of beans currently excluded from in creation checks */
private final Set<String> inCreationCheckExclusions =
Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
/**
* allowEarlyReference 表示是否容许其余 bean 引用
*/
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从 singletonObjects 获取实例，singletonObjects 中缓存的实例都是彻底实例化好的 bean，能够直接使用
Object singletonObject = this.singletonObjects.get(beanName);
/*
* 若是 singletonObject = null，代表还没建立，或者还没彻底建立好。
*/
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从 earlySingletonObjects 中获取提早曝光的 bean，用于处理循环引用
singletonObject = this.earlySingletonObjects.get(beanName);
// 若是若是 singletonObject = null，且容许提早曝光 bean 实例，则从相应的 ObjectFactory 获取一个原始的（raw）bean（还没有填充属性）
if (singletonObject == null && allowEarlyReference) {
// 获取相应的工厂类
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 提早曝光 bean 实例，用于解决循环依赖
singletonObject = singletonFactory.getObject();
// 放入缓存中，若是还有其余 bean 依赖当前 bean，其余 bean 能够直接从 earlySingletonObjects 取结果
this.earlySingletonObjects.put(beanName, singletonObject);
//移除bean factory 由于已经出事花了一个原始bean放入 earlySingletonObjects
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
复制代码
2.1.7 判断bean是否建立中
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
复制代码
2.1.8 AbstractBeanFactory.getObjectForBeanInstance
- 从FactoryBean 获取bean 实例
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
// 若是 name 以 & 开头，但 beanInstance 却不是 FactoryBean，抛出异常
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
/**
* 1 beanInstance 是 FactoryBean 须要调用 工厂方法生成bean
* 2 beanInstance 是一个普通bean 直接返回
*/
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
//若是 mbd 为空，则从缓存中加载 bean。FactoryBean 生成的单例 bean 会被缓存 在 factoryBeanObjectCache 集合中，不用每次都建立
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// 到这一步确定是FactoryBean
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// 若是mbd is null 则判断是否存在 beanname 的 BeanDefinition，若存在 合并
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
复制代码
2.1.9 org.springframework.beans.factory.support.FactoryBeanRegistrySupport#getObjectFromFactoryBean
/**
* FactoryBean 也有单例和原型之分
* 针对单例FactoryBean 生成bean 也默认是单例模式，须要放入缓存
* 非单例的FactoryBean 生成的bean 则不会放入缓存
* @param factory
* @param beanName
* @param shouldPostProcess 对bean 进行后置处理
* @return
*/
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//若是factory 是单例模式
if (factory.isSingleton() && this.containsSingleton(beanName)) {
synchronized(this.getSingletonMutex()) {
//缓存中获取bean
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
//使用工厂方法建立bean
object = this.doGetObjectFromFactoryBean(factory, beanName);
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
} else {
if (shouldPostProcess) {
// singletonsCurrentlyInCreation 是否已有该bean Name， 若是有直接返回
if (this.isSingletonCurrentlyInCreation(beanName)) {
return object;
}
this.beforeSingletonCreation(beanName);
try {
//后置处理
object = this.postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable var14) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", var14);
} finally {
this.afterSingletonCreation(beanName);
}
}
// singletonObjects map 是否包含 beanName
if (this.containsSingleton(beanName)) {
//若是包含则 把 FactoryBean 建立的bean 缓存到 factoryBeanObjectCache
//factoryBeanObjectCache 定义于 org.springframework.beans.factory.support.FactoryBeanRegistrySupport
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
} else {
//非单例模式 直接经过工厂方法获取
Object object = this.doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
object = this.postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", var17);
}
}
return object;
}
}
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
//这块没太懂
if (System.getSecurityManager() != null) {
AccessControlContext acc = this.getAccessControlContext();
try {
object = AccessController.doPrivileged(factory::getObject, acc);
} catch (PrivilegedActionException var6) {
throw var6.getException();
}
} else {
//直接经过工厂方法获取
object = factory.getObject();
}
} catch (FactoryBeanNotInitializedException var7) {
throw new BeanCurrentlyInCreationException(beanName, var7.toString());
} catch (Throwable var8) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);
}
if (object == null) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
复制代码
待完善中spring
相关文章
- 1. Spring IoC源码解析之getBean
- 2. Spring源码-IOC容器(三)-GetBean
- 3. [spring源码学习]4、IOC源码——普通bean初始化
- 4. 学习Spring IOC源码
- 5. 框架源码系列六：Spring源码学习之Spring IOC源码学习
- 6. spring IOC源码学习(一)
- 7. Spring源码学习（一）------ IoC
- 8. Spring源码学习（一） IOC容器
- 9. Spring源码-Ioc
- 10. Spring BeanFactory getBean 源码剖析
- 更多相关文章...
- • Spring IoC容器：BeanFactory和ApplicationContext - Spring教程
- • 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 适用于PHP初学者的学习线路和建议
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
