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

三双

源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇文章对觉得困难的朋友有一个帮助。
2 I2 E& H* B4 E2 I2 K6 K
# z- M! g! u& K* a. N   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。

   首先来打开该类的代码，我们将看到如下代码：
8 O2 O! V4 a8 O# z以下内容为程序代码:
. h! P: \  J4 U
( X" c+ Q  G1 _! wpublic class XmlBeanFactory extends DefaultListableBeanFactory {

3 M5 e% r: j" S, X  a0 l$ }   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
& i2 Z4 Z# i- {( B2 }" @
   public XmlBeanFactory(Resource resource) throws BeansException {
: I, R! W1 K$ V2 S3 g9 a3 X       this(resource, null);
" q: P9 A- L1 Q6 V; u1 u- f   }
! r- Y: d4 H  k. y5 G
1 A8 S# B, F1 r# F$ h! J; }$ S   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
7 z4 G3 _" Z+ n! Z7 v: z: l       super(parentBeanFactory);
) `! {7 k5 x/ S# v       this.reader.loadBeanDefinitions(resource);
: a/ ^# I8 H' |8 O6 o$ |   }

) M9 H8 F6 V$ Q4 C}
- O/ b' R! P* p1 d  I! M) I

" N4 e3 O% n5 [( R9 K, [   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：
: x) f, q& E- ~
" T! @& J: d2 L+ B9 Y! d6 x: x2 A以下内容为程序代码:

+ ~( D& [- n0 V3 H. y9 W' H   super(parentBeanFactory);
   this.reader.loadBeanDefinitions(resource);
& C' ^: y" j  s/ W  ]
) E. I8 o& J1 }- |! Q" x) o
! p& O4 q% w* s9 d; E5 Y% Z+ s   第一句就是将父亲工厂交给父类的构造函数，实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，那接下来我们再看被调用的loadBeanDefinitions方法，这个方法里最主要的部分就是：

以下内容为程序代码:
9 M- ^4 O8 O9 C; C# _
+ p- L5 W. A5 e" M3 B- m       InputSource inputSource = new InputSource(inputStream);
/ B& Y3 R; m: g/ C' h8 a6 j               if (encodedResource.getEncoding() != null) {
, d. V/ [& e0 a- J0 u                   inputSource.setEncoding(encodedResource.getEncoding());
$ x% _. n% v) j               }
       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());


% Y6 {8 B9 O9 |9 D   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法
9 F* {1 ^$ t8 ]5 t. \- ^7 p

1. 
   * k+ {3 [' H" z- [
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   # P8 v0 i0 r. q
3.            if (logger.isDebugEnabled()) {
   / E0 n0 v: Z7 T) D
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   
5.            }
   
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   
7.            Document doc = builder.parse(inputSource);
   
8.            return registerBeanDefinitions(doc, resource);
   

复制代码

/ g  }, j" B( k0 G
   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
以下内容为程序代码:

# u- s, P# J3 _! W. V. f   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
       XmlBeanDefinitionParser parser =
, G2 n1 V8 Z; z" c5 U               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
" v% n0 t9 V- t6 J       return parser.registerBeanDefinitions(this, doc, resource);
   }


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

   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
           throws BeanDefinitionStoreException {

       this.beanDefinitionReader = reader;
       this.resource = resource;
  [6 i' Q/ c3 A& z3 l5 I
       logger.debug("Loading bean definitions");
       Element root = doc.getDocumentElement();
       //初始化根元素
+ o2 s0 q$ c: o. o; W% W0 }4 N9 z       initDefaults(root);
       if (logger.isDebugEnabled()) {
: k3 ~5 K( V1 @' n1 G2 z           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
1 j7 ]9 U* d9 R* e% _  P2 x           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
       }

  R, e- a9 H$ E; f1 M+ b8 P/ f       preProcessXml(root);//一个空方法用于扩展
       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
       if (logger.isDebugEnabled()) {
/ z8 t1 t  Q6 U6 O4 R           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
) B, L2 r* U2 q  l       }
' h" T8 z5 r  j, u& i$ J1 G       postProcessXml(root); //一个空方法用于扩展
( [* N1 [& V! Q4 A$ V4 c: {5 T4 i
       return beanDefinitionCount;
  t5 N, r9 [$ _: u4 p6 `! R   }
( X' t6 G* C; H2 Q  z

! H8 e. D+ O3 `" g. D3 ?0 j$ i   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
以下内容为程序代码:

1 R% H' X2 }: O; f' g2 q; n5 h   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
2 E2 g; g7 m. P% ?9 A       NodeList nl = root.getChildNodes();
5 N" D. i# p- G& y3 B       int beanDefinitionCount = 0;
       for (int i = 0; i < nl.getLength(); i++) {
           Node node = nl.item(i);
- \% h3 l& P" ^6 J: l! W5 d3 b/ W           if (node instanceof Element) {
               Element ele = (Element) node;
               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
2 Y- Z4 [1 O8 _                   importBeanDefinitionResource(ele);
" Z3 P  o5 g! W" ]+ R1 A               }
               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
, w% W$ o' B1 z' o4 O- k/ i                   String name = ele.getAttribute(NAME_ATTRIBUTE);
                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
) e: p( w( w9 ?$ p  N                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
9 t5 [1 L+ z' A  l6 i$ F, J               }
               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
- D7 i6 R( @: e, O               }
           }
0 D1 I# Q  X; c- R       }
; E) c" o3 ?; s& j$ q3 i       return beanDefinitionCount;
   }
3 H5 H  y8 ?4 k  x% V0 W. j
$ v3 K% K9 {6 W; N1 y$ u
   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
以下内容为程序代码:
6 b6 `8 K) N6 G  f- A
; y' R5 h: g) k# c: c% C5 O               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
; n( \  S; f- a$ }& C                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
) Q6 U# e) K$ ^9 Y; r               }

   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
以下内容为程序代码:
. A6 O" E1 w6 D/ s0 }  d- Z7 w" m
   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);


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