/**

*提供应用程序配置的中央接口

*当应用程序运行时，这是只读的，但如果实现支持，则可以重新加载

*用于访问应用程序组件的Bean工厂方法

*以通用方式加载文件资源的能力

*拥有向注册侦听器发布事件的能力

*解析消息的能力，支持国际化

*为了让BeanFactory拥有生命周期，实现了一些类

*/

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,

        MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

    /**

     * 返回application context唯一的id

    String getId();

    /**

     *返回上下文中已经部署的应用程序的名称

     */

    String getApplicationName();

    /**

     * 返回一个展示名称

     */

    String getDisplayName();

    /**

     * 程序第一次加载时返回时间.

     */

    long getStartupDate();

    /**

     * 返回父应用程序

     */

    ApplicationContext getParent();

    /**

     * Expose AutowireCapableBeanFactory functionality for this context.

     */

    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

}

/**

*用于访问SpringBean容器的顶级接口

*根据bean的定义，工厂将返回包含对象的独立实例或者单例的对象

*HierarchicalBeanFactory是一个分层的Bean，如果实现了这个接口，所有方法都会经过父类的工厂。

* ListableBeanFactory这个接口是要实现预先加载Bean的配置，生成好实例，直接管理Bean的实例，而不是来一个请求，生成一个。

*/

public interface BeanFactory {

    /**

     * 用来获得实例的引用，并且区分FactoryBean区分。

     * 如果使用bean的名字myJndiObject获取FactoryBean,返回的是一个工厂，而不是工厂的实例；如果需要获得工厂实例，需要转义。

     */

    String FACTORY_BEAN_PREFIX = "&";

    /**

     * 根据bean的名称，获取指定的bean实例，该实例可以是共享的，也可以是独立的.

     */

    Object getBean(String name) throws BeansException;

    /**

     * 根据bean的名称，获取指定的bean实例，该实例可以是共享的，也可以是独立的.并且增加了一个类型的检验。

     */

    <T> T getBean(String name, Class<T> requiredType) throws BeansException;

    Object getBean(String name, Object... args) throws BeansException;

    /**

     * 根据给定类型返回匹配的bean实例.

     */

    <T> T getBean(Class<T> requiredType) throws BeansException;

    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

    /**

     * 检查spring的bean容器中是否包含有该bean

     */

    boolean containsBean(String name);

    /**

     * 判断bean的作用域是否是singleton

     */

    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    /**

     * 判断bena的作用域是否是prototype

     */

    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    /**

     * 检查给定名称的bean是否和指定类型匹配.更确却的说是通过检查给定的bean，返回指定类型的目标对象

     */

    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

    /**

     * 获取给定名称的bean的class类型

     */

    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

    /**

     * 获取给定bean名称的别名，如果根据别名检索，将会获得原始bean名称。

     *

    String[] getAliases(String name);

}

BeanFactory

public void refresh() throws BeansException, IllegalStateException {

    Object var1 = this.startupShutdownMonitor;

    //启动监控标识，并且同步此对象，防止同一时间有多个

    //线程加载

    synchronized(this.startupShutdownMonitor) {

        //初始化一些上下文参数

        this.prepareRefresh();

        //创建一个BeanFactory，进去后只有两个方法this.refreshBeanFactory();

        //return this.getBeanFactory();

        //具体的实现在它的父类AbstractRefreshableApplicationContext中

        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

        //为 此beanFactory初始化一些组件，比如：ClassLoadder等等

        this.prepareBeanFactory(beanFactory);

        try {

            //获取容器级别的后处理器，允许上下文的子类中对

            //beanFactory进行后处理，在应用上下文内部beanFactory

            //初始化之后可以修改beanFactory,此时所有的BeanDefinittions都

            //已经被加载，但未被实例化，具体的实现在AbstractRefreshableWebApplicationContext

            this.postProcessBeanFactory(beanFactory);

            /**在装配完成配置后执行这些后处理器，这里涉及到一些接口

            我们在开发时可以实现这些接口扩展功能，例如：

            InstantiationAwareBeanPostProcessor包含两个方法

            一个是在实例化前调用，一个在实例化后，初始化前调用

            可以用来做特殊作用，例如代理等等

            DestructionAwareBeanPostProcessor在销毁前调用

            */

            this.invokeBeanFactoryPostProcessors(beanFactory);

            /**

            把所有的bean的后处理器排序，在bean实例化后调用

            */

            this.registerBeanPostProcessors(beanFactory);

            //初始化国际化信息资源

            this.initMessageSource();

            //初始化事件多播组件，Event触发时由Multicaster

            //通知ApplicationListener

            this.initApplicationEventMulticaster();

            //空方法由子类扩展，可以在实例化bean之前

            //做一些ApplicationContext相关的操作

            this.onRefresh();

            //注册事件监听器

            this.registerListeners();

            //单例模式的bean实例 化，初始化等等完成

            this.finishBeanFactoryInitialization(beanFactory);

            //applicationContext刷新完成后的处理，

            //例如生命周期监听器的回调，广播通知等

            this.finishRefresh();

        } catch (BeansException var9) {

            if(this.logger.isWarnEnabled()) {

                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);

            }

            //如果加载失败，则清理环境相关的信息

            this.destroyBeans();

            //把applicationContext的active设置成false

            this.cancelRefresh(var9);

            throw var9;

        } finally {

            //清理一些缓存

            this.resetCommonCaches();

        }

    }

}

    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

        refreshBeanFactory();

        ConfigurableListableBeanFactory beanFactory = getBeanFactory();

        if (logger.isDebugEnabled()) {

            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

        }

        return beanFactory;

    }

    @Override

    protected final void refreshBeanFactory() throws BeansException {

        if (hasBeanFactory()) {

            //如果存在就销毁重建

            destroyBeans();

            closeBeanFactory();

        }

        try {

             //创建一个DefaultListableBeanFactory作为Bean的

             //管理工厂类

             DefaultListableBeanFactory beanFactory = createBeanFactory();

            //加载自定义的beanFactory

            beanFactory.setSerializationId(getId());

            customizeBeanFactory(beanFactory);

            //加载beanDefinition，关系这个类加载的东西比较多

            //可以单分析

            loadBeanDefinitions(beanFactory);

            synchronized (this.beanFactoryMonitor) {

                this.beanFactory = beanFactory;

            }

        }

        catch (IOException ex) {

            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

        }

    }

    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

        // Create a new XmlBeanDefinitionReader for the given BeanFactory.

        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's

        // resource loading environment.

        beanDefinitionReader.setEnvironment(this.getEnvironment());

        beanDefinitionReader.setResourceLoader(this);

        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        // Allow a subclass to provide custom initialization of the reader,

        // then proceed with actually loading the bean definitions.

        initBeanDefinitionReader(beanDefinitionReader);

        loadBeanDefinitions(beanDefinitionReader);

    }

    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

        Resource[] configResources = getConfigResources();

        if (configResources != null) {

            reader.loadBeanDefinitions(configResources);

        }

        String[] configLocations = getConfigLocations();

        if (configLocations != null) {

            reader.loadBeanDefinitions(configLocations);

        }

    }

    @Override

    public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {

        NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args);

        if (namedBean != null) {

            return namedBean.getBeanInstance();

        }

        BeanFactory parent = getParentBeanFactory();

        if (parent != null) {

            return parent.getBean(requiredType, args);

        }

        throw new NoSuchBeanDefinitionException(requiredType);

    }

    private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {

        List<String> result = new ArrayList<String>();

        // Check all bean definitions.

        for (String beanName : this.beanDefinitionNames) {

            // Only consider bean as eligible if the bean name

            // is not defined as alias for some other bean.

            if (!isAlias(beanName)) {

                try {

                    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

                    // Only check bean definition if it is complete.

                    if (!mbd.isAbstract() && (allowEagerInit ||

                            ((mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading())) &&

                                    !requiresEagerInitForType(mbd.getFactoryBeanName()))) {

                        // In case of FactoryBean, match object created by FactoryBean.

                        boolean isFactoryBean = isFactoryBean(beanName, mbd);

                        BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();

                        boolean matchFound =

                                (allowEagerInit || !isFactoryBean ||

                                        (dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&

                                (includeNonSingletons ||

                                        (dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&

                                isTypeMatch(beanName, type);

                        if (!matchFound && isFactoryBean) {

                            // In case of FactoryBean, try to match FactoryBean instance itself next.

                            beanName = FACTORY_BEAN_PREFIX + beanName;

                            matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);

                        }

                        if (matchFound) {

                            result.add(beanName);

                        }

                    }

                }

                catch (CannotLoadBeanClassException ex) {

                    if (allowEagerInit) {

                        throw ex;

                    }

                    // Probably contains a placeholder: let's ignore it for type matching purposes.

                    if (this.logger.isDebugEnabled()) {

                        this.logger.debug("Ignoring bean class loading failure for bean '" + beanName + "'", ex);

                    }

                    onSuppressedException(ex);

                }

                catch (BeanDefinitionStoreException ex) {

                    if (allowEagerInit) {

                        throw ex;

                    }

                    // Probably contains a placeholder: let's ignore it for type matching purposes.

                    if (this.logger.isDebugEnabled()) {

                        this.logger.debug("Ignoring unresolvable metadata in bean definition '" + beanName + "'", ex);

                    }

                    onSuppressedException(ex);

                }

            }

        }

        // Check manually registered singletons too.

        for (String beanName : this.manualSingletonNames) {

            try {

                // In case of FactoryBean, match object created by FactoryBean.

                if (isFactoryBean(beanName)) {

                    if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {

                        result.add(beanName);

                        // Match found for this bean: do not match FactoryBean itself anymore.

                        continue;

                    }

                    // In case of FactoryBean, try to match FactoryBean itself next.

                    beanName = FACTORY_BEAN_PREFIX + beanName;

                }

                // Match raw bean instance (might be raw FactoryBean).

                if (isTypeMatch(beanName, type)) {

                    result.add(beanName);

                }

            }

            catch (NoSuchBeanDefinitionException ex) {

                // Shouldn't happen - probably a result of circular reference resolution...

                if (logger.isDebugEnabled()) {

                    logger.debug("Failed to check manually registered singleton with name '" + beanName + "'", ex);

                }

            }

        }

        return StringUtils.toStringArray(result);

    }