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

三双

源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇文章对觉得困难的朋友有一个帮助。

   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。
* [9 g) V; T1 t5 T" D& ]
7 W0 g. n0 ~/ U   首先来打开该类的代码，我们将看到如下代码：
1 e: V6 N6 B) N5 B5 g6 q* C以下内容为程序代码:

1 O; J* n" C) ]: D1 C7 rpublic class XmlBeanFactory extends DefaultListableBeanFactory {

   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
/ Q2 t' |! N; b( q4 q. o2 M
   public XmlBeanFactory(Resource resource) throws BeansException {
       this(resource, null);
4 Y0 }+ e: Y9 D5 z- v/ L8 t; n   }

. t4 j7 {( q  n   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
( I& u3 ^* E7 l/ O, i$ C       super(parentBeanFactory);
       this.reader.loadBeanDefinitions(resource);
   }

2 h' [3 ~# X% v1 U}

" H8 O7 S7 O  ^& q1 A
: L; u% B; o. T/ a( \4 ?2 l1 A$ |   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：
0 I+ d7 E7 W% B9 J2 h
以下内容为程序代码:

3 Q* z% Z7 J$ K* J   super(parentBeanFactory);
   this.reader.loadBeanDefinitions(resource);
$ J6 W8 M3 O; j  \  O; Q
; T6 G! e6 j& U% ~
0 ~/ O' c, |7 M( \   第一句就是将父亲工厂交给父类的构造函数，实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，那接下来我们再看被调用的loadBeanDefinitions方法，这个方法里最主要的部分就是：
, K% u( N# D. S% v; ~% Y7 I) h
& Y  a& n' U! M- N- n7 K以下内容为程序代码:

       InputSource inputSource = new InputSource(inputStream);
               if (encodedResource.getEncoding() != null) {
                   inputSource.setEncoding(encodedResource.getEncoding());
" m* ^9 Y* e% G! A$ [" r               }
       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
3 J* m+ j! R2 |
) A3 u2 L$ _5 _9 m7 f/ O- h. v. |; C
   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法
5 a+ y6 V6 T7 ?7 N- G  x

1. 
   9 R7 y% v0 |7 k
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   
3.            if (logger.isDebugEnabled()) {
   
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   
5.            }
   8 _3 I8 }5 b: Z9 `! \; H5 H4 {/ d
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   
7.            Document doc = builder.parse(inputSource);
   ' P- o/ l2 n9 b6 u0 U  c
8.            return registerBeanDefinitions(doc, resource);
   

复制代码

/ ?8 L3 [' {  L; i$ ^! _   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
/ ~2 }9 ]( V; C4 n& f以下内容为程序代码:

5 O7 h% N& p/ W" B6 Y: f   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
       XmlBeanDefinitionParser parser =
               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
       return parser.registerBeanDefinitions(this, doc, resource);
   }
% p% n2 V4 M7 Y8 M  }' l
) W/ d- E; F0 k
1 A' B, [$ Y, I1 ?  r, Y/ T& h   这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：
% }# u' `& `4 G+ m& a0 o以下内容为程序代码:

   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
: n2 G2 E3 r7 D           throws BeanDefinitionStoreException {

       this.beanDefinitionReader = reader;
       this.resource = resource;

       logger.debug("Loading bean definitions");
       Element root = doc.getDocumentElement();
       //初始化根元素
       initDefaults(root);
       if (logger.isDebugEnabled()) {
           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
& }- W$ z# i* S- n. X9 r! w           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
       }

       preProcessXml(root);//一个空方法用于扩展
8 I1 M5 p8 ~# j+ t       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
       if (logger.isDebugEnabled()) {
           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
- c/ ~5 f3 A* b' j5 y" @$ O3 j# `+ ]       }
       postProcessXml(root); //一个空方法用于扩展

, }( r. i0 e$ Z9 p% ^7 n       return beanDefinitionCount;
" R8 d) k1 o& [( Y2 ~7 ?   }
9 [+ N, Y. m( M& t

   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
, S* a' w$ C9 X以下内容为程序代码:

  Q2 W/ h. v1 Z7 g5 J   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
: ?& Y. @$ H5 f2 ]4 d       NodeList nl = root.getChildNodes();
       int beanDefinitionCount = 0;
7 K1 y9 D. R. Y0 b8 n/ ^       for (int i = 0; i < nl.getLength(); i++) {
) ~$ W2 Y" K* v. N           Node node = nl.item(i);
           if (node instanceof Element) {
               Element ele = (Element) node;
8 ~5 s9 @3 l9 ]7 `; A( s( G# x9 V9 a               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
                   importBeanDefinitionResource(ele);
; }3 Q0 i4 O7 e- v8 X               }
: y$ s: g, b- I, z- ?+ a               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
( y) T1 K" h( Y9 n& F8 {5 d6 B                   String name = ele.getAttribute(NAME_ATTRIBUTE);
                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
               }
( p2 j# S, e% R/ Y5 o1 B               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
2 l& [, q; s6 ~) [6 V                   beanDefinitionCount++;
% ~4 M' W% A0 c" C; z                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
' b9 B3 {: X$ {9 \               }
           }
$ m( Z' p. r  b% b8 v, ~       }
. Q3 u# j2 K7 R4 N( K, C+ m       return beanDefinitionCount;
9 R; O% t* [" o& D1 T   }
- h# ?; h- b4 @! ~: D, v, k: v
) n/ {4 @( j) l( ^  L
   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
以下内容为程序代码:

               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
0 o- Q1 N) A5 W                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
) ~! w3 f4 N) X4 F/ m  n                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
               }

   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
以下内容为程序代码:
9 G2 L% j6 M& V3 r) z6 O
   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
9 }9 y7 ]( d8 [5 @
$ i0 m/ e; m/ z- z. K
   好了，就这么多了，本文只作为参考，只讲解了如何加载bean定义这块，只作为一个参考，希望对其他朋友能有所帮助吧，因为时间匆忙，有错漏的地方请指正。