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

三双

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

% @2 Y+ C& R* a  F' v$ l& j  _) e   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。
. P) s8 [# Z% c
; K# S; E) T. g. O   首先来打开该类的代码，我们将看到如下代码：
$ j; f2 K' \) K6 @5 }6 V以下内容为程序代码:

7 u% L) d6 N" k2 \2 G; p6 y, ipublic class XmlBeanFactory extends DefaultListableBeanFactory {
, [0 H* |% ~/ L& u
   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
' x5 [- ~1 p2 }8 ?8 c
   public XmlBeanFactory(Resource resource) throws BeansException {
       this(resource, null);
   }

8 @  ^8 `& P1 {4 Z   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
       super(parentBeanFactory);
       this.reader.loadBeanDefinitions(resource);
   }

' W! y9 f( B: D4 D0 k. F}
' o3 `; a, k8 m, b) Y$ I
- u) w: f0 u! e6 F9 G
   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：

以下内容为程序代码:
: c! Z/ ^, K7 M, B
   super(parentBeanFactory);
% X- c% u4 m" w7 D& Z/ y4 a0 l: f   this.reader.loadBeanDefinitions(resource);
0 F" `# ~( E% w# o/ l# {

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

: y8 a0 l; t6 X* h6 F以下内容为程序代码:
) K8 z, B2 T/ }9 d: Z! g% v  a  O/ O
5 t2 N# C* H( H  z( {$ [5 e       InputSource inputSource = new InputSource(inputStream);
               if (encodedResource.getEncoding() != null) {
7 ^) n& ^/ a/ Y  M- }  @                   inputSource.setEncoding(encodedResource.getEncoding());
- ?; q% S, l) }8 e               }
$ |+ F) `$ x, n6 v) ?1 [* B+ V       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());


* q) B, `+ ^9 G: k* z, P   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法
! p  Y7 A( [3 A9 S6 x+ t

1. 
   
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   
3.            if (logger.isDebugEnabled()) {
   ! a1 [3 S8 P, V+ R: ~
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   
5.            }
   
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   
7.            Document doc = builder.parse(inputSource);
   
8.            return registerBeanDefinitions(doc, resource);
   4 e, i( S% C; u: _

复制代码

/ G3 x/ r' h% ?   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
9 }' B! C8 \% Z3 S& m* R7 V" k以下内容为程序代码:
; I4 h& Z9 O7 \# U6 L
6 K* S  q' t7 P4 B  P   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
2 [! s2 k/ y9 B       XmlBeanDefinitionParser parser =
               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
! B# Y& \0 M4 `- r' j( S2 W       return parser.registerBeanDefinitions(this, doc, resource);
   }

9 Y! S8 U7 K1 P/ D+ q# G$ \
+ J4 O9 H7 s2 m* q3 r1 `   这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：
$ m% j* |5 H% }7 d* b+ o以下内容为程序代码:
) G& r6 o/ V. I' H' }! @& s$ r( |
! g  c  @; J4 [5 O# M7 v   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
           throws BeanDefinitionStoreException {
% R6 v: R: y1 }6 {' F
       this.beanDefinitionReader = reader;
0 e, O& C3 ]! L4 S7 I; k       this.resource = resource;

0 |2 _' U3 l( s+ ~: s6 G3 L1 D       logger.debug("Loading bean definitions");
       Element root = doc.getDocumentElement();
       //初始化根元素
7 b4 q& M1 B. ?: ^- X) `       initDefaults(root);
       if (logger.isDebugEnabled()) {
8 k5 M. I9 w: J/ F* ^           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
! w4 y+ Y) O9 _, o% Z, B9 f           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
  c; X  U' f0 x! }2 B6 S; m& Y1 I! d       }

       preProcessXml(root);//一个空方法用于扩展
) @1 k5 f* A, D; A6 P1 S; `       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
       if (logger.isDebugEnabled()) {
           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
* e) a* Z4 V5 Y' ?7 `       }
       postProcessXml(root); //一个空方法用于扩展
: P  \' E, }. m9 b, m2 J
; l6 f- Z/ ^; k) N9 k7 M       return beanDefinitionCount;
0 K5 Y7 {$ `) }6 J. A   }


   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
以下内容为程序代码:
0 i7 M' U) M' p8 Y. y' e0 {
   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
       NodeList nl = root.getChildNodes();
       int beanDefinitionCount = 0;
$ I* G! [6 _  N; H0 H       for (int i = 0; i < nl.getLength(); i++) {
           Node node = nl.item(i);
, b0 H/ B! F5 \9 p$ a5 P           if (node instanceof Element) {
4 c' j) z( V2 @0 K, t+ |% q               Element ele = (Element) node;
% E& }8 |* }! n0 \( U               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
                   importBeanDefinitionResource(ele);
. P) K( C7 E/ S1 [+ y/ Z               }
               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
- C2 |" S6 P- K6 \                   String name = ele.getAttribute(NAME_ATTRIBUTE);
" g- m- T0 Y8 J8 A5 C& G/ L7 p                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
. m  y- H2 H; e$ ?2 X                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
% N1 K( S/ t5 a( u- p! j3 V  C               }
3 l, K1 y5 w: [               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
                   beanDefinitionCount++;
( i, L. j$ H6 @0 l9 G                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
" V0 a5 ]4 {7 u2 ~                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
# c' o2 X' a: R               }
           }
       }
       return beanDefinitionCount;
" ~% v/ y  a8 |: r   }

: c# R6 ]* A/ r+ n  r; C
   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
以下内容为程序代码:

               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
+ C" _( H  f) t% W8 Y% p                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
               }
. ?& L1 I, C8 Z6 i4 i' P5 B( @* i: U
   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
2 y' c8 o0 t, L以下内容为程序代码:
2 T% ^5 o8 L, }+ D' B; p
   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);


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