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

三双

源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇文章对觉得困难的朋友有一个帮助。
) T1 l6 F: r. y, ?2 ]. ^
   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。
( i7 S! }0 `3 S$ |: J, w
   首先来打开该类的代码，我们将看到如下代码：
以下内容为程序代码:
6 y) Z. m# J0 J7 c) U% \9 o$ t
public class XmlBeanFactory extends DefaultListableBeanFactory {

& P4 Q$ }. }* e  I4 f3 a4 o8 Z   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

   public XmlBeanFactory(Resource resource) throws BeansException {
       this(resource, null);
   }
( W; N) a, l3 q) F$ Z
( Y- j8 F4 @  H$ {   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
1 r/ t% T  T/ b0 N       super(parentBeanFactory);
/ d/ F6 D* I7 N+ s6 ^       this.reader.loadBeanDefinitions(resource);
2 ]0 P8 p  x% X$ [& [   }

}


   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：
5 `6 h' [4 o4 c" |, _% O- @$ f
3 `/ G! Q8 A' N! L+ h; H9 Z. y" L以下内容为程序代码:

3 V% P3 h6 j! ?9 j   super(parentBeanFactory);
. Y% g. P+ n6 H0 }% {' H* D/ D! \   this.reader.loadBeanDefinitions(resource);


   第一句就是将父亲工厂交给父类的构造函数，实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，那接下来我们再看被调用的loadBeanDefinitions方法，这个方法里最主要的部分就是：
  J3 w) @( T- k8 j9 Y
. v. I- L5 A0 b, `; h: h7 \, v以下内容为程序代码:

5 I" B* A% B2 [. I  }2 b3 B       InputSource inputSource = new InputSource(inputStream);
1 w* ]1 Z' n' J" A               if (encodedResource.getEncoding() != null) {
1 I  ]1 U# Y2 m- [4 A, i1 e* N: K& m                   inputSource.setEncoding(encodedResource.getEncoding());
               }
* N' K2 ~, t, p. o0 L       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
4 M( d! y$ R% l3 ?/ g

! X5 z0 q- V: g& I- P5 R; {$ v   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法
; X) X7 l5 o4 V7 E9 i6 _" V

1. 
   
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   / k4 s) F( O  u1 ?: S& \
3.            if (logger.isDebugEnabled()) {
   6 Y' C2 j8 h) i, @- H
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   / z  m- @" n. t6 b. x' G" }
5.            }
   
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   3 D1 u; m, Q. k  \  N; l
7.            Document doc = builder.parse(inputSource);
   ' u6 t8 u: \7 N2 G
8.            return registerBeanDefinitions(doc, resource);
   

复制代码

6 y3 D4 N9 U7 X. p1 Y/ N
" o7 s8 w) w  D. T8 H3 M   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
0 [" |, x; O+ R5 b' C; H! p; _以下内容为程序代码:
2 o" ~  t0 x% p$ c
   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
       XmlBeanDefinitionParser parser =
/ _; Q+ B: {. I* B2 _               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
, S) n7 ?: v$ }, N/ v       return parser.registerBeanDefinitions(this, doc, resource);
   }


   这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：
, ^% y. e" O# F. h2 G. |7 g以下内容为程序代码:

) U& e! i: h* c4 H+ ~" ?   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
$ t* C  |6 y3 L+ E0 u$ H           throws BeanDefinitionStoreException {

       this.beanDefinitionReader = reader;
       this.resource = resource;
) q; X5 n4 i4 g& o. y
" b0 w: a: `8 T' H  G$ m       logger.debug("Loading bean definitions");
, p2 o6 i* T; [+ {  M       Element root = doc.getDocumentElement();
       //初始化根元素
* O" W6 G( L* h$ e, |4 E5 Q3 U       initDefaults(root);
       if (logger.isDebugEnabled()) {
; O) \3 d1 J1 Q6 Z7 p- ~2 r           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
- I% T" o: I  P3 i3 N           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
       }
0 N9 ~8 G( \; _. D% p. F
       preProcessXml(root);//一个空方法用于扩展
       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
       if (logger.isDebugEnabled()) {
           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
       }
4 ~; Z2 Y- c; [2 W7 u4 L7 U       postProcessXml(root); //一个空方法用于扩展

       return beanDefinitionCount;
   }


1 R9 R0 V7 h6 X) Q% q& ?   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
" r1 Q6 ~6 N9 Q; A+ L以下内容为程序代码:

   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
       NodeList nl = root.getChildNodes();
5 P, U. s8 O2 A- S( X4 A( x/ F7 `       int beanDefinitionCount = 0;
       for (int i = 0; i < nl.getLength(); i++) {
  ?+ c  q% Y. m& g- \4 V           Node node = nl.item(i);
           if (node instanceof Element) {
5 [7 i9 J0 W& p4 i* X4 v$ [               Element ele = (Element) node;
               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
; L% d9 |7 Y- t. a  K- {. ?! N                   importBeanDefinitionResource(ele);
               }
# ^% |/ O3 ^) T/ A3 ~6 ^               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
1 [9 p. E9 G5 U; [! |! ]: K4 j                   String name = ele.getAttribute(NAME_ATTRIBUTE);
                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
4 E4 F5 ^0 c; k- F% \3 S               }
               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
                   beanDefinitionCount++;
+ F  O1 s+ [' |5 ~                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
# ^3 F0 ]3 b! c2 y8 ^                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
               }
           }
6 X  }) Z8 P3 R$ o& y       }
       return beanDefinitionCount;
2 d0 V5 \0 s; J   }
/ @( t2 W& o! k

: y6 v% p) S  X2 t. ]   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
以下内容为程序代码:

               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
; J! Y! X% {6 Y+ R4 {) Y                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
( r7 ~, p8 B. ~/ D' l3 J4 x9 Q               }

   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
以下内容为程序代码:
- K) a8 T) ~" r) n. i9 B3 O+ ?: V, L
   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
  K6 v, D) u# y9 |2 `1 ?' W

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