Spring 4.3 源码分析之 IOC 基本容器启动

1. IOC 容器启动之猜测

在进行分析 Spring 容器启动时, 我们先歪歪一下, Spring 容器启动到底做了什么事情, 有什么好特别

1. 定位描述 Bean 依赖关系的 Xml 文件地址, 创建 DocumentBuilder 对象, 并将xml解析成 Document 
2. 通过 DefaultBeanDefinitionDocumentReader 及 BeanDefinitionParserDelegate 进行解析 XML中的每个节点 --> BeanDefinition
3. 将 2 中解析的 BeanDefinition 注册到容器中
4. 有了上面 Bean 定义的信息, 接着就可以通过 BeanFactory.getBean() 方法来创建+获取 Bean
5. 在创建之前若系统中有 BeanFactoryBeanPostProcessor, 则将 BeanFactoryBeanPostProcessor 对 容器中的 BeanDefinition 进行一些修饰(比如将 BeanDefinition 中的一些占位符(${}) 中的内容替换成 properties 中的内容)
6. 若容器中存在 InstantiationAwareBeanPostProcessor, 则先调用 实例化前置方法(postProcessBeforeInstantiation) 来进行生成代理对象(若配置了 customTargetSourceCreators, 则将创建对应的代理对象)
7. 通过反射来直接创建类(其实在这之前还有一部分, 查看是否类有定制的构造函数(在 SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructor), 对对对, 其实真正的用到的是 @Autowired 注解(在AutowiredAnnotationBeanPostProcessor中), 这个注解可以指定对应的构造函数)
8. 再次收集 Bean 上需要配置的信息(这部分配置的信息主要指在 Bean 的属性, 方法上设置的依赖属性), 接口MergedBeanDefinitionPostProcessor的 postProcessMergedBeanDefinition就是入口, 比如 AutowiredAnnotationBeanPostProcessor收集 @Autowired, @Value; CommonAnnotationBeanPostProcessor 收集 @Resource
9. 若当前对象是单例, 且容器允许循环引用, 则直接将刚刚生成的对象包裹在 ObjectFactory 里面, 放在singletonFactories中进行暴露(这里就是 Spring 解决循环依赖的方法)
10. 调用 InstantiationAwareBeanPostProcessor 的postProcessAfterInstantiation 方法来决定是否需要解决 xml 或通过在类属性上配置注解 的依赖属性, 若返回 false, 则直接返回
11. 解决 Bean 上配置的通过 @Autowired, @Value, @Resource 设置的依赖属性(通过 InstantiationAwareBeanPostProcessor的postProcessPropertyValues)
12. 解决 xml 上配置的依赖属性(比如 ref, property, list, map 等)
13. invoke 实现了 Aware 的接口方法, 主要是设置 BeanFactory, BeanName, BeanClassLoader 等
14. 调用 Bean 初始化方法的前置方法(注意上面是 Bean 的实例化 Instantiation, 这里是 Bean 的初始化 Initialization) postProcessBeforeInitialization <-- 其实这个方法没做什么, 其中一个比较重要的是设置一些 Aware(AoolicationContextAwareProcessor)
15. 初始化 Bean 的初始化方法, 初始化方法主要是实现 InitializaingBean 接口的 afterPropertiesSet, 与在 xml 中配置的初始化方法
16. 执行 Bean 初始化的后置方法(BeanProcessor.postProcessAfterInitialization), 这里其实是一般 AOP 实现的入口, 主要是 基于aop命名空间实现动态代理的 AspectJAwareAdvisorAutoProxyCreator 与基于 AspectJ 注解的 AnnotationAwareAspectJAutoProxyCreator (这两个在 AOP 那篇中会详述)
17. 这时 Bean 的依赖属性已经设置好了, 该生成代理类, 也生成了, 接着就放到容器中(若 Bean 是单例, 则会将 Bean 包裹成 DispoableBeanAdapter 主要是为后续激活xml的销毁方法或 DisposableBean.destory), 直接返回生成的 Bean 对象

上面的流程很多, 这个只是我自己对bean注入/创建的概述总结, 其中有几个注意点:

1. 其中将 Xml 里面的信息解析成 BeanDefinition是个很复杂的过程, 但其中可能只有 模版模式, 代理模式, NamespaceHandler 才真正的对我们工作有比较好的借鉴意义, 没有必要花很长时间在这里
2. Bean的整个创建主要分成, 依赖信息的收集, Bean的实例化(Instantiation), Bean的初始化(Initialization)，(PS: 要牢记 "实例化"与"初始化" 这两个概念)

2. IOC 基本容器启动 Demo

这里指的基本容器就是 "DefaultListableBeanFactory", 下面我看一个 Demo:

    


// 测试代码
@Test
public void doTraditionBeanFactory() throws Exception {
    String resourceName = "org/springframework/beans/factory/xml/application.xml";
    // 最基本的 IOC 工厂 DefaultListableBeanFactory
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    // 配置Bean依赖文件 
    Resource resource = new ClassPathResource(resourceName);
    // 使用 XML 读取器读取 xml 里面的信息, 并且设置到 BeanFactory 中
    new XmlBeanDefinitionReader(factory).loadBeanDefinitions(resource);
    // 获取 BeanFactory 中的对象 (PS: 注意这时 容器中指存在 BeanDefinition, 还未生成对应的 Bean)
    TestBean bean = (TestBean) factory.getBean("testBean");
    assertNotNull(bean);
}

上面的Demo中主要有以下组件:

1. DefaultListableBeanFactory: 最基本也是最实用的 BeanFactory 工厂
2. Resource: 对xml资源的统一封装
3. XmlBeanDefinitionReader: xml文件的读取器, 主要完成 xml 里面配置资源的解析(解析成BeanDefinition), 并且注入到 BeanFactory 中

对仅仅这3个类就完成了Bean配置文件的定位, 读取, 解析, 注入, 类创建, 下面会一一进行解析

3. 配置文件的定位与读取

这里的配置文件 "org/springframework/beans/factory/xml/application.xml" 包裹在ClassPathResource, 通过 class/classLoader 来直接读取文件, 转换成数据流

public InputStream getInputStream() throws IOException {
    // 下面通过 class/ClassLoader 来判断怎么去读取资源
    InputStream is;
    if (this.clazz != null) {                               // 若配置了 class, 则直接通过 class 来获取文件的数据流对象
        is = this.clazz.getResourceAsStream(this.path);
    }
    else if (this.classLoader != null) {                    // 若配置了 classLoader, 则直接通过 classLoader 来获取文件的数据流对象      
        is = this.classLoader.getResourceAsStream(this.path);
    }
    else {                                                  // 通过这个方法的调用类(也就是 Reflection.getCallerClass())背后的 classLoader 来获取数据流
        is = ClassLoader.getSystemResourceAsStream(this.path);
    }
    if (is == null) {
        throw new FileNotFoundException(getDescription() + " cannot be opened because it does not exist");
    }
    return is;
}

有了数据流, 我们就可以通过 Document 解析器解析成 Document, 在根据 Document中每个节点所在的 Namespace 来解析成对应的 BeanDefinition

4. 将配置文件解析成 BeanDefinition (解析主入口)

这里有个偏离目录以下, 常见的Bean配置文件主要通过 BeanDefinitionReader(子类 XmlBeanDefinitionReader, PropertiesBeanDefinitionReader), 或扫描指定目录下面的所有 class 文件, 将被指定注解修饰的类注入到容器中, 一般现在这两种方法在项目中都使用, 其中 XmlBeanDefinitionReader 完成 PropertiesBeanDefinitionReader, 我将这个归结为以下原因:

1. 用 XML 配置 Bean, 扩展性好(支持各种数据结构, list, map)
2. 能自己扩充命名空间(基本命名空间只针对  标签), 比如Spring原生扩充的命名空间, (aop中),  (事务配置), (SpringMVC中配置)

直接看 XmlBeanDefinitionReader 的加载过程吧

// 这里是载入 XML 形式 Bean 定义资源文件的方法
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    Assert.notNull(encodedResource, "EncodedResource must not be null");
    if (logger.isInfoEnabled()) {
        logger.info("Loading XML bean definitions from " + encodedResource.getResource());
    }
    // 通过类属性 resourcesCurrentlyBeingLoaded 记录当前线程已加载的资源
    Set currentResources = this.resourcesCurrentlyBeingLoaded.get();
    if (currentResources == null) {
        currentResources = new HashSet(4);
        this.resourcesCurrentlyBeingLoaded.set(currentResources);
    }
    // 若配置信息已经加载过, 则直接抛出异常
    if (!currentResources.add(encodedResource)) {
        throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
    }
    try {
        // 将资源文件转为 InputStream 的 IO 流
        InputStream inputStream = encodedResource.getResource().getInputStream();
        try {
            // 把 InputStream 封装成 InputSource(InputSource 这个类并不来自于 Spring, 它的全路径是 org.xml.sax.InputSource), 接着就是 通过 DocumentBuilder 解析 Docuement
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            // doLoadbeanDefinitions 才是核心加载资源文件的方法
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());       
        }
        finally {
            inputStream.close();                // 关闭从 Resource 中得到的 IO 流
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException(
                "IOException parsing XML document from " + encodedResource.getResource(), ex);
    }
    finally {
        currentResources.remove(encodedResource);
        if (currentResources.isEmpty()) {
            this.resourcesCurrentlyBeingLoaded.remove();
        }
    }
}

代码进行到这里其实我们只是获取对应的 xml的数据流对象, 接着需要将 数据流对象转化成 Document 对象, 针对这部分内容,首先需要介绍下面几个对象:

1. DefaultDocumentLoader: 这个类完成了 Document 解析器工厂 DocumentBuilderFactory 的创建及配置(配置是否支持命名空间, 是否支持校验)
2. XmlValidationModeDetector: xml 格式的校验器, 校验 xml头是否是包含 "DOCTYPE", 校验每个节点是否是 "<" 开头, ">" 结尾
3. errorHandler: xml解析错误时的报警机制
4. DocumentBuilder: 将数据流包装类 InputSource 解析成 Doucment 的解析器 ( 这个类存在于 javax.xml.parsers 中)
5. DocumentBuilderFactory: DocumentBuilder的工厂类, 其中主要设置 校验模式与是否支持命名空间

以上几个最中还是 DocumentBuilder 将xml解析成 Document, 有了Document我们可以接下来的 Document解析成 BeanDefinition 工作

现在又会出现有几个非常重要的工具类:

1. DefaultNamespaceHandlerResolver: xml中Namespace解析器, 这个类会获取所有 jar/war/directory 中"META-INF/spring.handlers"的内容, 生成对应的 NamespaceHandler, 并调用 init方法进行初始化(这里定义各个各个标签的详细Bean解析器 -> BeanDefinitionParser)
2. XmlReaderContext: Xml读取器上下文, 里面包含了 ProblemReporter,  ReaderEventListener, SourceExtractor (前面三个类几乎没做什么东西), NamespaceHandlerResolver(xml中节点的命名空间解析器), 当然还有 BeanDefinitionRegistry(其实这里就是 DefaultListableBeanFactory), 

上面出现了多个工具类(对, 没错, 为了解析个xml文件, Spring使用了这么多的工具类), 接下来就是 Docment 的解析

先看一下解析的入口:

/**
 * 如果想在 XML 解析前后对 Element 元素做一些处理(模版模式)
 * 则在 DefaultBeanDefinitionDocumentreader 的子类重写 preProcessXml(...) postProcessXml(..) 即可
 * Register each bean definition within the given root {@code } element.
 */
protected void doRegisterBeanDefinitions(Element root) {
    BeanDefinitionParserDelegate parent = this.delegate;
    // 创建解析的委托处理工具类 (这个类 用于完成正真的解析过程)
    this.delegate = createDelegate(getReaderContext(), root, parent);

    if (this.delegate.isDefaultNamespace(root)) {
        // 此处针对  的节点属性 profile 进行操作
        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)) {      // 查看环境变量中的 Profile 是否和 xml一致, 若不一致则直接不属于这个 profile, 直接返回
                if (logger.isInfoEnabled()) {
                    logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                            "] not matching: " + getReaderContext().getResource());
                }
                return;
            }
        }
    }
    // 解析前置处理, 这里是空实现 留给子类实现 (默认 空实现)
    preProcessXml(root);
    // 解析整个文档, 轮询各个子节点分别解析,
    parseBeanDefinitions(root, this.delegate);
    // 解析后置处理, 也是空实现 留给子类实现 (默认 空实现)
    postProcessXml(root);
    this.delegate = parent;
}

这时又出现一个新的类 BeanDefinitionParserDelegate, 这个类也是解析的核心类, 无论是 , , 标签, 还是其他命名空间的标签, 都是由这个类来进行解析的, 这时再看看在 DefualtBeanDefinitionDocumentReader 的解析策略(主要以 Namespace 来进行区分)

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // Bean 定义额 Document 对象使用了 Spring 默认的 XML 命名空间 (http://www.springframework.org/schema/beans)
    if (delegate.isDefaultNamespace(root)) {
        // 获取 Bean 定义的 Document 对象根元素的所有子节点
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            // 获取  Document 节点是 XML 元素节点
            if (node instanceof Element) {
                Element ele = (Element) node;
                // 若果是默认命名空间(beans), 则直接解析 比如 
                if (delegate.isDefaultNamespace(ele)) {
                    // 解析 import 标签, alias 标签, bean 标签, 内置  标签
                    parseDefaultElement(ele, delegate);
                }
                else {
                    // 没有使用 Spring 默认的 XML 命名空间, 则使用用户自定义的解析规则解析元素节点 (这里蕴含这在默认命名空间的节点里面可以存在非默认命名空间的节点)
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        // Document 的根节点没有使用 Spring 默认的命名空间, 则使用用户自定义的
        delegate.parseCustomElement(root);
    }
}

从这里可以看出无论是否是默认命名空间, 都是通过 BeanDefinitionParserDelegate 来进行解析

5. 默认命名空间标签解析

这里主要针对 import, alias, bean, beans 标签进行解析

// 使用 Spring 的 Bean 规则解析 Document 元素节点
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    // 如果元素节点是  导入元素, 则进行导入解析
    // import 标签解析
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    // 如果元素节点是  别名元素, 进行别名解析
    // alias 标签解析
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    // 元素节点既不是导入元素, 也不是别名元素, 即普通的  元素,
    // 按照 Spring 的bean规则解析元素
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
    // 如果是 beans 标签, 则回到代码的上层, 递归解析
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        // 递归
        doRegisterBeanDefinitions(ele);
    }
}

当遇到 import标签时, 直接读取对应资源, 并通过 XmlBeanDefinitionReader 再次进行读取资源配置文件

/**
 * Parse an "import" element and load the bean definitions
 * from the given resource into the bean factory.
 *
 * Demo
 *
 * 
 *     
 *     
 * 
 */
// 解析  导入元素, 从给定的导入路径加载 Bean定义资源到 Spring Ioc 容器中
protected void importBeanDefinitionResource(Element ele) {
    // 获取  标签的 resource 属性值
    String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
    // 如果导入额元素的 location 属性值为空, 则没有导入任何资源, 直接返回
    if (!StringUtils.hasText(location)) {
        getReaderContext().error("Resource location must not be empty", ele);
        return;
    }
    // 这里强调一下, 对于  标签, 其会从 System.getProperties() 和 System.getenv() 中属性获取, 进行解析占位符 ${} 中的内容
    location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

    Set actualResources = new LinkedHashSet(4);

    // 标识给定的导入元素的 location 是否是绝对路径
    // Discover whether the location is an absolute or relative URI
    boolean absoluteLocation = false;
    try {
        absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
    }
    catch (URISyntaxException ex) {
        // cannot convert to an URI, considering the location relative
        // unless it is the well-known Spring prefix "classpath*:"
        // 给定的导入元素的 location 不是绝对路径
    }

    // 如果是绝对 URI 则直接根据 地址加载对应的配置文件
    // 给定的导入元素的 location 是绝对路径
    // Absolute or relative?
    if (absoluteLocation) {
        try {
            // 使用资源读入器加载给定路径的 Bean 定义资源(这里其实就是递归解析的一个过程)
            int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
            }
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error(
                    "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
        }
    }
    else {
        // 如果是相对路径, 则根据相对地址计算出绝对地址
        // No URL -> considering resource location as relative to the current file.
        try {
            int importCount;
            // 将给定导入元素的 location 封装为相对路径资源
            Resource relativeResource = getReaderContext().getResource().createRelative(location);
            // 封装的相对路径资源存在
            if (relativeResource.exists()) {        // 下面又是 解析 xml 里面的描述信息, 来加载 Bean
                importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
                actualResources.add(relativeResource);
            }
            // 封装的相对路径资源不存在
            else {  // 如果解析不成功, 则使用默认的解析器 ResourcePatternResolver 进行解析
                // 获取 Spring Ioc 容器资源读入器的基本路径
                String baseLocation = getReaderContext().getResource().getURL().toString();
                // 下面又是 解析 xml 里面的描述信息, 来加载 Bean
                importCount = getReaderContext().getReader().loadBeanDefinitions(
                        StringUtils.applyRelativePath(baseLocation, location), actualResources);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
            }
        }
        catch (IOException ex) {
            getReaderContext().error("Failed to resolve current resource location", ele, ex);
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
                    ele, ex);
        }
    }
    Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
    // 在解析完  元素之后, 向对应监听器发送相应时间通知
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

当遇到 标签时, 会将解析的结果注册到 DefaultListableFactory 的父级类 SimpleAliasRegistry#aliasMap 中

/**
 * Process the given alias element, registering the alias with the registry.
 */
// 解析  别名元素, 为 Bean 向 Spring Ioc 容器注册别名
protected void processAliasRegistration(Element ele) {
    // 获取  别名元素中的 name 的属性值
    String name = ele.getAttribute(NAME_ATTRIBUTE);
    // 获取  别名元素中 alias 的属性值
    String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
    boolean valid = true;
    //  别名元素的 name 属性值是否为空
    if (!StringUtils.hasText(name)) {
        getReaderContext().error("Name must not be empty", ele);
        valid = false;
    }
    //  别名元素的 alias 属性值是否为空
    if (!StringUtils.hasText(alias)) {
        getReaderContext().error("Alias must not be empty", ele);
        valid = false;
    }
    if (valid) { // name/alias 都不为空
        try {
            // 向容器的资源读入器注册别名, 查阅后其会保存到 DefaultListableFactory 的父级类 SimpleAliasRegistry#aliasMap 中
            getReaderContext().getRegistry().registerAlias(name, alias);
        }
        catch (Exception ex) {
            getReaderContext().error("Failed to register alias '" + alias +
                    "' for bean with name '" + name + "'", ele, ex);
        }
        // 解析完  元素之后, 发送容器别名处理完成事件
        getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
    }
}

到了精彩的地方 标签的解析, 这是一个非常复杂的解析过程, 先看以下主逻辑:

// 解析 Bean 定义资源 Document 对象的普通元素
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    /**
     * 利用 BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element e)
     * 解析给定的 bean 元素信息为, BeanDefinitionHolder, 这其中就包含了 id, class, alias, name 等属性
     */
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        // 这里就是对  标签里面, 不是能通过命名空间解析得了的标签的解析
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // 向 Spring Ioc 容器注册解析得到 Bean 定义, 这是 Bean 定义向 Ioc 容器注册的入口
            // Register the final decorated instance.
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                    bdHolder.getBeanName() + "'", ele, ex);
        }
        // 解析完成, 发送相应的注册事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

OK 这里又分为两部分, bean标签及里面子标签的解析, 先是解析 标签中的 id, name等属性

// 解析 Bean 定义资源文件中的  元素, 这个方法中主要处理  元素的 id, name
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    // 获取  元素中的 id 属性值
    String id = ele.getAttribute(ID_ATTRIBUTE);
    // 如果有 name 属性, 则获取 name, 并且 可有多个 name, 以 , ; 为分隔符号
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    
    // 将  元素中的所有的 name 属性值存放到别名中
    List aliases = new ArrayList();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    String beanName = id;
    // 如果  元素中没有配置 id 属性时, 将别名中的第一个值赋值给 beanName
    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");
        }
    }
    
    // 检查  元素所配置的 id 或者 name 的唯一性, containingBean 标识 
    if (containingBean == null) {
        // 检查  元素锁所配置的 id, name 或者别名是否重复
        checkNameUniqueness(beanName, aliases, ele);
    }
    
    // 详细对  元素中配置的 Bean 定义进行解析的地方
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        if (!StringUtils.hasText(beanName)) {
            try { 
                if (containingBean != null) { // (PS: containingBean默认是 null)
                    //  为解析的 Bean 生成一个唯一额 beanName 并注册
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    // 为解析的 Bean 生成 beanName, 并加入到 aliases中
                    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);
    }
    // 解析出错, 返回 null
    return null;
}

接着呢是 bean 标签里面的其他属性进行解析

/**
 * Parse the bean definition itself, without regard to name or aliases. May return
 * {@code null} if problems occurred during the parsing of the bean definition.
 */
// 详细对  元素中配置的 Bean 定义其他属性进行解析, 由于 上面的方法中已经对 Bean 的id, name等属性进行处理, 该方法主要处理除了这两个个以外的其他属性数据
public AbstractBeanDefinition parseBeanDefinitionElement(
        Element ele, String beanName, BeanDefinition containingBean) {
    // 记录解析的 
    this.parseState.push(new BeanEntry(beanName));
    // 这里只读去  元素中配置的 class 名字, 然后载入到 BeanDefinition 中去
    String className = null;
    // 解析 Class 属性
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }

    try {
        String parent = null;
        // 如果  元素中配置了 parent属性, 则获取parent 属性的值
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }
        // 创建用于承载属性的 AbstractBeanDefinition 类型的 GenericBeanDefinition
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);
        // 这里对当前的 Bean 元素进行属性的解析, 并设置 description 的信息 (注意是 bean 标签的, 比如 scope, abstract, lazy-init, init-method, destroy-method 等)
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
        
        // 对  元素的 mate(元信息)属性解析
        parseMetaElements(ele, bd);
        // 对  元素的 loopup-method 属性解析
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        // 对  元素的 replaced-method 属性解析
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
        // 解析  元素的构造方法
        parseConstructorArgElements(ele, bd);
        // 解析  元素的  属性
        parsePropertyElements(ele, bd);
        // 解析  元素的 qualifier 属性
        parseQualifierElements(ele, bd);

        // 为当前解析的 Bean 设置所需要的资源和依赖对象
        bd.setResource(this.readerContext.getResource());
        bd.setSource(extractSource(ele));

        return bd;
    }
    catch (Throwable ex) {
        error("Unexpected failure during bean definition parsing", ele, ex);
    }
    finally {
        this.parseState.pop();
    }

    // 解析元素出错返回 null
    return null;
}

(PS: 这里都是标签解析部分, 所以详细说了)
而对应那些非默认命名空间的标签的解析, 主要是通过命名空间解析类找到对应的 NamespaceHandler 来进行解析

6. 非默认命名空间标签解析

这一部分就相对简单了, 根据节点获取 namespaceUri, 然后获取对应的 NamespaceHandler, 接着就行相应解析

// 实现对非默认命名空间节点的通用解析框架 (PS 此处的 containingBd 默认为 null)
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
    // 获取命名空间
    String namespaceUri = getNamespaceURI(ele);
    // 从 map 集合中获取 Namespacehandler 接口
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    // 调用统一的解析接口
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

这时xml中描述的bean信息已经被解析成 BeanDefinition, 注入到 BeanFactory 中(PS: 注入的统一入口 BeanDefinitionRegistry.registerBeanDefinition), 紧接着就是Bean的获取(PS: 到现在Bean还未生成, 容器中存在的只是 bean 的描述信息 BeanDefinition, 只有在 BeanFactory.getBean()时才会进行一次创建, Bean一旦创建好, 就会缓存在容器中)

7. getBean中创建Bean的主逻辑

到这里其实就是刚刚执行了最上面demo中的 4行代码, 完成了 xml 文件中Bean的解析, 解析成了BeanDefinition, 并且注册到了 BeanDefinitionRegistry 中(但是我的 bean 还没生成呢, 何时生成呢, 其实就是 beanFactory.getBean() 方法里面)

String resourceName = "org/springframework/beans/factory/xml/application.xml";
// 最基本的 IOC 工厂 DefaultListableBeanFactory
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
// 配置Bean依赖文件
Resource resource = new ClassPathResource(resourceName);
// 使用 XML 读取器读取 xml 里面的信息, 并且设置到 BeanFactory 中
new XmlBeanDefinitionReader(factory).loadBeanDefinitions(resource);

而整个创建的过程很复杂, 大体上分为以下几步:

1. 通过 transformedBeanName 来获取BeanName(PS:  若传来的是 别名 alias,  则通过 transformedBeanName获取对应的真实 BeanName)
2. 通过 getSingleton 从缓存中取是否已经有被创建过的单例类型的 bean, 而 getSingleton 中又分成两部
   a. 若 signletonObjects 中已经存在对象, 则直接返回
   b. 若 bean被提早暴露了(就是通过 ObjectFactory 进行提早暴露, 以解决 循环引用) , 则直接通过 ObjectFactory.getObject 返回对象(PS: 这个 ObjectFactory 是在 AbstractAutowireCapableBeanFactory.doCreateBean 中的 add SingletonFactory 中将 包裹实例化了的Bean的 ObjectFactory 加入到 singletonFactories 中)
3. 若 getSingleton 返回了对象, 则直接通过 getObjectForBeanInstance 来获取真实的对象(PS: 对, 刚才 getSingleton 返回的对象有可能是 FactoryBean, 所以还需要通过 FactoryBean的getObject来获取真实的对象, 而这时还会在 这个对象上运用所有 BeanPostProcessor.postProcessAfterInitialization)
4. 这里有个判断, 若BeanDefinition是原型模式, 并且已经在创建中, 则直接报异常(PS: 这里表明若原型模式的 Bean需要一个创建好之后才能再次创建)
5. 若此时发现本 BeanFactory 中不存在 BeanDefinition, 而 parentBeanFactory 中存在对应的BeanDefinition, 则将类的创建交给 parentBeanFactory 来创建
6. 若 BeanDefinition有parentClass 的设置, 则获取parentClass的BeanDefinition, 并合并到本类对应的 BeanDefinition
7. 这时来到 Bean 的创建, 根据 BeanDefinition 是 singleton, prototype, 与其他 scope 来分别处理, 最后基本上也是交给 getObjectForBeanInstance 来获取真实的 Bean(上面获取的bean可能是 FactoryBean, 而不是真正需要的 Bean), 
8. 最后将对象返回到上层

这里可以看一下下面主逻辑的代码

// 参考资料 http://www.cnblogs.com/ITtangtang/p/3978349.html
// 正真实现向 Ioc 容器获取 Bean 的功能, 也是触发依赖注入功能的地方
@SuppressWarnings("unchecked")
protected  T doGetBean(
        final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {

    // 获取真实的 beanName的名称(PS: 如果name是别名, 将别名转换为规范的 Bean 名称)
    final String beanName = transformedBeanName(name);
    Object bean;

    // spring创建bean原则: 不等 bean 创建完成就会将 包装bean的ObjectFactory对象提早暴露出来, 主要是解决循环依赖问题, 这样一旦下一个类创建时,若需要查找依赖类, 则可以通过 ObjectFactory 来提前获取引用
    // 先从缓存中取是否已经有被创建过的单例类型的 bean, 对于单例模型的 Bean 整个 Ioc 容器中只创建一次, 不需要重复创建
    // Eagerly check singleton cache for manually registered singletons.
    Object sharedInstance = getSingleton(beanName);
    // 如果能从缓存中获得已缓存的单例 bean, 并且参数 args == null (args默认就是 null), 那么直接返回缓存中的 bean, 否则继续创建 bean
    if (sharedInstance != null && args == null) {
        if (logger.isDebugEnabled()) {
            // 如果指定名称的单例 Bean, 在创建过程中, 则打印以下日志信息
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        // 返回对应的实例, 可能存在是 FactoryBean 的情况, 返回的是 通过 Factorybean 创建的 bean 实例(如果 beanName 的命名是 &开头或sharedInstance不是Factorybean, 那么返回的是 sharedInstance 实例) (PS: BeanFactory 是管理容器中的 Bean 的工厂, 而 FactoryBean 是 创建对象的工厂 bean)
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else { // 若 不能在缓存中找到 单例 bean, 则执行下面的逻辑
        /**
         * 只有单例模式下, 才能尝试解决循环依赖, 原型模式下, 直接抛出异常 BeanCurrentlyInCreationException
         * 什么是循环依赖, 例如 A 中有B 属性, B 中也有 A 属性,但是 A 还未创建完成时, 会先去创建B, 但是创建B的时候又要先去创建 A, 造成循环依赖
         */
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        /**
         * 对 Ioc 容器中是否存在指定名称的 BeanDefinition进行检查, 首先检查是否
         * 能在当前的 BeanFactory 中获取的所有需要的 bean, 如果不能则委托当前容器的
         * 父级容器去查找, 如果还是找不到则沿着容器的继承体系向父级容器查找
         */
        // Check if bean definition exists in this factory.
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 如果当前工厂 AbstractBeanFactory 存在父级 beanFactory,且当前 AbstractBeanFactory 不存在 bean 定义(BeanDefinition), 则把创建 bean 的职责交给父级 Beanfactory
        // 当前容器的父级容器存在, 其当前容器中不存在指定名称的 Bean
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 解析指定的 bean 名称的原始名称 (其实就是, 若name最前面是$符号, 则还是返回代 $符号的name)
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            // delegate 到 beanFactory 中寻找
            if (args != null) {
                // Delegation to parent with explicit args.
                // 委派父级容器根据指定名称和显示的参数查找
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // 委派父级容器根据指定名称和类型查找
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

        if (!typeCheckOnly) { // (PS: 默认 false)
            // 把指定的 beanName 记录到 alreadyCreated Map 中(缓存), 表明该 beanName 已经创建过, 或即将创建 (beanFactory 用此来优化 beanName 重复创建)
            markBeanAsCreated(beanName);
        }

        try {
            /**
             * 将存储 XML 配置文件的 GenericBeanDefinition 转换成 RootBeanDefinition, 若有 parentName 属性, 则将parentName对应的 BeanDefinition属性合并到自己的 BeanDefinition 属性上
             * 为什么要将 GenericBeanDefinition 转化为 RootbeanDefinition 是因为:
             * 从 XML 配置文件中读取到的 Bean 信息是存储到 GenericbeanDefinition 中, 但是
             * 所有 Bean 后续处理都是针对 RootBeanDefinition 的, 所以这里需要做一个转换
             */
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 获取当前的 Bean 所依赖 Bean(PS： 一般 dependsOn 都为 null, 很少通过dependsOn来实现依赖注入)
            // Guarantee initialization of beans that the current bean depends on.
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 把 bean 依赖的信息缓存起来
                    registerDependentBean(dep, beanName);   // 缓存依赖调用
                    // 递归调用 getBean 方法, 获取当前 Bean 的依赖的 Bean
                    getBean(dep);
                }
            }


            // 创建单例模式的 Bean 实例对象
            // 这里通过 createBean 方法创建 singleton bean 的实例, ObjectFactory中有一个会调函数 getObject, 会在 getSingleton 中会触发 ObjectFactory -> getObject() -> 最后到这里的 createBean()
            // Create bean instance.
            if (mbd.isSingleton()) { // 如果是 singleton
                sharedInstance = getSingleton(beanName, new ObjectFactory