SpringIOC知其所以然
说到底,IOC的核心还是在这里,首先通过BeanDefinitionRegistry的实现类进行注册,让后再通过BeanFactory获取注册的Bean,获取的过程中通过反射获取。
一、BeanDefinitionRegistry接口的基本方法
上期看过了DefaultListableBeanFactory实现了两个顶级接口,BeanFactory和BeanDefinitionRegistry,如上一个博客所示类图,我想这个Date.class肯定是要进行反射的,但是我不确定是在注册bean的时候还是在getBean的时候,所以,我只能跟着程序去Debug。
首先我只能找BeanDefinitionRegistry接口的方法
只能贴代码了
//这个是注册调用的方法,beanName这个参数是注册的Key,beanDefinition代表的是我们注册的这个bean的定义类,猜想,继续看
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition)beanDefinition).validate();
} catch (BeanDefinitionValidationException var8) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var8);
}
}
//this.beanDefinitionMap这个在前面声明了,是一个currentHashMap,也就此印证了,Spring的IOC容器存储是一个currentHashMap
//这句话的意思应该是在注册这个bean的时候先去容器中拿,看看有没有,如果没有就继续下一步,如果有,就进行一些逻辑处理
BeanDefinition existingDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
if (!this.isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
if (existingDefinition.getRole() < beanDefinition.getRole()) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
} else if (!beanDefinition.equals(existingDefinition)) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
} else if (this.logger.isTraceEnabled()) {
this.logger.trace("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
this.beanDefinitionMap.put(beanName, beanDefinition);
} else {
if (this.hasBeanCreationStarted()) {
Map var4 = this.beanDefinitionMap;
//这里,使用同步,处理并发,这里有个问题,为什么要使用synchronized来把this.beanDefinitionMap这个进行同步处理?此问题等会百度一下,我的想法this.beanDefinitionMap如果在并发的时候,如果没有个先后顺序的话,可能会导致抢占存储空间,而导致死锁或者说死循环????啊啊啊,不行,这个得好好补一下集合这一块
synchronized(this.beanDefinitionMap) {
//这里应该充分说明了,这个注册的方法只不过是将我们对应的key和value放到容器里面
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
this.removeManualSingletonName(beanName);
}
} else {
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || this.containsSingleton(beanName)) {
this.resetBeanDefinition(beanName);
}
}
简单跟了一下这个注册的方法registerBeanDefinition,最终的结果是我们的class在这里并没有被转换成对象,而只是作为信息存储到了容器中,那就到下一步呢,应该Date.class的实例化的过程是在BeanFactory中实现的,所以,继续。。。
二、BeanFactory接口的基本方法
前面找了半天,没发现什么,但也不是徒劳无功,至少清楚了两个地方
- Spring的容器,实际上是一个HashMap
- 感觉有第二,但没想出来第二是啥,哈哈~(我觉得应该是synchronized(this.beanDefinitionMap) 这一句也算收获)
废话不多说,继续。。。看看getBean里面有一些什么玄机
//首先进去看到AbstractBeanFactory这里调用了这个方法,继续跟doGetBean方法
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
-------------------假装这是在找方法的过程---------------------------------
//这个方法好长、、、假装认真看一下吧
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
String beanName = this.transformedBeanName(name);
//感觉这里要看一下,应该是关于单例模式相关的,咱也没有证据,毕竟这货返回是个null
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return parentBeanFactory.getBean(nameToLookup);
}
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
try {
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dep = var11[var13];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
this.registerDependentBean(dep, beanName);
try {
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var24) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
}
}
}
//这里返回是true,判断对象是否是单例模式,也印证了SpringIOC注入时,默认是单例模式,这里面有个关键的值叫做scope,也就是以前在配置文件里面配置的scope,而这里默认为true的话,可以肯定的是,在上面的mbd实例化的时候,scope被默认成了singleton,具体在哪,RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);跟一下这个代码就很清楚
if (mbd.isSingleton()) {
//程序在这里跳出去了,而且很明显,这个方法就是创建bean用的,至于() -> {这个表达式是JDK1.8的新特性lambda表达式
//sharedInstance的生成过程就是Spring去反射的过程
// return this.createBean(beanName, mbd, args);重点在这里这一句,跟了一下代码,在此处,我们的Date.class被实例化成了Date对象
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
//这里sharedInstance实际上只是进去玩了一圈,成了bean,其实这里有一个东西我感觉我漏掉了,但是我觉得这个应该在后面的学习中会学习到,就是这个this.getObjectFromFactoryBean(factory, beanName, !synthetic); 这个记录一下,后面再来翻
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
String scopeName = mbd.getScope();
Scope 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, () -> {
this.beforePrototypeCreation(beanName);
Object var4;
try {
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var23) {
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", var23);
}
}
} catch (BeansException var26) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var26;
}
}
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
} else {
return convertedBean;
}
} catch (TypeMismatchException var25) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
} else {
return bean;
}
}
this.createBean(beanName, mbd, args)详解
代码太多,我也懒得贴了,画个图梳理一下吧
时序图太宽了,我就用流程图代替吧
最后到了Constructor这里进行反射
感觉现在已经懵逼了,已经搞清楚了流程,也把注册和获取bean串联起来,但是感觉还是差点什么,嗯,回头再想想,先到这,烂尾~~
总结
但是还是总结一下收获,根据代码现在大概理解了SpringIOC容器,其实并不是直接将类实例化注入容器,而是将类的定义存到了容器,当去获取Bean的时候,BeanFactory工厂才会去进行反射获取Bean,对于单例的Bean,工厂会在实例化之后将bean放到singletonObjects的这个ConcurrentHashMap中,下次再获取的时候,直接从singletonObjects容器中得到;