SpringIOC知其所以然

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 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接口的基本方法

前面找了半天，没发现什么，但也不是徒劳无功，至少清楚了两个地方

1. Spring的容器，实际上是一个HashMap
2. 感觉有第二，但没想出来第二是啥，哈哈~（我觉得应该是synchronized(this.beanDefinitionMap) 这一句也算收获）

废话不多说，继续。。。看看getBean里面有一些什么玄机

//首先进去看到AbstractBeanFactory这里调用了这个方法，继续跟doGetBean方法
    public Object getBean(String name) throws BeansException {
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

-------------------假装这是在找方法的过程---------------------------------

//这个方法好长、、、假装认真看一下吧
protected  T doGetBean(String name, @Nullable Class 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容器中得到；