对Spring ioc的启动分析

未来我未来

    IOC:
        1、IOC是一个容器
        2、容器启动的时候创建所有单实例对象
        3、我们可以直接从容器中获取到这个对象
    SpringlOC:
        1）、ioc容器的启动过程？启动期间都做了什么（什么时候创建所有单实例bean)
        2）、ioc是如何创建这些单实例bean，并如何管理的；
        3）、到底保存在了哪里？

public ClassPathxmlApplicationcontext(string[] configlocations,boolean refresh,Applicationcontext parent) throws BeansException{
    super(parent)；
    setconfigLocations(configLocations)；
    if(refresh){
       refresh()；
    }
}



public void refresh() throws BeansException, IllegalStateException {
    //同步锁，保证多线程情况下ioc容器只会创建1次
    synchronized(this.startupShutdownMonitor) {
       //容器刷新
        this.prepareRefresh();


       //Spring解析.xml文件
        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();
            
            //初始化所有单实例bean
            this.finishBeanFactoryInitialization(beanFactory);

            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }
            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }
    }
}



finishBeanFactoryInitialization(beanFactory)；实现
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //类型转换
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
            public String resolveStringValue(String strVal) {
                return AbstractApplicationContext.this.getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }
    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();
    //初始化单实例bean
    beanFactory.preInstantiateSingletons();
}
preInstantiateSingletons();在DefaultListableBeanFactory类下
DefaultListableBeanFactory:bean工厂；创建bean
public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Pre-instantiating singletons in " + this);
    }


    //拿到所有要创建的bean的名字
    List<String> beanNames = new ArrayList(this.beanDefinitionNames);
    Iterator var2 = beanNames.iterator();
    while(true) {
        while(true) {
           //bean名字
            String beanName;
            //bean的定义信息
            RootBeanDefinition bd;
            do {
                do {
                    do {
                        if (!var2.hasNext()) {
                            var2 = beanNames.iterator();
                            while(var2.hasNext()) {
                                beanName = (String)var2.next();
                                Object singletonInstance = this.getSingleton(beanName);
                                if (singletonInstance instanceof SmartInitializingSingleton) {
                                    final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                    if (System.getSecurityManager() != null) {
                                        AccessController.doPrivileged(new PrivilegedAction<Object>() {
                                            public Object run() {
                                                smartSingleton.afterSingletonsInstantiated();
                                                return null;
                                            }
                                        }, this.getAccessControlContext());
                                    } else {
                                        smartSingleton.afterSingletonsInstantiated();
                                    }
                                }
                            }
                            return;
                        }
                        beanName = (String)var2.next();
                        bd = this.getMergedLocalBeanDefinition(beanName);
                    } while(bd.isAbstract());
                } while(!bd.isSingleton());
            } while(bd.isLazyInit());
            //是否实现了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());
                } else {
                    isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
                }
                if (isEagerInit) {
                    this.getBean(beanName);//调getbean
                }
            } else {
                   this.getBean(beanName);//调getbean
            }
        }
    }
}



this.getBean(beanName);创建bean细节
public Object getBean(String name) throws BeansException {
    return this.doGetBean(name, (Class)null, (Object[])null, false);
}
都是掉doGetBean
调用doGetBean(name, (Class)null, (Object[])null, false);
protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
    final String beanName = this.transformedBeanName(name);
    //先从已经注册的所有单实例bean中看有没有bean
    Object sharedInstance = this.getSingleton(beanName);
    Object 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。depends-on属性；如果有就创建
            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);
                    }
                }
            }
                       //创建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 name '" + 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 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 && bean != null && !requiredType.isInstance(bean)) {
        try {
            return this.getTypeConverter().convertIfNecessary(bean, requiredType);
        } catch (TypeMismatchException var25) {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    } else {
        return bean;
    }
}
getSingleton(beanName, new ObjectFactory<Object>()方法
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "'beanName' must not be null");
    synchronized(this.singletonObjects) {
        //把bean  get出来 见1
        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!)");
            }
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            this.beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = this.suppressedExceptions == null;
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet();
            }
            try {
                //创建bean 见2
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            } catch (IllegalStateException var16) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw var16;
                }
            } catch (BeanCreationException var17) {
                BeanCreationException ex = var17;
                if (recordSuppressedExceptions) {
                    Iterator var8 = this.suppressedExceptions.iterator();
                    while(var8.hasNext()) {
                        Exception suppressedException = (Exception)var8.next();
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            } finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                this.afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                //添加创建bean
                this.addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject != NULL_OBJECT ? singletonObject : null;
    }
}


DefaultSingletonBeanRegistry
1.
private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
2.
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}
3.
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized(this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject != null ? singletonObject : NULL_OBJECT);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}
ioc容器之一：
创建好的对象最终保存在map里-->DefaultSingletonBeanRegistry-->singletonObjects

---

BeanFactory和ApplicationContext的区别；

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

ApplicationContextSpring里面最大的模式就是工厂模式；
        <bean class=""></bean>
        BeanFactory:bean工厂；工厂模式；帮用户创建bean