Spring IOC源码分析（一）

1.Spring IOC源码分析（一）

Spring IOC容器一般是指两个：BeanFactory和ApplicationContext。BeanFactory是最顶层的接口，提供了IOC最基本的功能，但是无法提供AOP、WEB等高级特性。ApplicationContext实现了BeanFactory，是一个高级接口，在BeanFactory的基础上做了扩展，支持诸多高级特性，如BeanFactory不支持的AOP、WEB，还有国际化、事件监听、加载资源文件的能力等。目前在实际应用中，我们都是使用的ApplicationContext。

它实现的这些接口都表明了它具有的能力。

ApplicationContext的部分实现类图：

上述类图中三个红色框框住的类是Spring中常用的三个ApplicationContext实现类。ClassPathXmlApplicationContext是基于XML文件的；AnnotationConfigApplicationContext和AnnotationConfigWebApplicationContext都是基于注解的。

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()方法主要是解析给定的字符串是否使用了占位符，在后面也被频繁用到。

2.刷新容器

上面的步骤初始化了我们的容器并且知道了资源文件路径所在位置，那么这一步就是解析给定的XML资源文件路径。

/**
* 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简单点。总结下来可以分为三步：

1.初始化。初始化应用上下文，给定XML资源文件或配置类或者包路径。

2.加载。加载给定的资源，不同的资源类型有不同的加载方式，为解析资源做准备。

3.注册。解析资源，初始化BeanDefinition，注册到IOC容器中。