Spring读源码系列04----bean的加载---上
2023-09-14 09:02:33 时间
Spring读源码系列04----bean的加载---上
- Bean的加载
- AbstractBeanFactory#getBean(String name)----根据名字获取bean
- FactoryBean的使用
- 缓存中获取单例bean
- 从Bean实例中获取对象---FactoryBean
- 获取单例
- DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory)-----加载单例bean
- DefaultSingletonBeanRegistry#beforeSingletonCreation---记录当前正要创建的bean到singletonsCurrentlyInCreation缓存中
- DefaultSingletonBeanRegistry#afterSingletonCreation---从singletonsCurrentlyInCreation缓存中移除当前bean正在加载的状态记录
- DefaultSingletonBeanRegistry#addSingleton---新创建的bean加入单例bean缓冲池中
- ObjectFactory#getObject---调用ObjectFactory的getObject方法新创建一个单例bean实例
- 准备创建bean
阅读本系列之前,建议先从本专栏的两个不同视角学习spring的系列作为入门学习点(这两个系列会持续更新)，先大体理解spring的架构设计与精髓，然后再来阅读本系列，深入源码分析，而不再纸上谈兵。
从整体来学spring系列文章:
Spring复杂的BeanFactory继承体系该如何理解? ----上
Spring复杂的BeanFactory继承体系该如何理解? ----中
Spring复杂的BeanFactory继承体系该如何理解?—中下
Spring复杂的BeanFactory继承体系该如何理解?—下
该系列持续更新中…
独特视角学习spring系列文章:
该系列持续更新中…
本系列文章:
Spring读源码系列03----自定义标签解析(待续中)
Bean的加载
<bean id="peo" class="org.deepSpring.Peo"/>
public class DeepSpringStudy {
public static void main(String[] args) {
ClassPathResource classPathResource = new ClassPathResource("bean.xml");
XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(classPathResource);
Peo peo = (Peo) xmlBeanFactory.getBean("Peo");
peo.show();
}
}
public class XmlBeanFactory extends DefaultListableBeanFactory
正式开始之前,大家心中要有这幅继承图，不然后面会比较懵逼
AbstractBeanFactory#getBean(String name)----根据名字获取bean
AbstractBeanFactory#doGetBean—真正干活的方法
/**
* Return an instance, which may be shared or independent, of the specified bean.
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
//提取对应的beanName
//别名到真实的beanName,去掉FactoryBean的&
String beanName = transformedBeanName(name);
Object beanInstance;
//检查缓存中或者实例工厂中是否有对应的实例
//为什么首先会使用这段代码呢?
//因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖
//spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光
//(这里ObjectFactory是啥东西,后面会详细分析)
//也就是将ObjectFactory加入到缓存中,一旦下个bean创建时候需要依赖上个bean则直接使用ObjectFactory
//直接尝试从缓存获取或者singletonFactories中的ObjectFactory获取
Object sharedInstance = getSingleton(beanName);
//如果从缓存或者对象工厂获取到了对应的实例对象,并且此时构造参数为空--->因为这里必须是无参构造进行创建的
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//getObjectForBeanInstance这个干啥的呢？
//因为有时候存在诸如BeanFactory的情况,并不是直接返回实例本身而是返回指定方法返回的实例
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
//如果缓存或者对象工厂中没有的话
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
//只有在单例情况下才会去尝试解决循环依赖,原型模式下，如果存在A中有B的属性,B中有A的属性,那么当依赖注入的时候，就会产生当A还没有创建完的时候因为对于B的创建再次返回创建A，造成循环依赖，也就是下面判断的情况
//isPrototypeCurrentlyInCreation--->返回指定的原型bean当前是否正在创建中
//其实内部会有一个ThreadLocal<Object> prototypesCurrentlyInCreation属性记录当前线程正在创建的原型bean
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
//获取父容器---这里parentBeanFactory可以在创建BeanFactory通过参数传入
//如果没有设置,默认为NULL
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果存在父容器并且
//containsBeanDefinition最终调用的是DefaultListableBeanFactory的
//this.beanDefinitionMap.containsKey(beanName);
//这个beanDefinitionMap在xml解析过程中每次得到一个BeanDefinition都会往里面注册一个
//总结:containsBeanDefinition判断当前容器中是否存在beanName对应的BeanDefinition
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//能进入该判断条件说明在当前容器中找不到,并且又存在父容器,所以尝试去父容器中寻找
// Not found -> check parent.
//获取原始的beanName---如果是别名的话,变为别名指向的beanName,如果要获取的是FactoryBean的name的话,也需要进行特殊处理
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
//去父容器中找---一般都是会继承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) {
//携带参数class类型进行查找
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
//直接按照名字查找
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
//如果不是仅仅做类型检查则是创建bean,这里要进行记录
if (!typeCheckOnly) {
//将指定的 bean 标记为已创建（或即将创建）。 这允许 bean 工厂优化其缓存以重复创建指定的 bean。
//这里是用一个Set<String> alreadyCreated集合来存放正在创建中的bean
markBeanAsCreated(beanName);
}
//我猜测应该是用来追踪状态的
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
//增加追踪信息
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
//将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition,如果指定beanName是子bean的话,同时还会合并父类的相关属性
//一会进行分析!!!
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
//当前RootBeanDefinition依赖的其他bean
// Guarantee initialization of beans that the current bean depends on.
//解析标签上的depends-on属性时会将解析到的beanName放入到beanDefinition中去
String[] dependsOn = mbd.getDependsOn();
//若存在依赖则需要递归实例化依赖的bean
if (dependsOn != null) {
for (String dep : dependsOn) {
//isDependent:如果能从dependentBeanMap集合中找到当前beanName依赖的beans集合,
//并且该集合包含了当前依赖的dep，说明出现了循环依赖
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//依赖关系注册--->dependenciesForBeanMap
registerDependentBean(dep, beanName);
try {
//递归创建依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
//实例化依赖的bean后，便可以实例化mbd本身了
//singleton模式的创建
if (mbd.isSingleton()) {
//getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法一会进行分析
sharedInstance = getSingleton(beanName, () -> {
try {
//这个方法是核心
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;
}
});
//上面见过一次---如果缓存或者对象工厂有的话
//因为有时候存在诸如BeanFactory的情况,并不是直接返回实例本身而是返回指定方法返回的实例
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// prototype模式的创建
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
//这里是将当前正在创建中的PrototypeBean放入当前线程的prototypesCurrentlyInCreation--->ThreadLocal<Object>中去
//一开始当前线程只有一个正在创建的bean时，存放一个string，多余两个时，会变为set集合来存放
//当前正在创建的PrototypeBeans
beforePrototypeCreation(beanName);
//创建！！！----说明是核心方法
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//将当前bean的创建状态从prototypesCurrentlyInCreation集合中移除掉
afterPrototypeCreation(beanName);
}
//因为有时候存在诸如BeanFactory的情况,并不是直接返回实例本身而是返回指定方法返回的实例
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//如果当前bean的作用域不是单例也不是原型,那么进入下面的分支
//当然bean为其他类型
else {
//在指定的scope上实例化bean
//获取当前beanDefinition绑定的scopeName
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
//从已注册的scopes集合上获取对应的scope
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
//调用scope的get(String name, ObjectFactory<?> objectFactory)方法来返回一个bean实例
//objectFactory是一个函数式接口,只有一个getObject方法
Object scopedInstance = scope.get(beanName, () -> {
//同样也是记录当前bean的创建状态
//下面记录和移除创建状态的两个方法和Prototype使用的是一样的方法
//保存在prototypesCurrentlyInCreation中，对就是和上面Prototype一样的集合
beforePrototypeCreation(beanName);
try {
//无论是什么scope,如果bean还没创建过,都需要调用createBean来创建bean实例对象
return createBean(beanName, mbd, args);
}
finally {
//将当前bean的创建状态从prototypesCurrentlyInCreation集合中移除掉
afterPrototypeCreation(beanName);
}
});
//因为有时候存在诸如BeanFactory的情况,并不是直接返回实例本身而是返回指定方法返回的实例
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();
}
}
//是否需要进行类型转换
return adaptBeanInstance(name, beanInstance, requiredType);
}
goGetBean方法流程小结
FactoryBean的使用
public interface FactoryBean<T> {
String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
@Nullable
T getObject() throws Exception;
@Nullable
Class<?> getObjectType();
//该方法可以不覆盖,则默认为单例bean
default boolean isSingleton() {
return true;
}
}
举个栗子:
public class MyFactoryBean implements FactoryBean {
@Override
public Object getObject() throws Exception {
return new Bean();
}
@Override
public Class<?> getObjectType() {
return Bean.class;
}
@Override
public boolean isSingleton() {
//原本就是default方法,默认返回true
return FactoryBean.super.isSingleton();
}
}
<bean id="bean" class="org.deepSpring.MyFactoryBean"></bean>
如果希望获取FactoryBean本身,则需要在beanName前面加上&前缀
xmlBeanFactory.getBean("&bean");
缓存中获取单例bean
让我们回到doGetBean方法的这一行代码来:
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
DefaultSingletonBeanRegistry#getSingleton—尝试从缓存或者ObjectFactory中获取单例bean
public Object getSingleton(String beanName) {
//true设置标识允许早期依赖
return getSingleton(beanName, true);
}
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// Quick check for existing instance without full singleton lock
//从单例缓冲池中检查缓存中是否存在对应的单例bean实例
Object singletonObject = this.singletonObjects.get(beanName);
//如果单例缓冲池中找不到并且当前beanName处于正在创建阶段的话
//isSingletonCurrentlyInCreation是通过singletonsCurrentlyInCreation集合来判断当前bean是否处于创建状态的
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//从早期单例对象的缓存获取缓存----这里earlySingletonObjects为什么存在,干啥的,暂时不管,后面进行揭秘
singletonObject = this.earlySingletonObjects.get(beanName);
//如果从单例缓冲池和早期单例缓冲池都找不到,并且如果可以创建早期引用###
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
// Consistent creation of early reference within full singleton lock
//这里是单例模式的双重锁校验实现,不知道各位有没有看出来
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
//直接看这里就可以了------->
//当某些方法需要提前初始化的时候则会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletonFactories
//对于允许提前爆料的bean来说,都会在创建过程中将自身关联的singletonFactory暴露出来
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//调用预先设定的getObject方法----》核心在于其中的createBean方法
singletonObject = singletonFactory.getObject();
//记录在缓存中，earlySingletonObjects和singletonFactories互斥关系
//singletonFactory负责提前暴露bean,既然这里已经暴露完了
//那么得到的bean就是earlySingletonObject，加入earlySingletonObjects缓存
//而当前singletonFactory就可以移除了
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
//返回最终创建生成的singletonObject
return singletonObject;
}
从Bean实例中获取对象—FactoryBean
AbstractBeanFactory#getObjectForBeanInstance—对bean是工厂类型进行特殊处理
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
//如果指定的name是工厂相关(以&为前缀)
if (BeanFactoryUtils.isFactoryDereference(name)) {
//如果beanInstance 是NullBean直接返回
if (beanInstance instanceof NullBean) {
return beanInstance;
}
//如果beanInstance不是FactoryBean就抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
//是FactoryBean类型的话,直接返回FactoryBean本身即可
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
//如果当前bean不是FactoryBean，只是普通的单例bean,那么直接返回即可
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
//到这里说明是FactoryBean
//加载FactoryBean
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
//第一次创建后,能放缓存就放缓存里面,这是spring的作风习惯！！！
//下一次再需要的时候,先看缓存
//尝试从缓存中加载bean---》factoryBeanObjectCache
//FactoryBeans 创建的单例对象的缓存：FactoryBean 名称到对象。
object = getCachedObjectForFactoryBean(beanName);
}
//缓存中没有
if (object == null) {
//因为已经知道了一定时FactoryBean类型
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
//如果传入的mdb为null,并且当前容器中包含这个beanName
if (mbd == null && containsBeanDefinition(beanName)) {
//getMergedLocalBeanDefinition见过了
//将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition,如果指定beanName是子bean的话,同时还会合并父类的相关属性
mbd = getMergedLocalBeanDefinition(beanName);
}
//是否是用户定义的而不是应用程序本身定义的
//如果是应用程序定义的返回false,否则返回true
boolean synthetic = (mbd != null && mbd.isSynthetic());
//这个方法很重要@@@----一般都是用户定义的，因此上面的synthetic为false,所以!synthetic为true
//该变量作用就在于用户的bean需要经过后置处理，而应用程序定义的bean不需要
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
FactoryBeanRegistrySupport#getObjectFromFactoryBean—从工厂bean中获取产品
/**
* Obtain an object to expose from the given FactoryBean.
* shouldPostProcess:当前bean是否需要进行后置处理
*/
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//是否是单例并且当然容器包含此beanName---这里的beanName是工厂bean,不是目的对象
if (factory.isSingleton() && containsSingleton(beanName)) {
//锁住了singletonObjects---全局变量,会有并发问题
synchronized (getSingletonMutex()) {
//尝试从FactoryBeans 创建的单例对象的缓存中寻找当前的beanName对应需要得到的目标对象
//factoryBeanObjectCache
Object object = this.factoryBeanObjectCache.get(beanName);
//如果缓存中没有
if (object == null) {
//尝试从工厂中获取
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
//如果当前bean需要进行后置处理器处理---如果是用户自定义的bean,这里默认都为true
if (shouldPostProcess) {
//检查当前bean是否正在创建中---singletonsCurrentlyInCreation
if (isSingletonCurrentlyInCreation(beanName)) {
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
//记录当前bean正在创建的状态到singletonsCurrentlyInCreation
beforeSingletonCreation(beanName);
try {
//这个地方比较重要,因为这里是我们第一次看到bean的后置处理器被调用的地方
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
//移除正在创建的状态
afterSingletonCreation(beanName);
}
}
//下面就很简单了:
//如果singletonObjects包含了当前beanName
if (containsSingleton(beanName)) {
//往工厂bean缓存中保存当前工厂bean生产的bean对象
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
//返回的是工厂getObject方法返回的对象
return object;
}
}
//工厂需要生产的bean不是单例的,那么就没有缓存池,所以每次都尝试去调用getObject方法返回一个新的对象
else {
//尝试调用工厂的getObject方法
Object object = doGetObjectFromFactoryBean(factory, beanName);
//如果当前bean需要进行后置处理器处理---如果是用户自定义的bean,这里默认都为true
if (shouldPostProcess) {
try {
//这个地方比较重要,因为这里是我们第一次看到bean的后置处理器被调用的地方
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
当然还少了一点,就是后置处理器的调用
AbstractAutowireCapableBeanFactory#postProcessObjectFromFactoryBean—FactoryBean的getObject方法调用后,遍历后置处理器进行后置处理
/**
* Applies the {@code postProcessAfterInitialization} callback of all
* registered BeanPostProcessors, giving them a chance to post-process the
* object obtained from FactoryBeans (for example, to auto-proxy them).
* @see #applyBeanPostProcessorsAfterInitialization
*/
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization—bean初始化(创建后)，进行后置处理,在这里(postProcessAfterInitialization)可以返回bean的代理对象
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//遍历所有已经注册好的BeanPostProcessor
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//调用他们的postProcessAfterInitialization方法,会传入当前创建出来的bean实例和beanName
Object current = processor.postProcessAfterInitialization(result, beanName);
//如果当前后置处理器返回null，说明不对当前bean的内容进行修改,返回原来的bean
if (current == null) {
return result;
}
//否则返回经过修改之后的bean---我们可以在这里对bean进行代理,然后返回bean的代理对象
result = current;
}
return result;
}
FactoryBeanRegistrySupport#doGetObjectFromFactoryBean—真正去调用工厂bean的getObject方法
/**
* Obtain an object to expose from the given FactoryBean.
*/
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
//需要权限验证后才能调用getObject方法
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
//调用getObject方法
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//直接调用getObject方法
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
//如果工厂返回的是null,那么就会返回一个NullBean()
object = new NullBean();
}
//返回工厂创建的对象
return object;
}
spring 3.0版本，是将后置处理的代码放在了doGetObjectFromFactoryBean的return语句之前进行判断窒息的，但是现在最新版本放到了getObjectFromFactoryBean方法中
获取单例
DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory)-----加载单例bean
/**
* Return the (raw) singleton object registered under the given name,
* creating and registering a new one if none registered yet.
* @param beanName the name of the bean
* @param singletonFactory the ObjectFactory to lazily create the singleton
* with, if necessary
* @return the registered singleton object
*/
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) {
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!)");
}
//这行日志如果平时注意的小伙伴,应该能看见---前提日志级别在debug模式下
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//getObjectFromFactoryBean方法也调用过---记录当前bean的创建状态-->singletonsCurrentlyInCreation
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//调用传入singletonFactory的getObject方法来初始化bean---实际调用的是传入的singletonFactory
//里面的createBean方法
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.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//这个在getObjectFromFactoryBean也调用,移除当前bean的创建状态--->singletonsCurrentlyInCreation
afterSingletonCreation(beanName);
}
//addSingleton干了啥:
//this.singletonObjects.put(beanName, singletonObject);
//this.singletonFactories.remove(beanName);
//this.earlySingletonObjects.remove(beanName);
//this.registeredSingletons.add(beanName);
//singletonFactories和earlySingletonObjects都是存放被提早创建的bean,但是注意这两个互斥
//而singletonObjects和registeredSingletons存放已经创建好的bean
//这里bean已经创建好了，那么就需要把当前bean从提早创建的bean相关集合中移除
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
DefaultSingletonBeanRegistry#beforeSingletonCreation—记录当前正要创建的bean到singletonsCurrentlyInCreation缓存中
/**
* Callback before singleton creation.
* <p>The default implementation register the singleton as currently in creation.
* @param beanName the name of the singleton about to be created
* @see #isSingletonCurrentlyInCreation
*/
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
DefaultSingletonBeanRegistry#afterSingletonCreation—从singletonsCurrentlyInCreation缓存中移除当前bean正在加载的状态记录
/**
* Callback after singleton creation.
* <p>The default implementation marks the singleton as not in creation anymore.
* @param beanName the name of the singleton that has been created
* @see #isSingletonCurrentlyInCreation
*/
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
DefaultSingletonBeanRegistry#addSingleton—新创建的bean加入单例bean缓冲池中
/**
* Add the given singleton object to the singleton cache of this factory.
* <p>To be called for eager registration of singletons.
* @param beanName the name of the bean
* @param singletonObject the singleton object
*/
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
ObjectFactory#getObject—调用ObjectFactory的getObject方法新创建一个单例bean实例
ObjectFactory是一个函数式接口:
@FunctionalInterface
public interface ObjectFactory<T> {
/**
* Return an instance (possibly shared or independent)
* of the object managed by this factory.
*/
T getObject() throws BeansException;
}
准备创建bean
AbstractAutowireCapableBeanFactory#createBean—创建bean前的准备
/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
* @see #doCreateBean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
//准备使用的BeanDefinition
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.
//解析出当前传入的BeanDefinition对应的Class对象---根据设置的class属性或者className来解析class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
//验证及准备覆盖的方法----一会进行分析！！！
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.
//给BeanPostProcessors一个机会来返回代理真正的实例---第一次讲到是在FactoryBean的getObject方法调用过后
//!!!!重点分析
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);
}
try {
//真正创建bean的动作
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
//返回创建后的bean实例
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);
}
}
AbstractBeanDefinition#prepareMethodOverrides—处理override属性
验证并准备为此 bean 定义的方法覆盖。检查具有指定名称的方法是否存在。
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
// Check that lookup methods exist and determine their overloaded status.
if (hasMethodOverrides()) {
//遍历BeanDefinition的Overrides集合---对每个MethodOverride执行prepareMethodOverride方法
getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
}
}
/**
* Validate and prepare the given method override.
* Checks for existence of a method with the specified name,
* marking it as not overloaded if none found.
*/
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
//获取对应类中对应方法名的个数
int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
if (count == 0) {
throw new BeanDefinitionValidationException(
"Invalid method override: no method with name '" + mo.getMethodName() +
"' on class [" + getBeanClassName() + "]");
}
else if (count == 1) {
// Mark override as not overloaded, to avoid the overhead of arg type checking.
//将覆盖标记为未重载，以避免 arg 类型检查的开销。
mo.setOverloaded(false);
}
}
AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation—实例化的前置处理
/**
* Apply before-instantiation post-processors, resolving whether there is a
* before-instantiation shortcut for the specified bean.
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @return the shortcut-determined bean instance, or {@code null} if none
*/
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
//beforeInstantiationResolved:包可见字段，指示实例化前的后处理器已启动
//这里对于第一次进入的RootBeanDefinition来说都还没被处理过,因此该值为NULL
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
//isSynthetic返回true说明当前RootBeanDefinition是应用程序本身创建的
//!isSynthenic说明是用户创建的,上面在FatoryBean创建bean的时候就讲到过
//只有用户创建的bean才需要经过后置处理器进行处理
//是否存在InstantiationAwareBeanPostProcessor的短路后置处理器
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//解析出当前bean的class类型
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//应用后置处理器返回一个bean
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
//如果返回的bean不为空,说明进行代理或者修改操作,然后紧接着应用AfterInitialization相关处理器
//如果为空,这里直接返回---不会执行下面这个后置处理器
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation—实例化前的后置处理器应用
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
return null;
}
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization—实例化后的后置处理器应用
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
//如果postProcessAfterInitialization方法返回的值不为null,那么会直接返回该值---替换原有传入的bean对象
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
applyBeanPostProcessorsAfterInitialization方法被调用的前提一定是在applyBeanPostProcessorsBeforeInstantiation方法处理后，返回的bean不为空才可以,这是上面编码写死的
因为bean的加载内容较多,因此这里打算剩下的内容放到下一集一起说完
相关文章
- 【01】Spring源码-手写篇-手写IoC实现
- Spring学习笔记（三）——Spring注解开发&spring与Junit整合测试
- Spring Framework 源码学习笔记（二）
- Spring Framework 源码学习笔记（六）
- java面试题 --- Spring②
- Spring中的AOP以及切入点表达式和各种通知
- 试试使用Spring Event组合@Async注解，轻松实现代码的解耦和异步
- 【03】Spring源码-手写篇-手写AOP实现(上)
- 【05】Spring源码-手写篇-手写Bean配置
- 【07】Spring源码-分析篇-refresh方法
- 解释spring框架中bean的生命周期_Spring bean的生命周期
- mybatis3源码解析--spring下mapper注册详解
- 从源码看Spring的i18n·优雅的国际化实战
- spring源码详解（一）
- Spring AOP详解
- 【Spring源码】- 07 扩展点之自定义标签
- Spring Cloud Gateway 的架构和核心组件（二）
- Spring Cloud Gateway路由的基本概念
- Spring Cloud Gateway监控配置示例
- Spring Cloud Security的核心组件-OAuth2示例
- Dubbo使用例子并且和Spring集成使用详解架构师
- drools6的kie-spring集成使用详解编程语言
- spring定时任务的几种实现方式详解编程语言
- Spring异常重试框架Spring Retry详解编程语言
- Spring Boot(十二)：spring boot如何测试打包部署详解编程语言
- Spring框架致力于搭建基于MSSQL的稳健开发体系（spring mssql）