• 前言

1. 对于IOC容器而言，BeanDefinition的载入过程，相当于把定义的BeanDefinition在IOC容器中转换成一个Spring内部表示的数据机构的过程。简单说，就是把Spring配置文件中的bean的定义转成Spring的内部数据结构。
2. 上一篇博客已经描述了Spring如何通过web.xml的配置读取配置路径，通过Resource接口读取配置文件。简单回忆一下上一篇博客的代码顺序。借用上个博客的一张图来看下代码的顺序：

• BeanDefinition的载入和解析

  我们接着上一篇的代码，在AbstractBeanDefinitionReader的loadBeanDefinitions方法中，我们定位到了Resource[]，看下简略代码：
  
  代码1.1：AbstractBeanDefinitionReader的loadBeanDefinitions方法

     
     
  public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
    ...
    if (resourceLoader instanceof ResourcePatternResolver) {
        Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
            int loadCount = loadBeanDefinitions(resources);
    ...
    }else {
        Resource resource = resourceLoader.getResource(location);
        int loadCount = loadBeanDefinitions(resource);
    ...
    }
  }

• 将xml文件转换成DOM对象

  通过getResource()方法得到Resource之后，那么就开始了真正加载Bean资源。因为Spring可以对应不同形式的BeanDefinition，我们这里讲的是xml的形式，所以就需要到XmlBeanDefinitionReader的实现中去看源码。
  
  代码1.2：XmlBeanDefinitionReader的loadBeanDefinitions及doLoadBeanDefinitions方法

 
 
//该方法-->调用入口
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        return loadBeanDefinitions(new EncodedResource(resource));
}
//该方法-->载入xml形式的BeanDefinition的地方
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        Assert.notNull(encodedResource, "EncodedResource must not be null");
        if (logger.isInfoEnabled()) {
            logger.info("Loading XML bean definitions from " + encodedResource.getResource());
        }
        //这里是获取线程局部变量
        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
        if (currentResources == null) {
            currentResources = new HashSet<EncodedResource>(4);
            this.resourcesCurrentlyBeingLoaded.set(currentResources);
        }
        if (!currentResources.add(encodedResource)) {
            throw new BeanDefinitionStoreException(
                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        }
        try {
            //将资源文件转换为IO输入流 
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {
                    inputSource.setEncoding(encodedResource.getEncoding());
                }
                //具体读取过程的方法  
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }
            finally {
                inputStream.close();
            }
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "IOException parsing XML document from " + encodedResource.getResource(), ex);
        }
        finally {
            currentResources.remove(encodedResource);
            if (currentResources.isEmpty()) {
                this.resourcesCurrentlyBeingLoaded.remove();
            }
        }
    }
    //该方法-->从特定XML文件中实际载入Bean定义资源
    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {
            int validationMode = getValidationModeForResource(resource);
            //将XML文件转换为DOM对象，解析过程由documentLoader实现  
            Document doc = this.documentLoader.loadDocument(
                    inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
            //这里是启动对Bean定义解析的详细过程，该解析过程会用到Spring的Bean配置规则【下文详解】  
            return registerBeanDefinitions(doc, resource);
        }
        .....
    }

上面的过程完成了两个动作：(1)资源文件转换成IO输入流;(2)将xml文件转换成DOM对象。至于解析xml文件的方法，里面是通过创建解析工厂，设置xml解析校检，通过工厂创建解析器，然后parse(),所以这个过程我们就不再看了。

• 按照Spring的Bean规则对Document对象进行解析

  走主线：得到dom对象后，开始启动对bean定义的详细解析。来看registerBeanDefinitions方法。
  
  代码1.3：XmlBeanDefinitionReader的loadBeanDefinitions方法

 
 
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        //得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();、
        //获得容器中注册的Bean数量  
        int countBefore = getRegistry().getBeanDefinitionCount();
        //解析过程入口，BeanDefinitionDocumentReader只是个接口，具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成  
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        //统计解析的Bean数量
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }

我觉得看到这里，是个正常人都会想骂人了，搞这么复杂这么饶人，真TM恶心。不过话说回来，我们作为一个学习者，都知道别人是优秀的，这么设计肯定有很多的道理。讲真，我看IOC源码N遍了，有些地方还是不能理解。废话少说，因为马上就要进入真正解析的地方了，我们稍微总结下上面那么多的饶人的代码。其实就2个核心思想：（1）首先，通过调用XML解析器将Bean定义资源文件转换得到Document对象，但是这些Document对象并没有按照Spring的Bean规则进行解析。这一步是载入的过程。（2）其次，在完成通用的XML解析之后，按照Spring的Bean规则对Document对象进行解析。按照Spring的Bean规则对Document对象解析的过程是在接口BeanDefinitionDocumentReader的实现类DefaultBeanDefinitionDocumentReader中实现的。OK,重点来了。（友情提示，会绕好几个方法。）

 
 
//该方法--根据Spring DTD对Bean的定义规则解析Bean定义Document对象
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        //获取根元素
        Element root = doc.getDocumentElement();
        //具体的解析过程由BeanDefinitionParserDelegate实现，BeanDefinitionParserDelegate中定义了Spring Bean定义XML文件的各种元素 (Delegate:代表、委派的意思)
        BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);
        preProcessXml(root);
        //从Document的根元素开始进行Bean定义的Document对象  
        parseBeanDefinitions(root, delegate);
        postProcessXml(root);
    }
    //该方法--使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象  
    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        //如果使用了Spring默认的XML命名空间
        if (delegate.isDefaultNamespace(root)) {
            //遍历根元素的所有子节点 
            NodeList nl = root.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                //如果该节点是XML元素节点 
                if (node instanceof Element) {
                    Element ele = (Element) node;
                     //如果该节点使用的是Spring默认的XML命名空间  
                    if (delegate.isDefaultNamespace(ele)) {
                        //使用Spring的Bean规则解析元素节点  
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        //没有使用Spring默认的XML命名空间，则使用用户自定义的解析规则解析元素节点 
                        //（如：自定义的xsd等）
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            //Document的根节点没有使用Spring默认的命名空间，则使用用户自定义的解析规则解析Document根节点  
            delegate.parseCustomElement(root);
        }
    }

上面这段代码又墨迹了一会，这里主要是看节点元素是否是Spring的规范，因为它允许我们自定义解析规范，那么正常我们是利用Spring的规则，所以我们来看parseDefaultElement(ele, delegate)方法。

 
 
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);
        }
        //如果普通的<Bean>元素，按照Spring的Bean规则解析元素  
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        }
    }

不知道大家看到这里是不是有种释放的感觉，终于TM的看到了自己熟悉的一点东西了。

• Bean资源的解析

  OK,下面的东西大家会更熟悉，我们主要看对Bean的解析。
  

  代码1.6：DefaultBeanDefinitionDocumentReader的processBeanDefinition方法

     
     
  //解析bean资源
    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        //BeanDefinitionHolder是对BeanDefinition的封装，包括BeanDefinition，beanName,aliases
        //对Document对象中<Bean>元素的解析由BeanDefinitionParserDelegate实现
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                //向Spring IoC容器注册解析得到的Bean定义，
                //这是Bean定义向IoC容器注册的入口 ，实际上是放到一个Map里面 【后面再看】
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error("Failed to register bean definition with name '" +
                        bdHolder.getBeanName() + "'", ele, ex);
            }
            // Send registration event.
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

  processBeanDefinition方法又引入了BeanDefinitionHolder的概念，注释上我也写了，是一个封装类。因为BeanDefinition是完完整整的Bean定义的解析，holder加了beanName相当于一个key。我们也看到了register方法，这个我们后续再单独讲下，下面进入parseBeanDefinitionElement具体解析Bean定义的地方。：
  

  代码1.7：BeanDefinitionParserDelegate的parseBeanDefinitionElement方法

     
     
    //该方法--diaoy 入口
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
        return parseBeanDefinitionElement(ele, null);
    }
    //该方法--解析Bean定义资源文件中的<Bean>元素，这个方法中主要处理<Bean>元素的id，name和别名属性
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        String id = ele.getAttribute(ID_ATTRIBUTE);//id
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//name
        List<String> aliases = new ArrayList<String>();//aliase
        if (StringUtils.hasLength(nameAttr)) {
            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_DELIMITERS);
            aliases.addAll(Arrays.asList(nameArr));
        }
        String beanName = id;
        //如果<Bean>元素中没有配置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");
            }
        }
        //检查<Bean>元素所配置的id或者name的唯一性，containingBean标识<Bean>元素中是否包含子<Bean>元素 
        if (containingBean == null) {
            checkNameUniqueness(beanName, aliases, ele);
        }
        //详细对<Bean>元素中配置的Bean定义进行解析的地方【property,description,parent等】
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            if (!StringUtils.hasText(beanName)) {
                try {
                    if (containingBean != null) {
                        //如果<Bean>元素中没有配置id、别名或者name，且没有包含子
                        //<Bean>元素，为解析的Bean生成一个唯一beanName并注册 
                        beanName = BeanDefinitionReaderUtils.generateBeanName(
                                beanDefinition, this.readerContext.getRegistry(), true);
                    }
                    else {
                        beanName = this.readerContext.generateBeanName(beanDefinition);
                        //如果<Bean>元素中没有配置id、别名或者name，但包含了子
                        //<Bean>元素，为解析的Bean使用别名向IoC容器注册 
                        String beanClassName = beanDefinition.getBeanClassName();
                        //为解析的Bean使用别名注册时，为了向后兼容Spring1.2/2.0，给别名添加类名后缀  
                        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;
    }

  看到这里大家是不是心里舒服多了，我们看到这里还没有对bean进行完整的解析，具体的参数配置在parseBeanDefinitionElement方法中，我们继续看下对参数的解析。
  

  代码1.8：BeanDefinitionParserDelegate的parseBeanDefinitionElement方法

     
     
  public AbstractBeanDefinition parseBeanDefinitionElement(
            Element ele, String beanName, BeanDefinition containingBean) {
        //记录解析的<Bean
        this.parseState.push(new BeanEntry(beanName));
        //这里只读取<Bean>元素中配置的class名字，然后载入到BeanDefinition中去  
        //只是记录配置的class名字，并不做实例化，对象的实例化在依赖注入时完成  
        String className = null;
         //如果<Bean>元素中配置了parent属性，则获取parent属性的值
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
        }
        try {
            String parent = null;
            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
                parent = ele.getAttribute(PARENT_ATTRIBUTE);
            }
            //根据<Bean>元素配置的class名称和parent属性值创建BeanDefinition
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
             //对<Bean>元素的不同的属性解析【不再写注释了，代码很清晰】
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            parseMetaElements(ele, bd);
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
            parseConstructorArgElements(ele, bd);
            parsePropertyElements(ele, bd);
            parseQualifierElements(ele, bd);
            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;
    }

  只要使用过Spring，对Spring配置文件比较熟悉的人，通过对上述源码的分析，就会明白我们在Spring配置文件中<Bean>元素的中配置的属性就是通过该方法解析和设置到Bean中去的。
  注意：在解析<Bean>元素过程中没有创建和实例化Bean对象，只是创建了Bean对象的定义类BeanDefinition，将<Bean>元素中的配置信息设置到BeanDefinition中作为记录，当依赖注入时才使用这些记录信息创建和实例化具体的Bean对象。
  上面方法中一些对一些配置如元信息(meta)、qualifier等的解析，我们在Spring中配置时使用的也不多，我们在使用Spring的<Bean>元素时，配置最多的是<property>属性。那么我们其实是有必要了解这些属性如何配置的，文章太长了，下一篇文章再说吧。