基本概念

ApplicationContext 繼承體系

本文主要關注ApplicationContext的繼承體系，至於BeanFactory的分支，以後再研究。

BeanFactory or ApplicationContext?

BeanFactory和ApplicationContext都是實現IoC容器的基礎介面。Application是BeanFactory的子介面，包含了BeanFactory的功能，同時增加了對Transactions和AOP的支援。所以官方更推薦開發者使用ApplicationContext及其子類實現IoC容器。特別地，Spring在實現時，大量使用ApplicationContext實現BeanPostProcessor extension point。

官方文件有如下闡述：
The BeanFactory provides the underlying basis for Spring’s IoC functionality but it is only used directly in integration with other third-party frameworks and is now largely historical in nature for most users of Spring.
只有在與第三方框架整合時，才推薦使用BeanFactory。

org.springframework.context.Interface ApplicationContext

All Superinterfaces:（繼承介面）
ApplicationEventPublisher, BeanFactory, EnvironmentCapable, HierarchicalBeanFactory, ListableBeanFactory, MessageSource, ResourceLoader, ResourcePatternResolver
ApplicationContext實現了上述介面，豐富了基本IoC容器（BeanFactory）的行為，可以說是一個高階的IoC容器。
從ApplicationContext介面的實現，我們看出其特點：
1. 支援資訊源，可以實現國際化。（實現MessageSource介面）
2. 訪問資源。(實現ResourcePatternResolver介面)
3. 支援應用事件。(實現ApplicationEventPublisher介面)
它的常用具體類有ClasspathXmlApplicationContext和FileSystemXmlApplicationContext，Web 專案方面有XmlWebApplicationContext。

IoC容器的初始化

IoC容器的初始化主要包括BeanDefinition的Resource定位、載入解析和註冊這三個基本的過程。我們以ApplicationContext為例講解。由於篇幅過大，這篇文章先詳細講解Resource定位。

建立：

ApplicationContext =new FileSystemXmlApplicationContext(xmlPath);

建構函式：分3步，分別是呼叫父類建構函式、setConfigLocations和refresh

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

1.super(parent)的作用是為容器設定Bean資源載入器，通過debug，可知實際是由其父類AbstractApplicationContext 完成設定。注意，從這裡可以看到AbstractApplicationContext 繼承了DefaultResourceLoader，所以實際上它自身也作為資源載入器。

AbstractApplicationContext.java

public abstract class AbstractApplicationContext extends DefaultResourceLoader  
        implements ConfigurableApplicationContext, DisposableBean 

public AbstractApplicationContext(ApplicationContext parent) {
    this();
    setParent(parent);
}        
public AbstractApplicationContext() {
    this.resourcePatternResolver = getResourcePatternResolver();
}
protected ResourcePatternResolver getResourcePatternResolver() {
    return new PathMatchingResourcePatternResolver(this);
}

2.接下來，setConfigLocations(configLocations)的作用是設定Bean定義資原始檔的路徑，實際是由其父類AbstractRefreshableConfigApplicationContext完成設定

AbstractRefreshableConfigApplicationContext.java

public abstract class AbstractRefreshableConfigApplicationContext extends AbstractRefreshableApplicationContext
        implements BeanNameAware, InitializingBean

//從這裡可以看到配置Bean定義資原始檔可以使用兩種方式，字串和字串陣列
//字串會以,; /t/n這些分隔符分割
//location="a.xml,b.xml,..."
public void setConfigLocation(String location) {
        //String CONFIG_LOCATION_DELIMITERS = ",; /t/n";  
       //即多個資原始檔路徑之間用” ,; /t/n”分隔，解析成陣列形式 
        setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS));
}
//location=new String[]{“a.xml”,”b.xml”,……} 
public void setConfigLocations(String... locations) {
        if (locations != null) {
            Assert.noNullElements(locations, "Config locations must not be null");
            this.configLocations = new String[locations.length];
            for (int i = 0; i < locations.length; i++) {
                // resolvePath為同一個類中將字串解析為路徑的方法  
                this.configLocations[i] = resolvePath(locations[i]).trim();
            }
        }
        else {
            this.configLocations = null;
        }
}

3.接下來是開始進行Bean定義資原始檔載入，由AbstractApplicationContext的refresh函式完成。
refresh函式是一個模板方法，執行多個方法，而且提供了各(protected)方法的（預設）實現，其子類可以重寫它們
模板方法模式：在一個方法中定義一個演算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類（使用protected方法）可以在不改變演算法結構的情況下，重新定義演算法中的某些步驟。
refresh函式中呼叫了多個方法，這裡先不詳細講解每一個方法，可以先通過英文註釋大概瞭解各方法的作用。

AbstractApplicationContext.java

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

refresh()核心呼叫方法1：obtainFreshBeanFactory函式呼叫，完成了容器初始化的最重要最基礎的功能，Bean定義資源的Resource定位、載入解析和註冊。

AbstractApplicationContext.java

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
}
protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

這裡使用了委派設計模式，obtainFreshBeanFactory中呼叫了兩個抽象方法，定義了obtainFreshBeanFactory的演算法骨架，實際的行為交給其子類（AbstractRefreshableApplicationContext）實現

AbstractRefreshableApplicationContext.java

    @Override
    protected final void refreshBeanFactory() throws BeansException {
        //如果已經有容器，銷燬容器中的bean，關閉容器，以保證在refresh之後使用的是新建立起來的IoC容器
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            //建立IoC容器
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            //對IoC容器進行定製化，如設定啟動引數，開啟註解的自動裝配等
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            //呼叫載入Bean定義的方法，這裡又使用了委派模式，在當前類中只定義了抽象的loadBeanDefinitions方法，具體的實現呼叫子類容器
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

在這個方法中，先判斷BeanFactory是否存在，如果存在則先銷燬beans並關閉beanFactory，接著建立DefaultListableBeanFactory，並呼叫loadBeanDefinitions(beanFactory)裝載bean
使用了委派模式，在當前類中只定義了抽象的loadBeanDefinitions方法，具體的實現呼叫子類容器（AbstractXmlApplicationContext）

AbstractXmlApplicationContext.java

@Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
        //建立XmlBeanDefinitionReader，即建立Bean讀取器，並通過回撥設定到容器中去，容器使用該讀取器讀取Bean定義資源
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's
        // resource loading environment.
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        //為Bean讀取器設定資源載入器，  
        //AbstractXmlApplicationContext的祖先父類AbstractApplicationContext繼承DefaultResourceLoader，
        //因此，容器本身也是一個資源載入器
        //所以，這個資源載入器由始至終都是容器自身
        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);
    }

呼叫了另一個過載函式loadBeanDefinitions(beanDefinitionReader)，委託給了XmlBeanDefinitionReader

AbstractXmlApplicationContext.java

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        //獲取Bean定義資源的定位
        Resource[] configResources = getConfigResources();
        if (configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }
        //如果configResources為空，則獲取FileSystemXmlApplicationContext構造方法中setConfigLocations方法設定的資源  
        String[] configLocations = getConfigLocations();
        if (configLocations != null) {
            //XmlBeanDefinitionReader呼叫其父類AbstractBeanDefinitionReader讀取定位的Bean定義資源
            reader.loadBeanDefinitions(configLocations);
        }
    }

這裡也使用了委託模式，呼叫子類的獲取Bean定義資源定位的方法（getConfigResources()），該方法在ClassPathXmlApplicationContext中實現，FileSystemXmlApplicationContext預設返回null。

由於FileSystemXmlApplicationContext的getConfigResources返回null，因此程式執行configLocations分支，呼叫XmlBeanDefinitionReader的父類AbstractBeanDefinitionReader的loadBeanDefinitions(String… locations)方法

AbstractBeanDefinitionReader.java

@Override
    public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
        Assert.notNull(locations, "Location array must not be null");
        int counter = 0;
        for (String location : locations) {
            counter += loadBeanDefinitions(location);
        }
        return counter;
    }

對每一個location呼叫loadBeanDefinitions，其抽象父類AbstractBeanDefinitionReader定義了方法骨架

AbstractBeanDefinitionReader.java

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
        //1.獲取在IoC容器初始化過程中設定的資源載入器，呼叫
        ResourceLoader resourceLoader = getResourceLoader();
        if (resourceLoader == null) {
            throw new BeanDefinitionStoreException(
                    "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
        }

        if (resourceLoader instanceof ResourcePatternResolver) {
            // Resource pattern matching available.
            try {
                //2.將指定位置的Bean定義資原始檔解析為Spring IoC容器封裝的資源（Resource）
                Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
                //3.委派呼叫其子類XmlBeanDefinitionReader的方法，載入Resource
                int loadCount = loadBeanDefinitions(resources);
                if (actualResources != null) {
                    for (Resource resource : resources) {
                        actualResources.add(resource);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
                }
                return loadCount;
            }
            catch (IOException ex) {
                throw new BeanDefinitionStoreException(
                        "Could not resolve bean definition resource pattern [" + location + "]", ex);
            }
        }
        else {
            // Can only load single resources by absolute URL.
            //和上面步驟2一樣，獲得Resource。實際呼叫的是DefaultResourceLoader中的getSource()方法定位Resource
            Resource resource = resourceLoader.getResource(location);
            int loadCount = loadBeanDefinitions(resource);
            if (actualResources != null) {
                actualResources.add(resource);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
            }
            return loadCount;
        }
    }

FileSystemXmlApplicationContext本身就是DefaultResourceLoader的實現類

意思是，AbstractBeanDefinitionReader中ResourceLoader resourceLoader = getResourceLoader(); 得到的是FileSystemXmlApplicationContext（AbstractApplicationContext）。
還記得在AbstractXmlApplicationContext中beanDefinitionReader.setResourceLoader(this); 為Bean讀取器設定的資源載入器，正是AbstractApplicationContext，因為繼承了DefaultResourceLoader，因此容器本身也是一個資源載入器

將指定位置的Bean定義資原始檔解析為IoC容器封裝的資源（Resource）的語句

Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
or
Resource resource = resourceLoader.getResource(location);

資源載入器獲取要讀入的資源（Resource）
實際上，呼叫了DefaultResourceLoader的getResource方法獲取Resource。

DefaultResourceLoader

@Override
    public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        if (location.startsWith("/")) {
            return getResourceByPath(location);
        }
        //如果是類路徑的方式，那需要使用ClassPathResource 來得到bean 檔案的資源物件
        else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
            return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
        }
        else {
            try {
                // Try to parse the location as a URL...
                URL url = new URL(location);
                return new UrlResource(url);
            }
            catch (MalformedURLException ex) {
                // No URL -> resolve as resource path.
                return getResourceByPath(location);
            }
        }
    }

至此，完成了Bean定義資源的Resource定位

總結一下從建立容器之後各個父類方法呼叫，不然就有點懵逼了！

接下來，開始Bean定義資源（已封裝成Resource）的載入解析

回到XmlBeanDefinitionReader的loadBeanDefinitions方法

XmlBeanDefinitionReader.java

@Override
    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        //將讀入的XML資源進行特殊編碼處理
        return loadBeanDefinitions(new EncodedResource(resource));
    }

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        Assert.notNull(encodedResource, "EncodedResource must not be null");
        if (logger.isInfoEnabled()) {
            logger.info("Loading XML bean definitions from " + encodedResource.getResource());
        }

        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
        if (currentResources == null) {
            currentResources = new HashSet<EncodedResource>(4);
            this.resourcesCurrentlyBeingLoaded.set(currentResources);
        }
        if (!currentResources.add(encodedResource)) {
            throw new BeanDefinitionStoreException(
                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        }
        try {
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {
                    inputSource.setEncoding(encodedResource.getEncoding());
                }
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }
            finally {
                inputStream.close();
            }
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "IOException parsing XML document from " + encodedResource.getResource(), ex);
        }
        finally {
            currentResources.remove(encodedResource);
            if (currentResources.isEmpty()) {
                this.resourcesCurrentlyBeingLoaded.remove();
            }
        }
    }