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

三双

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

; j& U& K" a% ?( ^; N6 }1 f   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。
% d% H6 y7 ]% p7 p% U+ H
   首先来打开该类的代码，我们将看到如下代码：
以下内容为程序代码:

public class XmlBeanFactory extends DefaultListableBeanFactory {
: I8 U6 c1 `; p, |3 z. Y
   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

: G8 w, b+ G  Q5 Y" Y# m) `/ s   public XmlBeanFactory(Resource resource) throws BeansException {
% v" k' L: k9 \' S& n       this(resource, null);
   }

   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
       super(parentBeanFactory);
, K3 o. D2 F' a; ]1 N1 ]; f       this.reader.loadBeanDefinitions(resource);
   }

0 W* d+ D; j" @  C* X}

9 @; ^. x: z) r1 X5 Z2 M2 C
4 B: q' x9 O' ]% ~0 k3 X   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：

以下内容为程序代码:
; h8 h( J' \/ X
   super(parentBeanFactory);
- c) E4 C8 C! Z/ ~   this.reader.loadBeanDefinitions(resource);

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

以下内容为程序代码:

       InputSource inputSource = new InputSource(inputStream);
               if (encodedResource.getEncoding() != null) {
$ I+ l2 S% @( c. b' \6 X                   inputSource.setEncoding(encodedResource.getEncoding());
" M7 Z" z+ o% \; B9 D" {               }
2 ~" P- P7 s% U$ V9 q       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

) |8 D. w6 I0 _
   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法

1. 
   ( w! N9 u# j' `1 K& h7 G; l+ w
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   
3.            if (logger.isDebugEnabled()) {
   # N8 Q4 j9 H2 z* R- X
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   , J7 }# C8 r, j. [* R9 @1 Y% Z
5.            }
   
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   , c( m+ O+ b& h# ?, B
7.            Document doc = builder.parse(inputSource);
   
8.            return registerBeanDefinitions(doc, resource);
   2 Y' c1 a2 m9 n& g

复制代码

3 N/ R: l7 w* V1 y- Z
   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
以下内容为程序代码:
- d" v2 ~+ o) ]" V5 B9 ?& J& m. s
   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
       XmlBeanDefinitionParser parser =
               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
& L9 V; P0 r/ S2 V; D; z' f, Q       return parser.registerBeanDefinitions(this, doc, resource);
8 T, @* \( |" C- _  b% m2 `   }


   这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：
以下内容为程序代码:
7 h- E3 J" i0 t: e3 o4 K! s! G$ s
   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
           throws BeanDefinitionStoreException {

! m$ @  g  \% w6 W7 T- O. ?4 ^       this.beanDefinitionReader = reader;
       this.resource = resource;

       logger.debug("Loading bean definitions");
! L" _5 j, {" Z* `! a/ t1 `8 {       Element root = doc.getDocumentElement();
       //初始化根元素
       initDefaults(root);
9 r# ?4 O7 e4 I$ L6 F& [       if (logger.isDebugEnabled()) {
           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
       }
$ j; ~; u" K; L4 k
# c0 a( H" X1 N       preProcessXml(root);//一个空方法用于扩展
       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
$ k" D% @1 D  E* o9 V       if (logger.isDebugEnabled()) {
$ A( M- [( Y7 b9 x, @           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
       }
0 |$ [* R6 p2 b7 a$ Y) h       postProcessXml(root); //一个空方法用于扩展
) \% W' W* L( N8 D8 Z3 Q
" r* I* b& Y3 Y7 Q- k2 T       return beanDefinitionCount;
5 K5 Z* x$ C: @" ?' E! @7 R   }

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

4 K! F0 j( W0 V3 y0 L   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
/ ~& R2 C' [2 d  K4 l) e  V! @       NodeList nl = root.getChildNodes();
) E; L5 T; h: m6 Q- Z: U       int beanDefinitionCount = 0;
& C- a* ], a: H* D       for (int i = 0; i < nl.getLength(); i++) {
1 ~# [( ?' O9 w1 i% u           Node node = nl.item(i);
' @, K" a. g4 R  W           if (node instanceof Element) {
$ d3 }  U1 r; d4 b) p               Element ele = (Element) node;
               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
8 s, y4 j1 D; I) E" l/ o1 D: N                   importBeanDefinitionResource(ele);
9 X& e/ A7 o1 d3 r               }
$ `6 I) {+ h, J5 s6 J1 e               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
                   String name = ele.getAttribute(NAME_ATTRIBUTE);
                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
( {8 \9 `/ b7 g, s3 E, J               }
               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
* G1 R1 L  h6 ]( q0 B; ]6 d/ w                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
0 T, v, b# ^( o. g8 H$ e                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
, ?# Z# ^7 i5 S) v  ?0 V               }
           }
       }
$ \. K( c: z4 @1 k       return beanDefinitionCount;
2 H0 D& ~: V& N  N* I   }
+ H$ o. z0 C, T! J" m8 Q  D

   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
以下内容为程序代码:
$ ?+ y# \, l6 G" |+ c8 u
3 ~  l2 \5 V# M0 E               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
5 G. F5 N$ d. V6 t& q0 d                   beanDefinitionCount++;
+ v" a/ i" h+ G* p) k) _                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
6 l$ @; T2 B3 x: W% _" e+ n                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
- i* I; a: d( x3 w2 ^5 I9 K               }
* u7 t- U# @! {9 _' T
4 l5 P1 n3 U1 s; \. E/ z$ [   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
以下内容为程序代码:

9 L+ a( U  u. t* e: R9 f3 r: ?   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
& i0 V4 Z( v# I1 N  F! U8 ]) [

2 L+ a& J4 y! R. f6 p: z2 q   好了，就这么多了，本文只作为参考，只讲解了如何加载bean定义这块，只作为一个参考，希望对其他朋友能有所帮助吧，因为时间匆忙，有错漏的地方请指正。