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

三双

源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇文章对觉得困难的朋友有一个帮助。
& K  U/ E' Q5 a3 x# S( g  x
   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。
" b8 ~- k9 J" j1 l* k! {
   首先来打开该类的代码，我们将看到如下代码：
7 V( X+ E5 w8 v7 G" _' e以下内容为程序代码:
0 n5 ]5 ^2 c9 o. G# w# F( c" d3 j2 o
0 H/ X+ ~; i* q/ K/ K7 _public class XmlBeanFactory extends DefaultListableBeanFactory {

: l% u$ S  s! S   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

   public XmlBeanFactory(Resource resource) throws BeansException {
       this(resource, null);
   }

0 t; F6 e1 g3 A) j  P3 C   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
+ l+ g# c3 Q' T+ H" T# v' c       super(parentBeanFactory);
       this.reader.loadBeanDefinitions(resource);
$ g& @- U( G" p' J3 H5 k   }

}
2 u1 e6 _4 v4 F2 l. A5 j  q
/ P: j! b9 Y) \* V' M6 [; O  S* \
2 o  M  Q4 H+ F7 z" U1 v4 N# V' |   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：

以下内容为程序代码:

7 ]) [) @  p' h$ w9 @7 @  h" z   super(parentBeanFactory);
0 a7 K1 ^& v2 k8 D5 [& ?  J   this.reader.loadBeanDefinitions(resource);
, D1 \) B6 c$ N; o0 a$ ~2 x

7 S0 [" j+ k8 n# n4 T0 Y/ ~( R   第一句就是将父亲工厂交给父类的构造函数，实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，那接下来我们再看被调用的loadBeanDefinitions方法，这个方法里最主要的部分就是：
9 K) j. x2 ?' X. p, j
5 j+ b- A3 e. K5 Z以下内容为程序代码:
" V6 Q- Y% e0 s  `, a) U
       InputSource inputSource = new InputSource(inputStream);
               if (encodedResource.getEncoding() != null) {
. S, i  b* c; i, G. _3 f                   inputSource.setEncoding(encodedResource.getEncoding());
; g/ x% p3 R2 K) x: U               }
2 u% ^8 W  _2 Z9 L- P       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
# G: ^6 E. ~- [" D" m+ y! U: e
' R' q  k: }4 q& J1 ^
   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法
- \. l3 H" f; ]9 t6 K( b2 {

1. 
   
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   
3.            if (logger.isDebugEnabled()) {
   
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   9 j& G8 k. q0 l( }5 F9 K! `
5.            }
   
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   : B7 w; B! O+ u% X0 J! t3 r
7.            Document doc = builder.parse(inputSource);
   
8.            return registerBeanDefinitions(doc, resource);
   # p  J- o* A& h  J( J6 i' z8 f

复制代码

$ D. k( s) ~% |& J6 a: {
2 P8 N) C( O2 D6 `5 l   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
, U" A/ w$ k- G以下内容为程序代码:
% ?" e, R6 c3 H4 q$ c
8 H; L. z+ V9 W# N5 L- S0 r8 p   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
       XmlBeanDefinitionParser parser =
               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
       return parser.registerBeanDefinitions(this, doc, resource);
   }

5 h2 |& t1 f1 n* P% @
   这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：
以下内容为程序代码:
+ V* ^3 A6 `8 b
   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
5 D+ I$ S$ z& Z6 h0 T           throws BeanDefinitionStoreException {
+ C) I: o! u  |0 b, X
       this.beanDefinitionReader = reader;
       this.resource = resource;

1 I  {+ l" }3 H% O       logger.debug("Loading bean definitions");
       Element root = doc.getDocumentElement();
" Y- }. r7 \- a% r. r       //初始化根元素
       initDefaults(root);
       if (logger.isDebugEnabled()) {
5 G9 c. u9 s2 `4 S8 f           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
       }
! |* J- ?) O" h" q5 Z
1 O  z* x' X' h       preProcessXml(root);//一个空方法用于扩展
+ f# r1 f9 G3 {- I       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
1 Y! z; V7 @9 q/ T       if (logger.isDebugEnabled()) {
; q% r9 p" p. e$ d' \& S$ w4 `8 I           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
       }
" `" W/ a& Y7 ?/ w. ]       postProcessXml(root); //一个空方法用于扩展
- V9 b5 u$ S3 Y  B
       return beanDefinitionCount;
; C1 Q( y9 X6 a; i9 Q; P3 j   }
- ?1 R+ i' I' P6 R) l
; |/ i& w, L: |" A
   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
0 R/ ^- L* z* f- ^- E以下内容为程序代码:
: _* L, x: r3 G* c. n, `
# R" R! F: H- {$ }: C& I   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
2 @- U/ [) B5 ?  \5 c1 Y+ _( G       NodeList nl = root.getChildNodes();
       int beanDefinitionCount = 0;
       for (int i = 0; i < nl.getLength(); i++) {
           Node node = nl.item(i);
           if (node instanceof Element) {
: O- I' K0 A( U               Element ele = (Element) node;
               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
1 V- L, g3 B, Z% y4 E                   importBeanDefinitionResource(ele);
' ^* _: Y. v- r9 `; U# a. v               }
. G- G. @% o. p5 o+ q               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
/ L( J5 _! E7 ?8 r" D; S# m6 H                   String name = ele.getAttribute(NAME_ATTRIBUTE);
                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
               }
               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
3 t7 [: }) G' d' p) q* ~* V! N/ R2 ~9 p                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
$ Q# s0 E* @- F# e( [! l               }
           }
2 D$ h9 d" k' B& D7 R- V! P! f       }
       return beanDefinitionCount;
   }
6 t0 e$ n- y; V+ }( `; l7 v

+ z8 G+ l: ?5 t4 _2 E2 L   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
8 P- l8 n: F* F* E8 d; f- z6 X以下内容为程序代码:

               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
- k6 ]& V, k+ {  a$ W  w' y7 r                   beanDefinitionCount++;
+ C2 t; Z& s0 n5 x                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
               }

  y/ @2 n; d" ^7 ^7 E- Q   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
% N: b* z. {& b' ~以下内容为程序代码:
7 z' ^( s9 J3 X
$ z- n2 `  G% ~/ F, ^7 c" Z   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
; g  q' O! t; [) g

# V8 Q5 _3 ~* O- y   好了，就这么多了，本文只作为参考，只讲解了如何加载bean定义这块，只作为一个参考，希望对其他朋友能有所帮助吧，因为时间匆忙，有错漏的地方请指正。