Spring源码学习(2)：XmlBeanFactory导读（转）

三双

源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇文章对觉得困难的朋友有一个帮助。
8 k; j2 W8 T& d$ {
   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。

/ _/ u3 O/ F% Z: l4 Y  x   首先来打开该类的代码，我们将看到如下代码：
: F3 b0 R; n0 ^+ F, b4 O以下内容为程序代码:
* H" |; o& ~0 g( d' a( V
public class XmlBeanFactory extends DefaultListableBeanFactory {

8 m6 C. v: S5 g   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
* M/ i) M- C" M+ h( M
7 n) @' W! o" O# `$ Q  K: Q   public XmlBeanFactory(Resource resource) throws BeansException {
       this(resource, null);
   }

& @* m& n# g0 e8 \   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
. p! Z, o3 b" U0 E$ d       super(parentBeanFactory);
       this.reader.loadBeanDefinitions(resource);
8 f' S  ~  f4 T. ?   }

}


   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：

: y7 Y3 Z. U& a+ x3 ?* ?3 o以下内容为程序代码:

+ F' i! y7 {* ]* e& z   super(parentBeanFactory);
: n  v4 w, s2 c3 w  H+ q# B   this.reader.loadBeanDefinitions(resource);

, p1 g/ L# U* u. K' Y8 d, R( F; _
5 b& o' M" _. n7 O4 O   第一句就是将父亲工厂交给父类的构造函数，实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，那接下来我们再看被调用的loadBeanDefinitions方法，这个方法里最主要的部分就是：

4 T  y2 e7 G8 k  z# n* r" `, H以下内容为程序代码:

+ Z3 y. I  p- H5 s" D( a. e0 Q8 l       InputSource inputSource = new InputSource(inputStream);
( k. P9 c; ?% P' X7 V! O- C               if (encodedResource.getEncoding() != null) {
                   inputSource.setEncoding(encodedResource.getEncoding());
* M/ `1 P, W! L! F; Q2 Z% r               }
       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
3 o( x& T# R" i, b+ n& ~

   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法

! x& |2 _' R0 @* B' a  W) t

1. 
   
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   ! p6 L+ c' @- c
3.            if (logger.isDebugEnabled()) {
   2 x0 v+ h2 O+ ]; \. g4 K
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   ' x5 }' [+ g/ t) |+ N& h
5.            }
   
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   
7.            Document doc = builder.parse(inputSource);
   + r7 t# D2 |( ^; m
8.            return registerBeanDefinitions(doc, resource);
   , l. J7 L) u0 _; j/ m; w

复制代码

4 d$ R# ~9 s$ I9 N! x   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
以下内容为程序代码:
) r3 f. T) Q5 }# t& d! H( X
. K* e# N/ l+ d" Q: H   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
) D$ i8 H; E: u/ g       XmlBeanDefinitionParser parser =
               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
       return parser.registerBeanDefinitions(this, doc, resource);
   }
; d! Z+ b1 J0 }5 S# U$ v
: D) g& X0 z3 a* P9 j! b
   这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：
2 n# k7 Z4 H# i" {2 c$ q以下内容为程序代码:

( p5 @9 i7 |, Y$ p& M$ K   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
. @" R0 e/ j" K5 s' v           throws BeanDefinitionStoreException {

' U2 Z" w$ t; U6 X% r1 p       this.beanDefinitionReader = reader;
       this.resource = resource;

       logger.debug("Loading bean definitions");
       Element root = doc.getDocumentElement();
       //初始化根元素
       initDefaults(root);
       if (logger.isDebugEnabled()) {
9 I2 a8 m  w: b* d           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
: A1 _' M+ ?! N           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
3 e: @! h; ^' [4 i           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
       }

       preProcessXml(root);//一个空方法用于扩展
       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
       if (logger.isDebugEnabled()) {
           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
) `, H( ^, A% z* y       }
/ z6 ]7 [/ K5 h       postProcessXml(root); //一个空方法用于扩展

  v$ Q9 y  \/ h7 [$ M$ _       return beanDefinitionCount;
7 t' t5 {8 @/ ^# d. n6 W5 K$ p   }
% ~, m; H5 l2 ^+ e- j

   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
: x2 _; k2 F' Z, r" V5 B* ]以下内容为程序代码:
/ w% t5 F6 e( ]1 n8 h; M& T/ y
   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
       NodeList nl = root.getChildNodes();
: f) n. u8 Y; p6 R! O5 h- J       int beanDefinitionCount = 0;
       for (int i = 0; i < nl.getLength(); i++) {
0 f& T$ E- D( `  e# J) T           Node node = nl.item(i);
           if (node instanceof Element) {
5 T6 `, S9 ?- R               Element ele = (Element) node;
               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
                   importBeanDefinitionResource(ele);
2 t. M2 I, j1 h               }
% e. D4 g. U) s               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
                   String name = ele.getAttribute(NAME_ATTRIBUTE);
2 f) N* d0 f  K5 e9 k/ v! ]                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
8 g6 D% I, n! G                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
               }
/ M" j0 p' f, N  C. y& L1 K) }               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
                   beanDefinitionCount++;
) W5 ^# `4 g! J$ _0 ^* A8 R8 ^* f                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
" A% _! m3 D4 g1 _# k% n                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
* `( d4 M+ x0 T% b% e" f4 R               }
           }
- `1 G6 f7 ]+ G       }
       return beanDefinitionCount;
   }
$ P/ I+ N( ?4 K

   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
以下内容为程序代码:
' A7 l7 v; e- {5 s; n( x8 P
               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
. @. @3 g: h/ z! h- Z$ B' Z                   beanDefinitionCount++;
+ o# L6 e1 Z  v: I" q) ?, x                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
               }
4 ^; L# f& ^+ a  @, C+ X# ?2 N2 a
   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
以下内容为程序代码:

   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
; ]- H0 D' Z+ }2 }! G& M
# |" A2 E! E+ m1 d) ?6 \1 M
   好了，就这么多了，本文只作为参考，只讲解了如何加载bean定义这块，只作为一个参考，希望对其他朋友能有所帮助吧，因为时间匆忙，有错漏的地方请指正。