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

三双

源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇文章对觉得困难的朋友有一个帮助。
* o$ h* E8 e0 H$ p* P/ D
6 ~& ~4 R8 z1 I/ @4 [   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。
9 o( L: [  p' W
+ y7 d: ]  E9 ]   首先来打开该类的代码，我们将看到如下代码：
0 F3 L8 R/ f& o以下内容为程序代码:

public class XmlBeanFactory extends DefaultListableBeanFactory {
7 }" {& S6 Q/ @- n! R
9 ~$ W; a5 m8 r/ {: ]5 I# v+ b   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
+ w6 n) t1 A0 c  Z
   public XmlBeanFactory(Resource resource) throws BeansException {
' g1 X, y/ Y% u       this(resource, null);
   }

   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
6 D. E6 t1 P" e  h/ @+ i       super(parentBeanFactory);
       this.reader.loadBeanDefinitions(resource);
   }

% Q$ D) m& y  U1 f( x& |/ ~}
# ?2 ^, T( o: G! b/ Y/ r: J1 |
8 A# Q) M! q: H3 M7 `. y
$ f! T7 z7 d) j8 E8 n3 T$ p: I   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：

! K" j/ ?1 c- T' w& G3 ]3 {以下内容为程序代码:

   super(parentBeanFactory);
' o5 y; A* Q4 F# i   this.reader.loadBeanDefinitions(resource);


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

! h% [+ Z4 K+ R, d6 ~) Y3 |3 u       InputSource inputSource = new InputSource(inputStream);
: S; d0 S5 h! `3 a8 a               if (encodedResource.getEncoding() != null) {
/ J( e. r- w9 x; L) n                   inputSource.setEncoding(encodedResource.getEncoding());
               }
       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
; R- m3 [1 X+ d$ d& E

   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法
( c- z* d+ I2 J/ L: ~; y7 o) S' m
7 c2 H8 f0 b; F

1. 
   + Z& n( F8 q7 C
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   
3.            if (logger.isDebugEnabled()) {
   
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   
5.            }
   
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   
7.            Document doc = builder.parse(inputSource);
   
8.            return registerBeanDefinitions(doc, resource);
   ; j, |+ N/ r, V. k' a

复制代码

+ a3 b" C9 N5 J" M& t
5 [/ h5 p- p6 f4 u2 V   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
以下内容为程序代码:

   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
       XmlBeanDefinitionParser parser =
               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
       return parser.registerBeanDefinitions(this, doc, resource);
$ l9 g& S6 t& e+ m+ E   }

; C' t& u2 C5 f/ u$ H" t- j- X- ]2 w
   这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：
以下内容为程序代码:
/ B4 V9 k* y2 `. F
! d# }+ u  u1 T% x" Y   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
# E- x" c. `* [3 U% u% W           throws BeanDefinitionStoreException {

       this.beanDefinitionReader = reader;
( |5 u) X* X2 A( B7 Z& D# `       this.resource = resource;

       logger.debug("Loading bean definitions");
- c* [/ u3 t# q# C       Element root = doc.getDocumentElement();
, T+ w: b, v! B6 n. k$ M       //初始化根元素
- C- L! e6 ^& ^! c       initDefaults(root);
       if (logger.isDebugEnabled()) {
           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
  N2 d' ]1 n/ I+ J2 ~2 u  Z4 g           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
4 \2 w8 `) c, O, ~6 r% D           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
       }
! P: C1 M5 t# I6 C' E
       preProcessXml(root);//一个空方法用于扩展
* _' s5 E' a0 t5 I       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
       if (logger.isDebugEnabled()) {
/ O5 J; |5 B- d1 T           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
       }
       postProcessXml(root); //一个空方法用于扩展

       return beanDefinitionCount;
   }
, m5 |/ X8 x) B

   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
6 X( I8 k3 l1 S) S' O  [5 z1 f以下内容为程序代码:
. |7 p# [" s! y# }5 D1 @! N" ^
   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
" O1 f% n1 x, f4 Z" K, Q5 v       NodeList nl = root.getChildNodes();
       int beanDefinitionCount = 0;
0 j: w, S+ K4 v! j- m! i) H       for (int i = 0; i < nl.getLength(); i++) {
           Node node = nl.item(i);
           if (node instanceof Element) {
               Element ele = (Element) node;
               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
                   importBeanDefinitionResource(ele);
               }
               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
7 S% ?% w& x% _  Q" ~                   String name = ele.getAttribute(NAME_ATTRIBUTE);
                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
$ Y9 v' _9 r+ h. [3 H* X! d" o                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
( J" {4 B3 v; o) N+ x               }
4 P2 i6 [# ?3 s               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
8 e7 L! k3 k% ]# S                   beanDefinitionCount++;
* w  ~, `6 C  k; [% o, m9 B                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
4 j* i: m4 O6 j/ p) t               }
+ ]( P0 b: w; {: m           }
       }
       return beanDefinitionCount;
2 Y; z: m( U* \" S; I& V6 X   }

6 r; f* N( _- C* M; Y
. ~5 L0 ^4 {2 o7 g: Q" n2 t   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
# I% S3 T. N. [* M- k3 `以下内容为程序代码:

, W# h. F! f# w               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
# O0 a1 H1 ?7 ?6 N& B3 l) a                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
% r" A% y* h6 N  z* R               }

9 w. C1 ~) t. v% ]4 q: M" D8 V   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
6 O# |! w3 \9 T0 T! d以下内容为程序代码:
, v1 v( K1 ?" n# G
" l5 M5 |( {# S+ ]   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);


. L% T: E( `; g8 A& g% {" X  x   好了，就这么多了，本文只作为参考，只讲解了如何加载bean定义这块，只作为一个参考，希望对其他朋友能有所帮助吧，因为时间匆忙，有错漏的地方请指正。