Spring复习(九)之源码分析

从此句开始调试
//1 ioc容器的创建
ioc = new ClassPathXmlApplicationContext(“IOC.xml”);
进入ClassPathXmlApplicationContext类
调用构造方法

调用该类的三个参数的构造方法

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
        super(parent);
        this.setConfigLocations(configLocations);
        if (refresh) {
            this.refresh();
        }

    }

this.refresh();是关键一旦放行，所有单实例bean创建完成
进入改方法在AbstractApplicationContext类

 public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
        	
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                //支持国际化功能
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var5) {
                this.destroyBeans();
                this.cancelRefresh(var5);
                throw var5;
            }

        }
    }

研究以上方法
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
其中 ConfigurableListableBeanFactory的父接口 是BeanFactory（最终接口）

ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
Spring解析xml配置文件，将要创建的所有bean配置信息保存起来 （spring对XML的解析）

关键代码，运行此代码所有bean创建（初始化所有单实例bean的方法）
this.finishBeanFactoryInitialization(beanFactory);
进入此方法在AbstractApplicationContext 类中

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
            beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
        }

        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        String[] var3 = weaverAwareNames;
        int var4 = weaverAwareNames.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String weaverAwareName = var3[var5];
            this.getBean(weaverAwareName);
        }

        beanFactory.setTempClassLoader((ClassLoader)null);
        beanFactory.freezeConfiguration();
        beanFactory.preInstantiateSingletons();
    }

方法关键代码
初始化所有单实例bean

 beanFactory.preInstantiateSingletons();

进入方法在类中DefaultListableBeanFactory：bean工厂

public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Pre-instantiating singletons in " + this);
        }

        Map var2 = this.beanDefinitionMap;
        ArrayList beanNames;
        synchronized(this.beanDefinitionMap) {
        	//拿到bean的name,即所有要创建的bean
            beanNames = new ArrayList(this.beanDefinitionNames);
        }

        Iterator var8 = beanNames.iterator();
		//按顺序创建bean
        while(true) {
            while(true) {
                String beanName;
                //拿到bean的定义信息
                RootBeanDefinition bd;
                //这里需要说明的地方是代码中存在的三个do while循环
                //spring想表达的逻辑是当bean定义是懒加载，不是单例或者是抽象bean的情况下，会循环下去。
                //言外之意是当一个bean，既不是懒加载，并且是单例以及不是抽象的情况下，会跳出循环从而进入到getBean方法中进行bean的初始化。
                do {
                    do {
                        do {
                            if (!var8.hasNext()) {
                                return;
                            }

                            beanName = (String)var8.next();
                            bd = this.getMergedLocalBeanDefinition(beanName);
                        } while(bd.isAbstract());
                    } while(!bd.isSingleton());
                } while(bd.isLazyInit());
				//判断bean是否实现了一个FactoryBean接口的bean
                if (this.isFactoryBean(beanName)) {
                    final FactoryBean<?> factory = (FactoryBean)this.getBean("&" + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = ((Boolean)AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                            public Boolean run() {
                                return ((SmartFactoryBean)factory).isEagerInit();
                            }
                        }, this.getAccessControlContext())).booleanValue();
                    } else {
                        isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
                    }

                    if (isEagerInit) {
                        this.getBean(beanName);
                    }
                } else {
                    this.getBean(beanName);
                }
            }
        }
    }

方发关键代码，所有的bean创建

this.getBean(beanName);

进入方法在类中AbstractBeanFactory

public Object getBean(String name) throws BeansException {
    doGetBean(name, (Class)null, (Object[])null, false)
}

关键代码是在调doGetBean()

doGetBean(name, (Class)null, (Object[])null, false)

进入方法在类中AbstractBeanFactory

protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
        final String beanName = this.transformedBeanName(name);
        //先从缓存中检查
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        //先从已经注册的所有单实例bean中看有没有这个单实例bean,第一次创建时没有的
        if (sharedInstance != null && args == null) {
            if (this.logger.isDebugEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.debug("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 (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }

            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            try {
                final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                //拿到创建当前bean之前需要提前创建的bean。如果有就循环创建
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                //如果有就循环创建
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dependsOnBean = var11[var13];
                        if (this.isDependent(beanName, dependsOnBean)) {
                            throw new BeanCreationException("Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                        }

                        this.registerDependentBean(dependsOnBean, beanName);
                        this.getBean(dependsOnBean);
                    }
                }
				//如果mbd是单例的就创建bean实例
                if (mbd.isSingleton()) {
                	//
                    sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            try {
                                return AbstractBeanFactory.this.createBean(beanName, mbd, args);
                            } catch (BeansException var2) {
                                AbstractBeanFactory.this.destroySingleton(beanName);
                                throw var2;
                            }
                        }
                    });
                    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 '" + scopeName + "'");
                    }

                    try {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                            public Object getObject() throws BeansException {
                                AbstractBeanFactory.this.beforePrototypeCreation(beanName);

                                Object var1;
                                try {
                                    var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
                                } finally {
                                    AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                                }

                                return var1;
                            }
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var21) {
                        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", var21);
                    }
                }
            } catch (BeansException var23) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var23;
            }
        }

        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                return this.getTypeConverter().convertIfNecessary(bean, requiredType);
            } catch (TypeMismatchException var22) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Failed to convert bean '" + name + "' to required type [" + ClassUtils.getQualifiedName(requiredType) + "]", var22);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

关键代码

 sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            try {
                                return AbstractBeanFactory.this.createBean(beanName, mbd, args);
                            } catch (BeansException var2) {
                                AbstractBeanFactory.this.destroySingleton(beanName);
                                throw var2;
                            }
                        }
                    });

进入方法getSingleton 在类DefaultSingletonBeanRegistry中

 public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "'beanName' must not be null");
        Map var3 = this.singletonObjects;
        synchronized(this.singletonObjects) {
        //先从一个地方将bean get出来
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while the singletons of this factory are in destruction (Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }

                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }

                this.beforeSingletonCreation(beanName);
                boolean recordSuppressedExceptions = this.suppressedExceptions == null;
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet();
                }

                try {
                    //bean创建的过程
                    singletonObject = singletonFactory.getObject();
                } catch (BeanCreationException var14) {
                    BeanCreationException ex = var14;
                    if (recordSuppressedExceptions) {
                        Iterator var7 = this.suppressedExceptions.iterator();

                        while(var7.hasNext()) {
                            Exception suppressedException = (Exception)var7.next();
                            ex.addRelatedCause(suppressedException);
                        }
                    }

                    throw ex;
                } finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }

                    this.afterSingletonCreation(beanName);
                }
				
				//添加创建的bean
                this.addSingleton(beanName, singletonObject);
            }

            return singletonObject != NULL_OBJECT ? singletonObject : null;
        }
    }

关注三行代码
第一行

 //先从一个地方将bean get出来
Object singletonObject = this.singletonObjects.get(beanName);

分析
singletonObjects在DefaultSingletonBeanRegistry类中

//缓存所有的单实例bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap(64);

第二行
//bean创建的过程
singletonObject = singletonFactory.getObject();

第三行

//添加创建的bean
 this.addSingleton(beanName, singletonObject);

分析进入方法addSingleton
创建好的对象最终保存在一个map中singletonObjects
这就是IOC容器之一保存单实例bean

 protected void addSingleton(String beanName, Object singletonObject) {
        Map var3 = this.singletonObjects;
        synchronized(this.singletonObjects) {
            this.singletonObjects.put(beanName, singletonObject != null ? singletonObject : NULL_OBJECT);
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

Object person03 = ioc.getBean(“person03”);
AbstractApplicationContext类中的方法

public Object getBean(String name) throws BeansException {
        this.assertBeanFactoryActive();
        return this.getBeanFactory().getBean(name);
    }

进入getBean方法

public Object getBean(String name) throws BeansException {
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

进入doGetBean方法
//从map中拿bean

protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
Object sharedInstance = this.getSingleton(beanName);

BeanFactory和ApplicationContext的区别；

ApplicationContext是BeanFactory的子接口；
BeanFactory：bean工厂接口；负责创建bean实例；容器里面保存的所有单例bean其实是一个map；
Spring最底层的接口；
ApplicationContext：是容器接口；更多的负责容器功能的实现；（可以基于beanFactory创建好的对象之上完成强大的容器）
容器可以从map获取这个bean，并且aop。di。在ApplicationContext接口的下的这些类里面；

BeanFactory最底层的接口，ApplicationContext留给程序员使用的ioc容器接口；ApplicationContext是BeanFactory的子接口；
ApplicationContext

Spring里面最大的模式就是工厂模式；

  <bean class=""></bean>

      BeanFactory：bean工厂；工厂模式；帮用户创建bean