Spring IOC源碼分析（一）

時間 2020-06-08

標籤 spring ioc 源碼分析欄目 Spring 简体版

原文原文鏈接

1.Spring IOC源碼分析（一）

Spring IOC容器通常是指兩個：BeanFactory和ApplicationContext。BeanFactory是最頂層的接口，提供了IOC最基本的功能，可是沒法提供AOP、WEB等高級特性。ApplicationContext實現了BeanFactory，是一個高級接口，在BeanFactory的基礎上作了擴展，支持諸多高級特性，如BeanFactory不支持的AOP、WEB，還有國際化、事件監聽、加載資源文件的能力等。目前在實際應用中，咱們都是使用的ApplicationContext。java

它實現的這些接口都代表了它具備的能力。node

ApplicationContext的部分實現類圖： web

上述類圖中三個紅色框框住的類是Spring中經常使用的三個ApplicationContext實現類。ClassPathXmlApplicationContext是基於XML文件的；AnnotationConfigApplicationContext和AnnotationConfigWebApplicationContext都是基於註解的。spring

1.基於XML的`BeanDefinition`初始化

1.初始化

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
複製代碼

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    this(new String[] {configLocation}, true, null);
}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {

    //1.到AbstractApplicationContext設置父容器，parent=NULL
    super(parent);
    //2.到AbstractRefreshableConfigApplicationContext設置資源路徑
    setConfigLocations(configLocations);
    //3.默認爲true
    if (refresh) {
        refresh();
    }
}
複製代碼

從這部分源碼能夠看出來，咱們經過傳入BeanDefinition資源文件去實例化ClassPathXmlApplicationContext的時候，ClassPathXmlApplicationContext經歷了三步：1.爲當前容器設置父容器；2.設置資源文件路徑；3.刷新容器。設計模式

1.設置父容器

public AbstractXmlApplicationContext(ApplicationContext parent) {
    super(parent);
}

public AbstractRefreshableConfigApplicationContext(ApplicationContext parent) {
    super(parent);
}

public AbstractRefreshableApplicationContext(ApplicationContext parent) {
    super(parent);
}

public AbstractApplicationContext(ApplicationContext parent) {
    //1.調用默認的構造方法，獲取ResourcePatterResolver
    this();
    //2.設置父容器
    setParent(parent);
}
複製代碼

從這部分源碼能夠看出，設置父容器的時候會一路調用父類的構造方法，直到AbstractApplicationContext，AbstractApplicationContext調用本身的無參構造方和設置父容器的方法。數組

public AbstractApplicationContext() {
    //1.設置資源路徑解析器
    this.resourcePatternResolver = getResourcePatternResolver();
}

/** * 初始化一個路徑匹配的資源路徑解析器 */
protected ResourcePatternResolver getResourcePatternResolver() {
    //AbstractApplicationContext繼承DefaultResourceLoader，所以也是一個ResourceLoader
    //根據路徑匹配的資源路徑解析器
    return new PathMatchingResourcePatternResolver(this);
}

@Override
public void setParent(ApplicationContext parent) {
    //1.parent爲NULL
    this.parent = parent;
    if (parent != null) {
        Environment parentEnvironment = parent.getEnvironment();
        if (parentEnvironment instanceof ConfigurableEnvironment) {
            getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
        }
    }
}
複製代碼

AbstractApplicationContext實例化完成以後會一直回調子類的構造方法直到ClassPathXmlApplicationContext，下面執行setConfigLocations()。緩存

2.設置資源文件路徑

/** * org.springframework.context.support.AbstractRefreshableConfigApplicationContext#setConfigLocations * 將傳入的字符串解析爲資源路徑 */
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++) {
            //將字符串解析爲路徑
            this.configLocations[i] = resolvePath(locations[i]).trim();
        }
    }
    else {
        this.configLocations = null;
    }
}

/** * org.springframework.context.support.AbstractRefreshableConfigApplicationContext#resolvePath * 解析給定的路徑，並替換${} */
protected String resolvePath(String path) {
    return getEnvironment().resolveRequiredPlaceholders(path);
}

/** * org.springframework.context.support.AbstractApplicationContext#getEnvironment * 獲取當前容器環境 */
@Override
public ConfigurableEnvironment getEnvironment() {
    //1.若是爲NULL，建立一個StandardEnvironment
    if (this.environment == null) {
        this.environment = createEnvironment();
    }
    //2.直接返回
    return this.environment;
}
複製代碼

上述源碼解析了給定的String可變數組，resolveRequiredPlaceHolders()方法主要是解析給定的字符串是否使用了佔位符，在後面也被頻繁用到。app

2.刷新容器

上面的步驟初始化了咱們的容器而且知道了資源文件路徑所在位置，那麼這一步就是解析給定的XML資源文件路徑。ide

/** * org.springframework.context.support.AbstractApplicationContext#refresh */
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        //1.準備刷新上下文的方法，設置了啓動時間和激活標誌，以及執行屬性源的任何初始化（Servlet）
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        //2.告訴子類去刷新內部的bean factory，子類的refreshBeanFactory方法真實的加載了bean definition 資源文件
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        //3.配置標準的bean factory，如ClassLoader、BeanPostProcessor、初始化回調等
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            //4.容許對bean factory的上下文子類註冊特殊的BeanPostProcessor，默認沒有實現
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            //5.實例化應用上下文中全部的BeanFactoryPostProcessor,並執行
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            //6.實例化並註冊BeanPostProcessor，攔截bean的實例化
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            //7.初始化信息源，與國際化有關
            initMessageSource();

            // Initialize event multicaster for this context.
            //8.初始化應用事件傳播器
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            //9.調用子類某些特殊bean的實例化,由子類實現，默認什麼都不作
            onRefresh();

            // Check for listener beans and register them.
            //10.爲事件傳播器註冊事件監聽器
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            //11.預實例化剩餘的非懶加載的單例bean（就是beanDefinitionMap中），會觸發回調
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            //12.發佈事件
            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.
            //13.銷燬已經建立的單例bean，避免資源懸空
            destroyBeans();

            // Reset 'active' flag.
            //14.取消刷新，重置激活標誌
            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...
            //15.自省緩存，可能咱們再也不須要單例bean的元數據，這在Spring core是常見的
            resetCommonCaches();
        }
    }
}
複製代碼

refresh()一個模板方法，定義了Spring IOC容器初始化的固定步驟，但一些具體的方法交由子類實現。refresh()方法的主要做用：在註冊IOC容器以前，若是容器已經存在，則須要把已有的容器銷燬和關閉。以保障在refresh以後使用的是新建立的IOC容器，緩存解析XML文件獲得的BeanDefinition，最後進行一些類的實例化。源碼分析

1.加載

/** * org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory */
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	//1.這裏使用了委派設計模式，父類定義了抽象的refreshBeanFactory方法，具體實現調用子類容器
    //的refreshBeanFactory方法
    refreshBeanFactory();
    //2.獲取子類建立的內部BeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
}
複製代碼

obtainFreshBeanFactory()告訴子類刷新或建立內部BeanFactory，這個內部BeanFactory真正的存儲了BeanDefinition。而後再從子類中獲取這個內部BeanFactory，也就可以拿到整個的beanDefinitionMap了，也就能夠繼續refresh()方法下面的操做了，如BeanFactoryPostProcessor、BeanPostPostProcessor等。

/** * org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory */
@Override
protected final void refreshBeanFactory() throws BeansException {
    //1.若是已經有容器， 銷燬容器中的bean，並關閉容器
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        //2.建立內部IOC容器
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
        //3.定製化BeanFactory，如是否容許bean定義重寫、是否容許循環引用
        customizeBeanFactory(beanFactory);
        //4.加載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爲DefaultListableBeanFactory，這個類繼承了DefaultSingletonBeanRegistry * org.springframework.context.support.AbstractRefreshableApplicationContext#createBeanFactory */
protected DefaultListableBeanFactory createBeanFactory() {
    return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

/** * 內部BeanFactory的父容器 * org.springframework.context.support.AbstractApplicationContext#getInternalParentBeanFactory */
protected BeanFactory getInternalParentBeanFactory() {
    //通常是NULL
    return (getParent() instanceof ConfigurableApplicationContext) ?
        ((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
}

/** * 定製化內部BeanFactory * org.springframework.context.support.AbstractRefreshableApplicationContext#customizeBeanFactory */
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    //1.是否容許重寫BeanDefinition，默認true
    if (this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    //2.是否容許循環引用，默認true
    if (this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences);
    }
}
複製代碼

上面這幾步就建立了一個內部的BeanFactory，下面就是調用loadBeanDefinitions()加載了。

/** * 加載父類委派的bean definition經過XmlBeanDefinitionReader * org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // Create a new XmlBeanDefinitionReader for the given BeanFactory.
    //1.建立XmlBeanDefinitionReader，即建立Bean讀取器，並經過回調設置到容器中去，容器使用該讀取器讀取Bean定義資源
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    // Configure the bean definition reader with this context's
    // resource loading environment.
    //2.重置Environment和ResourceLoader，這裏的this是ClassPathXmlApplicationContext
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    //3.爲Bean讀取器設置SAX Xml解析器
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

    // Allow a subclass to provide custom initialization of the reader,
    // then proceed with actually loading the bean definitions.
    //4.當Bean讀取器讀取Bean定義的xml資源文件時，啓用Xml的校驗機制，例如SAX使用.xsd文件驗證xml文件
    initBeanDefinitionReader(beanDefinitionReader);
    //5.真正的加載bean definitions
    loadBeanDefinitions(beanDefinitionReader);
}

/** * 建立XMLBeanDefinition讀取器，也會建立其父類AbstractBeanDefinitionReader * @param registry */
public XmlBeanDefinitionReader(BeanDefinitionRegistry registry) {
    super(registry);
}

/** * 若是給定的beanFactory即實現了ResourceLoader，又實現了BeanDefinitionRegistry，則爲ResourceLoader * 若是給定的beanFactory實現了EnvironmentCapable，則爲EnvironmentCapable，不然爲StandardEnvironment * org.springframework.beans.factory.support.AbstractBeanDefinitionReader#AbstractBeanDefinitionReader */
protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    //1.DefaultListableBeanFactory是BeanDefinitionRegistry的子類
    this.registry = registry;

    // Determine ResourceLoader to use.
    if (this.registry instanceof ResourceLoader) {
        this.resourceLoader = (ResourceLoader) this.registry;
    }
    else {
        this.resourceLoader = new PathMatchingResourcePatternResolver();
    }

    // Inherit Environment if possible
    if (this.registry instanceof EnvironmentCapable) {
        this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
    }
    else {
        this.environment = new StandardEnvironment();
    }
}

/** * 建立一個實體解析器，這是java SAX中的 * @param resourceLoader */
public ResourceEntityResolver(ResourceLoader resourceLoader) {
    super(resourceLoader.getClassLoader());
    this.resourceLoader = resourceLoader;
}


/** * 根據不一樣的namespace找不到不一樣的EntityResolver * @param classLoader */
public DelegatingEntityResolver(ClassLoader classLoader) {
    //1.namespace是.dtd的
    this.dtdResolver = new BeansDtdResolver();
    //2.namespace是.xsd
    this.schemaResolver = new PluggableSchemaResolver(classLoader);
}

/** * Xml Bean讀取器獲取要加載的資源 * org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions */
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    //1.獲取Bean定義資源位置，以前初始化ClassPathXmlApplicationContext的時候是設置了AbstractRefreshableConfigApplicationContextd的configLocations，因此這裏爲NULL
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    //2.若是上一步獲取爲null，
    //則從org.springframework.context.support.AbstractRefreshableConfigApplicationContext獲取configLocations
    //若是configLocations爲NULL，則從org.springframework.web.context.support.XmlWebApplicationContext#getDefaultConfigLocations
    // 獲取默認的public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml";
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        //調用父類AbstractBeanDefinitionReader的方法根據配置文件進行加載
        reader.loadBeanDefinitions(configLocations);
    }
}
複製代碼

上面咱們已經拿到了XmlBeanDefinitionReader，知道了資源的路徑，下面就是按照路徑真正的記載資源了。

//重載方法，調用loadBeanDefinitions(String)
@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;
}

//重載方法，調用loadBeanDefinitions(String,Set<Resource>)
@Override
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
    return loadBeanDefinitions(location, null);
}

/** * 真正的獲取資源 * org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions */
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
    //1.獲取以前的設置的資源加載器
    ResourceLoader resourceLoader = getResourceLoader();
    if (resourceLoader == null) {
        throw new BeanDefinitionStoreException(
            "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
    }

    //2.由於ApplicationContext實現了ResourcePatternResolver接口，因此會走這裏
    if (resourceLoader instanceof ResourcePatternResolver) {
        // Resource pattern matching available.
        try {
            //3.將指定位置的bean定義資源文件解析爲Spring IOC容器封裝的資源
            Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
            //4.委派調用其子類XmlBeanDefinitionReader的方法， 實現加載功能
            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.
        //5.將指定位置的Bean定義資源文件解析爲Spring IOC容器封裝的資源
        Resource resource = resourceLoader.getResource(location);
        //6.委派調用其子類XmlBeanDefinitionReader的方法， 實現加載功能
        int loadCount = loadBeanDefinitions(resource);
        if (actualResources != null) {
            actualResources.add(resource);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
        }
        return loadCount;
    }
}

/** * org.springframework.context.support.AbstractApplicationContext#getResources */
@Override
public Resource[] getResources(String locationPattern) throws IOException {
    //調用PathMatchingResourcePatternResolver
    return this.resourcePatternResolver.getResources(locationPattern);
}

/** * 將給定的資源文件路徑轉爲Resource * org.springframework.core.io.support.PathMatchingResourcePatternResolver#getResources */
@Override
public Resource[] getResources(String locationPattern) throws IOException {
    Assert.notNull(locationPattern, "Location pattern must not be null");
    //1.classpath*:，類路徑資源
    if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
        // a class path resource (multiple resources for same name possible)
        //2.一個類路徑，可能包含多個資源，如classpath*:spring-*.xml
        if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
            // a class path resource pattern
            return findPathMatchingResources(locationPattern);
        }
        else {
            // all class path resources with the given name
            //3.全部給定名稱的資源路徑classpath*:spring-dao.xml,spring-service.xml,spring-web.xml
            return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
        }
    }
    else {
        // Generally only look for a pattern after a prefix here,
        // and on Tomcat only after the "*/" separator for its "war:" protocol.
        int prefixEnd = (locationPattern.startsWith("war:") ? locationPattern.indexOf("*/") + 1 :
                         locationPattern.indexOf(':') + 1);
        if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
            // a file pattern
            return findPathMatchingResources(locationPattern);
        }
        else {
            //5.給定名稱的單個資源文件，會走這裏
            // a single resource with the given name
            return new Resource[] {getResourceLoader().getResource(locationPattern)};
        }
    }
}

/** * AbstractApplicationContext繼承了DefaultResourceLoader，由於沒有重寫，因此會走到這裏 * org.springframework.core.io.DefaultResourceLoader#getResource */
@Override
public Resource getResource(String location) {
    Assert.notNull(location, "Location must not be null");

    for (ProtocolResolver protocolResolver : this.protocolResolvers) {
        Resource resource = protocolResolver.resolve(location, this);
        if (resource != null) {
            return resource;
        }
    }

    //1.給定的路徑,ClassPathContextResource
    if (location.startsWith("/")) {
        return getResourceByPath(location);
    }
    //2.//若是是類路徑的方式，那須要使用ClassPathResource來獲得bean文件對象，classpath開頭
    else if (location.startsWith(CLASSPATH_URL_PREFIX)) {

        return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
    }
    //3.若是是URL形式，使用UrlResource做爲資源文件對象
    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.
            //若是既不是classpath，又不是url標識的Resource定位，則調用容器自己的getResourceByPath方法獲取Resource
            return getResourceByPath(location);
        }
    }
}

/** * 拿到類路徑資源 */
public ClassPathResource(String path, ClassLoader classLoader) {
    Assert.notNull(path, "Path must not be null");
    String pathToUse = StringUtils.cleanPath(path);
    if (pathToUse.startsWith("/")) {
        pathToUse = pathToUse.substring(1);
    }
    this.path = pathToUse; //applicationContext.xml
    this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
}

/** * 遍歷Resource * org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions */
@Override
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
    Assert.notNull(resources, "Resource array must not be null");
    int counter = 0;
    for (Resource resource : resources) {
        //這裏調用XmlBeanDefinitionReader的實現
        counter += loadBeanDefinitions(resource);
    }
    return counter;
}
複製代碼

這部分源碼展現了Spring如何將一個資源路徑名稱轉爲了可用的資源。首先遍歷configLocations，通過一系列的重載方法以後，先調用AbstractApplicationContext#getResource()，而後調用PathMatchingResourcePatternResolver#getResource（PathMatchingResourcePatterResolver是在初始化ClassPathXmlApplicationContext的時候就已經初始化了），最後調用DefaultResourceLoader#getResource根據給定的路徑形式轉爲不一樣的Resource（AbstractApplicationContext繼承了DefaultResourceLoader），因爲是classpath:applicationContext.xml，因此這裏拿到的是ClassPathResource。

/** * XmlBeanDefinitionReader加載資源的入口方法 * org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions */
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    //對資源進行編碼處理
    return loadBeanDefinitions(new EncodedResource(resource));
}

/** * 重載方法 * org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions */
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);
    }

    //1.線程單例
    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 {
        //2.將資源文件轉爲InputStream的IO流
        InputStream inputStream = encodedResource.getResource().getInputStream();
        try {
            //3.從InputStream中獲得XML的解析源
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            //4.具體的加載過程
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
        finally {
            //5.關閉流
            inputStream.close();
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException(
            "IOException parsing XML document from " + encodedResource.getResource(), ex);
    }
    finally {
        //6.移除
        currentResources.remove(encodedResource);
        if (currentResources.isEmpty()) {
            this.resourcesCurrentlyBeingLoaded.remove();
        }
    }
}

/** * 從指定的xml文件中真實的加載bean definition * org.springframework.beans.factory.xml.XmlBeanDefinitionReader#doLoadBeanDefinitions */
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
    try {
        //1.將XML文件轉爲Java DOM對象，解析過程由DocumentLoader實現
        Document doc = doLoadDocument(inputSource, resource);
        //2.這裏是啓動對Bean定義解析的詳細過程，該解析過程會用到Spring的Bean配置規則
        return registerBeanDefinitions(doc, resource);
    }
    catch (BeanDefinitionStoreException ex) {
        throw ex;
    }
    catch (SAXParseException ex) {
        throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                                                  "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
    }
    catch (SAXException ex) {
        throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                                                  "XML document from " + resource + " is invalid", ex);
    }
    catch (ParserConfigurationException ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                                               "Parser configuration exception parsing XML from " + resource, ex);
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                                               "IOException parsing XML document from " + resource, ex);
    }
    catch (Throwable ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                                               "Unexpected exception parsing XML document from " + resource, ex);
    }
}

/** * 根據DocumentLoader建立Document * org.springframework.beans.factory.xml.XmlBeanDefinitionReader#doLoadDocument */
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
    return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
                                            getValidationModeForResource(resource), isNamespaceAware());
}


/** * 使用標準的JAXP將載入的BeanDefinition資源轉換成Document對象 * org.springframework.beans.factory.xml.DefaultDocumentLoader#loadDocument */
@Override
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver, ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
    //1.建立文件解析工廠：驗證，命名空間
    DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
    if (logger.isDebugEnabled()) {
        logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
    }
    //2.建立文檔解析器：實體解析器，錯誤處理器
    DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
    //3.將Resource轉爲Document
    return builder.parse(inputSource);
}
複製代碼

上述源碼將Resource轉爲了Document，Document是JAXP的標準實現，用於操做XML文件，這裏拿到了Document，下一步就能夠根據Document去解析具體的標籤了。

2.註冊

/** * 根據DOM註冊Bean Definition * org.springframework.beans.factory.xml.XmlBeanDefinitionReader#registerBeanDefinitions */
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    //1.獲得BeanDefinitionDocumentReader來對XML格式的Bean Definition解析
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    //2.獲取容器中註冊的bean的數量
    int countBefore = getRegistry().getBeanDefinitionCount();
    //3.解析過程入口，這裏使用了委派模式，BeanDefinitionDocumentReader只是個接口，
    //具體的解析過程由DefaultBeanDefinitionDocumentReader去實現的
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    //4.統計解析的Bean數量
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

/** * 根據Spring DTO對Bean的定義規則解析Bean定義Document對象 * org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#registerBeanDefinitions */
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    //1.得到XML描述符
    this.readerContext = readerContext;
    logger.debug("Loading bean definitions");
    //2.得到Document的根元素，<beans/>
    Element root = doc.getDocumentElement();
    doRegisterBeanDefinitions(root);
}

/** * 註冊根標籤的下的每一個字標籤 * org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions */
protected void doRegisterBeanDefinitions(Element root) {
    // Any nested <beans> elements will cause recursion in this method. In
    // order to propagate and preserve <beans> default-* attributes correctly,
    // keep track of the current (parent) delegate, which may be null. Create
    // the new (child) delegate with a reference to the parent for fallback purposes,
    // then ultimately reset this.delegate back to its original (parent) reference.
    // this behavior emulates a stack of delegates without actually necessitating one.
    // 只要嵌l<beans/>標籤，都將致使該方法的遞歸。爲了正確的保留<beans/>的default-*屬性，根據當前（父）委託，能夠爲NULL。
    // 建立新的（子）委託，並帶有對父級的引用，以進行回退，而後最終將this.delegate重置回到原始（父）引用。
    // 此行爲模擬了一組委託，但實際沒有必要
    //1.標籤的解析由BeanDefinitionParseDelegate完成
    //BeanDefinitionParserDelegate中定義了Spring Bean定義XML文件中的各類元素
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);

    //2.判斷Profile
    if (this.delegate.isDefaultNamespace(root)) {
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
        if (StringUtils.hasText(profileSpec)) {
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                if (logger.isInfoEnabled()) {
                    logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                "] not matching: " + getReaderContext().getResource());
                }
                return;
            }
        }
    }

    //3.在解析Bean定義以前，進行自定義的解析，增長解析過程的可擴展性，這個方法默認沒實現，須要客戶重寫定義
    preProcessXml(root);
    //4.從Document的根元素開始進行Bean定義的Document對象，這裏遇到<beans/>會遞歸
    parseBeanDefinitions(root, this.delegate);
    //5.在解析Bean定義以後，進行自定義的解析，增長解析過程的可擴展性，這個方法默認沒實現，須要客戶重寫定義
    postProcessXml(root);

    this.delegate = parent;
}

/** * 使用Spring的Bean規則從Document的根元素開始進行Bean定義的Document對象 * org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions */
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    //1.Bean定義的Document對象使用了Spring默認的XML命名空間（即：http://www.springframework.org/schema/beans）
    if (delegate.isDefaultNamespace(root)) {
        //2.獲取Bean定義的Document對象根元素的全部子節點
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            //3.得到的Document節點是XML元素節點
            if (node instanceof Element) {
                Element ele = (Element) node;
                //4.BeanDefinition的Document的元素節點使用的是不是Spring默認的命名空間
                if (delegate.isDefaultNamespace(ele)) {
                    //5.使用Spring的Bean規則解析元素節點
                    parseDefaultElement(ele, delegate);
                }
                else {
                    //6.沒有使用Spring默認的XML命名空間，則使用用戶自定義的規則解析元素節點（如：http://www.springframework.org/schema/context）
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        //7.Document的根節點沒有使用Spring默認的命名空間，則使用用戶自定義的解析規則解析Document節點
        delegate.parseCustomElement(root);
    }
}

/** * 使用Spring的Bean規則解析Document元素節點 * org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement */
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    //1.若是元素節點是<import/>標籤，進行導入解析
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    //2.若是元素節點是<alias/>標籤，進行別名解析
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    //3.若是元素節點是<bean/>標籤，則按照Spring的Bean規則解析元素
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
    //4.若是元素節點是<beans/>標籤，則遞歸
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        doRegisterBeanDefinitions(ele);
    }
}

/** * 解析<bean/>標籤，並注入到註冊表中 * org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition */
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    //1.BeanDefinitionHolder是對BeanDefinition的封裝，包含BeanDefinition、beanName、aliases
    //對Document對象中的<bean/>標籤的解析由BeanDefinitionParserDelegate完成
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // Register the final decorated instance.
            //3.向IOC容器註冊解析獲得的BeanDefinition，這是BeanDefinition向IOC容器註冊的接口
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                                     bdHolder.getBeanName() + "'", ele, ex);
        }
        // Send registration event.
        //4.發送註冊完成事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

/** * 解析BeanDefinition標籤 * org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement */
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    return parseBeanDefinitionElement(ele, null);
}

/** * 解析BeanDefinition資源文件中的<bean/>標籤，這個方法主要處理<bean/>標籤的id、name屬性 * org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement */
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    //1.獲取<bean/>的id屬性值
    String id = ele.getAttribute(ID_ATTRIBUTE);
    //2.獲取<bean/>的name屬性值
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    //3.解析多個別名，使用分隔號，public static final String MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; ";
    List<String> aliases = new ArrayList<String>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    //4.若是<bean/>標籤中不存在id屬性，則以name屬性的第一個值做爲beanName
    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = aliases.remove(0);
        if (logger.isDebugEnabled()) {
            logger.debug("No XML 'id' specified - using '" + beanName +
                         "' as bean name and " + aliases + " as aliases");
        }
    }

    //5.containingBean是判斷<bean/>標籤是否包含子<bean/>標籤
    //檢查<bean/>的id和name惟一性
    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }

    //6.詳細的對<bean/>標籤中配置的BeanDefinition進行解析的地方
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                        beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    // Register an alias for the plain bean class name, if still possible,
                    // if the generator returned the class name plus a suffix.
                    // This is expected for Spring 1.2/2.0 backwards compatibility.
                    String beanClassName = beanDefinition.getBeanClassName();
                    if (beanClassName != null &&
                        beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                        !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                        aliases.add(beanClassName);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Neither XML 'id' nor 'name' specified - " +
                                 "using generated bean name [" + beanName + "]");
                }
            }
            catch (Exception ex) {
                error(ex.getMessage(), ele);
                return null;
            }
        }
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}


/** * 解析BeanDefinition自己，不考慮id和name屬性 * org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement */
public AbstractBeanDefinition parseBeanDefinitionElement( Element ele, String beanName, BeanDefinition containingBean) {
    //1.記錄解析的bean
    this.parseState.push(new BeanEntry(beanName));

    //2.讀取<bean/>的class屬性
    String className = null;
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }

    try {
        //3.讀取<bean/>的parent屬性
        String parent = null;
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }

        //4.根據<bean/>標籤配置的class屬性和parent屬性建立BeanDefinition，爲載入BeanDefinition信息作準備
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        //5.對當前<bean/>標籤中的一些屬性進行解析和設置，如scope等
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        //6.爲<bean/>標籤解析的BeanDefinition設置description信息
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        //7.對<bean/>標籤的meta屬性進行解析
        parseMetaElements(ele, bd);
        //8.對<bean/>標籤的look-up屬性進行解析
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        //9.對<bean/>標籤的replaced-method屬性進行解析
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        //10.對<bean/>標籤中的<constructor-arg/>構造方法標籤進行解析
        parseConstructorArgElements(ele, bd);
        //11.對<bean/>標籤中的<property/>set方法標籤進行解析
        parsePropertyElements(ele, bd);
        //12.對<bean/>標籤中的<qualifier/>別名標籤進行解析（多個實現類標識）
        parseQualifierElements(ele, bd);

        //13.爲當前的bean設置所需的資源和依賴對象
        bd.setResource(this.readerContext.getResource());
        bd.setSource(extractSource(ele));

        return bd;
    }
    catch (ClassNotFoundException ex) {
        error("Bean class [" + className + "] not found", ele, ex);
    }
    catch (NoClassDefFoundError err) {
        error("Class that bean class [" + className + "] depends on not found", ele, err);
    }
    catch (Throwable ex) {
        error("Unexpected failure during bean definition parsing", ele, ex);
    }
    finally {
        this.parseState.pop();
    }

    return null;
}

/** * 建立了BeanDefinition * org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#createBeanDefinition */
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName) throws ClassNotFoundException {

    return BeanDefinitionReaderUtils.createBeanDefinition(
        parentName, className, this.readerContext.getBeanClassLoader());
}

/** * 注入到IOC容器中 * org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition */
public static void registerBeanDefinition( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {

    // Register bean definition under primary name.
    //這裏的registry其實就是DefaultListableBeanFactory
    //1.獲取解析的BeanDefinition的名稱
    String beanName = definitionHolder.getBeanName();
    //2.向IOC容器註冊BeanDefinition
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    //3.若是BeanDefinition有別名，則註冊別名
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}
複製代碼

上述源碼展示了Spring建立BeanDefinition、解析Document中的標籤爲BeanDefinition設置屬性、將BeanDefinition注入到IOC容器的總體流程。

總結一下：

1.當建立ClassPathApplicationContext的時候，首先會建立父類，若是有父容器，會先設置父容器，而後會初始化一個路徑解析器PathMatchResourcePatternResolver。

2.根據構造方法中的configLocations來解析XML文件所在的類路徑，若是有佔位符，須要使用資源解析器PropertyResolver去替換佔位符

3.當上述的準備工做完成以後，就經過一個模板方法AbstractApplicationContext#refresh去刷新容器；首先會建立或者獲取一個已經存在的內部BeanFactory，而後調用一個loadBeanDefinitions方法；也就到了AbstractXmlApplicationContext，該類會建立一個XmlBeanDefinitionReader類，這個類會將給定路徑的XML文件轉爲Resource，而後將這個Resource轉爲Document對象；拿到了Document，也就能夠解析XML文件的每一個標籤了，因而DefaultBeanDefinitionDocumentReader就產生了，這個類用於順序遍歷整個XML文件中的每一個標籤；拿到遍歷的每一個標籤，由BeanDefinitionParseDelegate具體的去解析每一個標籤的屬性以及其子標籤等，這裏有個注意點，若是XML的namespace是beans，則使用Spring的Bean規則解析節點，若是非beans，則解析該節點的namespaceuri，獲取對應的處理器去進行處理。

4.解析標籤以後拿到了BeanDefinition、beanName、aliases，將這三個封裝爲一個BeanDefinitionHolder，而後經過BeanDefinitionReaderUtils#registerBeanDefinition將BeanDefinitionHolder注入到BeanDefinitionRegistry中，這裏BeanDefinitionRegistry其實就是DefaultListableBeanFactory。

2.基於註解的`BeanDefinition`初始化

在Spring中有兩個註解處理類：AnnotationConfigApplicationContext和AnnotationConfigWebApplicationContext。AnnotationConfigWebApplicationContext是AnnotationConfigApplicationContext的WEB版本，咱們能夠在web.xml中配置該處理類，web.xml默認是XmlWebApplicationContext。當咱們在applicationConext.xml中配置<context:annotation-config/>的時候將會使用AnnotationConfigApplicationContext。

這兩個註解都是用來掃描被這兩個註解@Configuration和@Component所註解的Bean。@Component是一個元註解，被它所註解的註解也能被掃描。如：@Controller、@Service、@Repository等。

1.`AnnotationConfigApplicationContext`

1.初始化

AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext("com.ly");
MyComponent component = annotationConfigApplicationContext.getBean(MyComponent.class);

/** * 該構造方法會自動掃描給定的包及其子包下的全部類，並自動識別全部的Spring Bean，將其註冊到容器中 */
public AnnotationConfigApplicationContext(String... basePackages) {
    this();
    //1.掃描注入BeanDefinition
    scan(basePackages);
    //2.手動刷新，到AbstractApplicationContext#refresh
    refresh();
}

/** * 默認構造方法，初始化一個空容器，容器不包含任何Bean信息，須要在稍後經過調用其register() * 方法註冊配置類，或調用scan()掃描寶，並手動調用refresh()方法刷新容器，觸發容器對註解Bean的載入、解析和註冊過程 */
public AnnotationConfigApplicationContext() {
    //1.保存一個讀取註解的BeanDefinition讀取器，並將其設置到容器中，用於讀取指定的Configuration類
    this.reader = new AnnotatedBeanDefinitionReader(this);
    //2.保存一個掃描指定類路徑中註解BeanDefinition掃描器，並將其設置到容器中，
    //用於掃描給定的包及其子包下的Configuration類
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}
複製代碼

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    this(registry, getOrCreateEnvironment(registry));
}

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    Assert.notNull(environment, "Environment must not be null");
    //1.AnnotationConfigApplicationContext
    this.registry = registry;
    //2.條件評價器
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    //3.註冊和註解相關的處理器
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

/** * 註冊註解相關處理器到註冊表中 * org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors */
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    registerAnnotationConfigProcessors(registry, null);
}

/** * 註冊註解相關的處理器到註冊表中 * org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors */
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, Object source) {
    //獲取內部BeanFactory，在GenericApplicationContext的構造方法中已經建立了
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(8);

    //1.增長ConfigurationAnnotationProcessor，處理@Configuration和@Bean
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    //2.增長AutowiredAnnotationProcessor，處理@Autowired、@Value、@Inject
    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    //3.RequiredAnnotationProcessor，處理@Required
    if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    //4.處理@PreDestory、@PostConstruct、@Resource、@EJB、@WebServiceRef
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    //5.處理@PersistenceUnit、@PersistenceContext
    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition();
        try {
            def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                                                AnnotationConfigUtils.class.getClassLoader()));
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
        }
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    //6.增長EventListenerProcessor，處理@EventListener
    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    //7.增長EventListenerFactory，支持@EventListener的工廠
    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

/** * 注入到IOC容器 * org.springframework.context.annotation.AnnotationConfigUtils#registerPostProcessor */
private static BeanDefinitionHolder registerPostProcessor( BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

    //1.BeanDefinition的角色
    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    //2.注入到IOC容器
    registry.registerBeanDefinition(beanName, definition);
    return new BeanDefinitionHolder(definition, beanName);
}
複製代碼

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
    this(registry, true);
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
    this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) {

    this(registry, useDefaultFilters, environment,
         (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}

/** * 爲容器建立一個ClassPathBeanDefinitionScanner，並指定是否使用默認的過濾規則 * 即Spring默認配置掃描：@Component、@Repository、@Service、@Controller註解的Bean * 同時也支持JAVAEE6的@ManagedBean和SR-330的@Named */
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, ResourceLoader resourceLoader) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    //1.爲容器設置加載BeanDefinition的註冊器
    this.registry = registry;
    //2.是否使用默認過濾
    if (useDefaultFilters) {
        registerDefaultFilters();
    }
    setEnvironment(environment);
    //3.資源加載器
    setResourceLoader(resourceLoader);
}

/** * 註冊默認過濾器 */
protected void registerDefaultFilters() {
    //1.@Component元註解自己及其被它註解的註解
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    try {
        //2.JSR-250的@ManagedBean
        this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
        logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
    }
    catch (ClassNotFoundException ex) {
        // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
    }
    try {
        //3.JSR-330的@Named
        this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
        logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
    }
    catch (ClassNotFoundException ex) {
        // JSR-330 API not available - simply skip.
    }
}
複製代碼

上述構造方法會初始化兩個重要的類：AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner。AnnotatedBeanDefinitionReader用來處理指定的Configuration類；ClassPathBeanDefinitionScanner用來掃描包中的配置類。

2.加載註冊

/** * 掃描指定指定包路徑及其子包下的註解類，爲了使新添加的類被註冊，必須手動調用 * 容器的refresh()刷新容器 * org.springframework.context.annotation.AnnotationConfigApplicationContext#scan */
public void scan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    this.scanner.scan(basePackages);
}


/** * 根據指定的類路徑進行掃描 * org.springframework.context.annotation.ClassPathBeanDefinitionScanner#scan */
public int scan(String... basePackages) {
    //1.獲取容器中已經註冊的Bean的數量
    int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

    //2.啓動自動掃描器掃描給定包
    doScan(basePackages);

    // Register annotation config processors, if necessary.
    //3.註冊註解配置處理器（初始化AnnotationConfigApplicationContext的時候可能容器裏面可能已經註冊過了）
    if (this.includeAnnotationConfig) {
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }
    //4.返回註冊Bean的個數
    return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}

/** * ClassPathBeanDefinitionScanner掃描給定包及其子包 * org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan */
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
    //1.遍歷給定的包
    for (String basePackage : basePackages) {
        //2.查好當前包符合被註解註釋的BeanDefinition
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
        //3.遍歷當前包符合的BeanDefinition
        for (BeanDefinition candidate : candidates) {
            //4.解析@Scope元信息
            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            candidate.setScope(scopeMetadata.getScopeName());
            //5.經過BeanNameGenerator生成beanName
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
            //6.若是掃描的Bean是AbstractBeanDefinition，爲Bean設置默認值
            if (candidate instanceof AbstractBeanDefinition) {
                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
            }
            //7.若是掃描的Bean是Spring的註解Bean，則處理通用註解
            if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }
            //8.檢查生成的beanName是否和容器中已經存在的發生衝突
            if (checkCandidate(beanName, candidate)) {
                //9.封裝成BeanDefinitionHolder，包括BeanDefinition、beanName、aliases
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                //10.根據@Scope的proxyMode判斷是否要生成代理對象
                definitionHolder =
                    AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                //11.向IOC容器注入代理Bean
                registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }
    return beanDefinitions;
}

/** * 掃描類路徑，查找合適候選組件 * org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents */
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
    try {
        //1.拼接:classpath*:com/ly/**/*.class 表示當前包及其子包的class文件
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        //2.經過PathMatchingResourcePatterResolver轉爲Resource，這裏拿到的是對應包及其子包的下的全部類，可是後面會過濾
        Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
        boolean traceEnabled = logger.isTraceEnabled();
        boolean debugEnabled = logger.isDebugEnabled();
        for (Resource resource : resources) {
            if (traceEnabled) {
                logger.trace("Scanning " + resource);
            }
            if (resource.isReadable()) {
                try {
                    //3.獲取元信息
                    MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                    //4.根據構造方法設置的過濾器進行過濾，是否被相應註解註解了
                    if (isCandidateComponent(metadataReader)) {
                        ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                        sbd.setResource(resource);
                        sbd.setSource(resource);
                        //5.檢查該BeanDefinition是否是接口、抽象類等組件，若是是，則不須要實例化
                        if (isCandidateComponent(sbd)) {
                            if (debugEnabled) {
                                logger.debug("Identified candidate component class: " + resource);
                            }
                            candidates.add(sbd);
                        }
                        else {
                            if (debugEnabled) {
                                logger.debug("Ignored because not a concrete top-level class: " + resource);
                            }
                        }
                    }
                    else {
                        if (traceEnabled) {
                            logger.trace("Ignored because not matching any filter: " + resource);
                        }
                    }
                }
                catch (Throwable ex) {
                    throw new BeanDefinitionStoreException(
                        "Failed to read candidate component class: " + resource, ex);
                }
            }
            else {
                if (traceEnabled) {
                    logger.trace("Ignored because not readable: " + resource);
                }
            }
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
    }
    return candidates;
}

/** * 解析AnnotationBeanDefintion的做用域元信息 * org.springframework.context.annotation.AnnotationScopeMetadataResolver#resolveScopeMetadata */
@Override
public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
    ScopeMetadata metadata = new ScopeMetadata();
    if (definition instanceof AnnotatedBeanDefinition) {
        AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
        //1.從AnnotationBeanDefinition的屬性中查找屬性爲"Scope"的值，即@Scope註解的值
        //annDef.getMetadata().getAnnotationAttributes()方法將Bean中全部的註解
        //和註解的值存放在一個Map集合中
        AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(
            annDef.getMetadata(), this.scopeAnnotationType);
        //2.將獲取到的@Scope註解中的值設置到要返回的對象中
        if (attributes != null) {
            metadata.setScopeName(attributes.getString("value"));
            //3.代理模式：默認是NO，還支持INTERFACES(cglib)、TARGET_CLASS(jdk)
            ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
            if (proxyMode == null || proxyMode == ScopedProxyMode.DEFAULT) {
                proxyMode = this.defaultProxyMode;
            }
            metadata.setScopedProxyMode(proxyMode);
        }
    }
    return metadata;
}

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
    processCommonDefinitionAnnotations(abd, abd.getMetadata());
}

/** * 處理BeanDefinition通用註解 * org.springframework.context.annotation.AnnotationConfigUtils#processCommonDefinitionAnnotations */
static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
    //1.處理@Lazy，獲取其值並設置到BeanDefinition中
    if (metadata.isAnnotated(Lazy.class.getName())) {
        abd.setLazyInit(attributesFor(metadata, Lazy.class).getBoolean("value"));
    }
    else if (abd.getMetadata() != metadata && abd.getMetadata().isAnnotated(Lazy.class.getName())) {
        abd.setLazyInit(attributesFor(abd.getMetadata(), Lazy.class).getBoolean("value"));
    }

    //2.若是Bean中有@Primary註解，則按類型自動裝配時，做爲第一候選
    if (metadata.isAnnotated(Primary.class.getName())) {
        abd.setPrimary(true);
    }
    //3.若是Bean中有@DependsOn註解，則爲該Bean設置所依賴的Bean名稱
    //容器將確保在實例化該Bean以前首先實例化依賴的Bean
    if (metadata.isAnnotated(DependsOn.class.getName())) {
        abd.setDependsOn(attributesFor(metadata, DependsOn.class).getStringArray("value"));
    }

    if (abd instanceof AbstractBeanDefinition) {
        AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
        if (metadata.isAnnotated(Role.class.getName())) {
            absBd.setRole(attributesFor(metadata, Role.class).getNumber("value").intValue());
        }
        if (metadata.isAnnotated(Description.class.getName())) {
            absBd.setDescription(attributesFor(metadata, Description.class).getString("value"));
        }
    }
}


/** * 根據做用域應用代理模式 * org.springframework.context.annotation.AnnotationConfigUtils#applyScopedProxyMode */
static BeanDefinitionHolder applyScopedProxyMode( ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {

    //1.獲取@Scope中的proxyMode值
    ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
    //2.若是是NO，不代理
    if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
        return definition;
    }

    //3.判斷是JDK動態代理，仍是CGLIB
    boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
    return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}

/** * 建立Proxy Bean以便AOP使用 * org.springframework.context.annotation.ScopedProxyCreator#createScopedProxy */
public static BeanDefinitionHolder createScopedProxy( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry, boolean proxyTargetClass) {

    return ScopedProxyUtils.createScopedProxy(definitionHolder, registry, proxyTargetClass);
}

/** * 注入原始BeanDefinition，並返回代理BeanDefinition * org.springframework.aop.scope.ScopedProxyUtils#createScopedProxy */
public static BeanDefinitionHolder createScopedProxy(BeanDefinitionHolder definition, BeanDefinitionRegistry registry, boolean proxyTargetClass) {

    //1.原始BeanDefinition信息
    String originalBeanName = definition.getBeanName();
    BeanDefinition targetDefinition = definition.getBeanDefinition();
    //2.重寫beanName
    String targetBeanName = getTargetBeanName(originalBeanName);

    // Create a scoped proxy definition for the original bean name,
    // "hiding" the target bean in an internal target definition.
    //3.建立代理BeanDefinition，並設置相關屬性
    RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
    proxyDefinition.setDecoratedDefinition(new BeanDefinitionHolder(targetDefinition, targetBeanName));
    proxyDefinition.setOriginatingBeanDefinition(targetDefinition);
    proxyDefinition.setSource(definition.getSource());
    proxyDefinition.setRole(targetDefinition.getRole());

    proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);
    if (proxyTargetClass) {
        targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
        // ScopedProxyFactoryBean's "proxyTargetClass" default is TRUE, so we don't need to set it explicitly here.
    }
    else {
        proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
    }

    // Copy autowire settings from original bean definition.
    proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
    proxyDefinition.setPrimary(targetDefinition.isPrimary());
    if (targetDefinition instanceof AbstractBeanDefinition) {
        proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
    }

    // The target bean should be ignored in favor of the scoped proxy.
    targetDefinition.setAutowireCandidate(false);
    targetDefinition.setPrimary(false);

    // Register the target bean as separate bean in the factory.
    //4.注入原始BeanDefinition，可是名稱是重寫以後的beanName，而代理BeanDefinition使用原始的beanName
    // 這樣咱們拿到的Bean雖然名稱是咱們注入的那個，可是本質上已經成爲了代理Bean
    registry.registerBeanDefinition(targetBeanName, targetDefinition);

    // Return the scoped proxy definition as primary bean definition
    // (potentially an inner bean).
    //5.返回代理BeanDefinition並注入IOC容器
    return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
}

/** * 註冊BeanDefinition到IOC容器，不管註解仍是XML，最後都是走這一步 * @param definitionHolder * @param registry */
protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}

/** * 注入到IOC容器中 * org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition */
public static void registerBeanDefinition( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {

    // Register bean definition under primary name.
    //這裏的registry其實就是DefaultListableBeanFactory
    //1.獲取解析的BeanDefinition的名稱
    String beanName = definitionHolder.getBeanName();
    //2.向IOC容器註冊BeanDefinition
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    //3.若是BeanDefinition有別名，則註冊別名
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}
複製代碼

AnnotationConfigApplicationContext經過掃描給定的包路徑進行解析，拿到該包及其子包的全部類，而後進行兩步過濾：第一次過濾該類是否被對應的註解進行註解了，若是註解了進行下一次過濾；第二步過濾該類是否是接口或抽象類，若是是，則不須要實例化。而後解析該類所擁有的註解，設置BeanDefinition相關屬性，生成beanName等。最後判斷是否要生成代理對象，最後將BeanDefinition注入到IOC容器中。

3.刷新

這裏就又到了AbstractApplicationContext#refresh()方法，也就與基於XML的初始化一致了，最主要的不一樣在於，AnnotationConfigApplicationContext是由本身掃碼並註冊BeanDefinition的，而ClassPathXmlApplicationContext是在org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory中註冊BeanDefinition的。

總結一下：

1.調用構造方法初始化當前類和其父類，會初始化兩個重要的類：AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner，前者用於讀取指定的Configuration類，後者用於掃描給定的包路徑。在建立AnnotatedBeanDefinitionReader類的時候，會實例化GenericApplicationContext的內部beanFactory。

2.在構造方法中調用ClassPathBeanDefinitionScanner#scan或AnnotatedBeanDefinitionReader#register方法注入BeanDefinition。

3.ClassPathBeanDefinitionScanner#scan經過調用ClassPathScanningCandidateComponentProvider#findCandidateComponents方法獲取包路徑拿到當前包包括子包的全部類，而後第一次過濾會判斷某個BeanDefinition是否被相應的註解註解了，第二次過濾某個BeanDefinition是不是接口、抽象類等，返回全部被註解的非接口、抽象等的BeanDefinition；而後遍歷解析每一個BeanDefinition所用的註解，若是該BeanDefinition被@Scope註解，並設置了proxyMode屬性，那麼會生成代理BeanDefinition注入IOC容器中，原始BeanDefinition也會注入IOC容器中；最後調用AbstractApplicationContext#refresh進行刷新。

4.AnnotatedBeanDefinitionReader#register和ClassPathBeanDefitionScanner#scan差很少，只是獲取BeanDefinition的方式不一樣，該方式直接根據給定的Configuration類，直接生成AnnotationGenericBeanDefinition，後面的處理都基本同樣了。

2.`AnnotationConfigWebApplicationContext`

AnnotationConfigWebApplicationContext和AnnotationConfigApplicationContext的差異在於，AnnotationConfigWebApplicationContext並無經過構造方法直接實例化AnnotataionBeanDefinitionReader和ClassPathBeanDefinitionScanner，而後調用兩個類的對應方法將BeanDefinition注入IOC容器，最後直接調用refresh()方法進行刷新。它的構造方法僅僅用於實例化，而後須要手動調用對應的register()方法注入Configuration類或scan()給定的包路徑，經過loadBeanDefinition()方法進行回調，來處理給定的Configuration類或包路徑將BeanDefinition注入IOC容器，最後手動調用refresh()方法進行刷新。

1.初始化

AnnotationConfigWebApplicationContext annotationConfigWebApplicationContext = new AnnotationConfigWebApplicationContext();
annotationConfigWebApplicationContext.scan("com.ly");


private final Set<Class<?>> annotatedClasses = new LinkedHashSet<Class<?>>();
/** * 注入配置類 * org.springframework.web.context.support.AnnotationConfigWebApplicationContext#register */
public void register(Class<?>... annotatedClasses) {
    Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
    this.annotatedClasses.addAll(Arrays.asList(annotatedClasses));
}

private final Set<String> basePackages = new LinkedHashSet<String>();
/** * 掃描包 * org.springframework.web.context.support.AnnotationConfigWebApplicationContext#scan */
public void scan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    this.basePackages.addAll(Arrays.asList(basePackages));
}
複製代碼

2.刷新

1.加載註冊

//須要咱們手動刷新IOC容器
annotationConfigWebApplicationContext.refresh();

/** * 告訴子類刷新內部BeanFactory，這個內部BeanFactory真正的存儲了BeanDefinition * org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory */
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    //1.這裏使用了委派設計模式，父類定義了抽象的refreshBeanFactory方法，具體實現調用子類容器的refreshBeanFactory方法
    refreshBeanFactory();
    //2.獲取子類建立的內部BeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
}


/** * org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory() */
@Override
protected final void refreshBeanFactory() throws BeansException {
    //1.若是已經有容器， 銷燬容器中的bean，並關閉容器
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        //2.建立或獲取內部IOC容器
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
        //3.定製化BeanFactory，如是否容許bean定義重寫、是否容許循環引用
        customizeBeanFactory(beanFactory);
        //4.加載bean定義的方法，這裏也是委派設計模式，在當前類中只定義了抽象的loadBeanDefinitions方法，實現交給子類，注意這裏，能夠回調AnnotationWebApplicationContext#loadBeanDefiniitins方法
        loadBeanDefinitions(beanFactory);
        synchronized (this.beanFactoryMonitor) {
            this.beanFactory = beanFactory;
        }
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}


/** * 重寫了AbstractApplicationContext#loadBeanDefinitions方法，用於加載BeanDefinition * org.springframework.web.context.support.AnnotationConfigWebApplicationContext#loadBeanDefinitions */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    //1.建立讀取器和掃描器
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);

    //2.注入名稱生成器
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    if (beanNameGenerator != null) {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }

    //3.解析@Scope
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (scopeMetadataResolver != null) {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }

    //配置類存在
    if (!this.annotatedClasses.isEmpty()) {
        if (logger.isInfoEnabled()) {
            logger.info("Registering annotated classes: [" +
                        StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]");
        }
        //4.這裏就和AnnotationConfigApplicationContext同樣了
        reader.register(ClassUtils.toClassArray(this.annotatedClasses));
    }

    //包路徑存在
    if (!this.basePackages.isEmpty()) {
        if (logger.isInfoEnabled()) {
            logger.info("Scanning base packages: [" +
                        StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
        }
        //5.這裏就和AnnotationConfigApplicationContext同樣了
        scanner.scan(StringUtils.toStringArray(this.basePackages));
    }

    // configLocations存在，給定的xml文件
    // 因爲AnnotationConfigWebApplicationContext和AnnotationConfigApplicationContext繼承的父類不同，
    // 因此AnnotationConfigApplicationContext不能夠設置這個
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation : configLocations) {
            try {
                Class<?> clazz = getClassLoader().loadClass(configLocation);
                if (logger.isInfoEnabled()) {
                    logger.info("Successfully resolved class for [" + configLocation + "]");
                }
                reader.register(clazz);
            }
            catch (ClassNotFoundException ex) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Could not load class for config location [" + configLocation +
                                 "] - trying package scan. " + ex);
                }
                int count = scanner.scan(configLocation);
                if (logger.isInfoEnabled()) {
                    if (count == 0) {
                        logger.info("No annotated classes found for specified class/package [" + configLocation + "]");
                    }
                    else {
                        logger.info("Found " + count + " annotated classes in package [" + configLocation + "]");
                    }
                }
            }
        }
    }
}
複製代碼

總結一下：

1.這個類只能使用默認構造方法進行實例化，拿到實例。

2.經過實例手動調用scan或register方法，並分別使用basePackages和annotatedClass兩個Set集合保存。

3.手動調用AbstractApplicationContext#refresh方法，refresh方法經過回掉該類重寫的loadBeanDefinitions，而後就和AnnotatioConfigWebApplicationContext同樣了，經過ClassPathBeanDefinitionScanner#scan或AnnotatedBeanDefinitionReader#register注入到IOC容器。

2.總結

上面分別講述了基於XML和基於註解的BeanDefinition的初始化，相對來講ClassPathXmlApplicationContext比較複雜，AnnotationConfigApplicationContext和AnnotationConfigWebApplicationContext簡單點。總結下來能夠分爲三步：