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

三双

源代码分析，是一件既痛苦又快乐的事情，看别人写的代码是通过的，但当你能够看明白的时候，相信快乐也会随之而来，为了减少痛苦，更快的带来快乐，在这里希望通过这篇文章对觉得困难的朋友有一个帮助。
* b8 y) K3 H0 A6 ^9 \
   本文以spring框架的XmlBeanFactory为入手点进行分析，希望能够以尽量简洁明了的方式给予有需要的朋友一定的帮助。

   首先来打开该类的代码，我们将看到如下代码：
以下内容为程序代码:
) X6 X9 O- R+ `0 `1 O4 x
public class XmlBeanFactory extends DefaultListableBeanFactory {
0 ^: _. w9 ]8 ^
; Y4 z5 R& r8 j" X   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
9 `$ e  M) I) c- \, _& C: I
   public XmlBeanFactory(Resource resource) throws BeansException {
+ Q2 B  B7 T( a1 b8 V  l: c$ D% x       this(resource, null);
; i+ n. `+ w/ c0 F+ e   }
4 W4 N2 W" a" N. K
9 v2 r3 m  L; w; j2 Y$ s: b   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
! Y! |+ Y( u# L" E5 K6 Y- p       super(parentBeanFactory);
       this.reader.loadBeanDefinitions(resource);
& Z) L" U/ b4 w/ ?% Z* G  b, r   }

5 M; g9 n% Z, M/ N! A  X}
6 O5 @  f/ C& q3 p. g# H

5 T* U. A/ _* \  @7 U8 k' k5 q   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：
  M# `% Z5 L0 \* W5 `* ]4 F
  T! V& V6 c! R5 l0 K% {以下内容为程序代码:

   super(parentBeanFactory);
   this.reader.loadBeanDefinitions(resource);
; u3 h. T, r" A; g% _# ^' T
4 L/ G3 i3 p7 ?6 m( s- Q3 Z4 N5 y
   第一句就是将父亲工厂交给父类的构造函数，实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，那接下来我们再看被调用的loadBeanDefinitions方法，这个方法里最主要的部分就是：

* ]4 K' j  r1 e3 Q* t' v3 D  \以下内容为程序代码:
0 }% J/ _3 ~6 }( A# O2 I- O( E; A
$ T  a6 V+ ]+ a       InputSource inputSource = new InputSource(inputStream);
               if (encodedResource.getEncoding() != null) {
                   inputSource.setEncoding(encodedResource.getEncoding());
- c& d3 K0 E. Z2 z               }
       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
$ c7 k8 ]! b* d5 ~1 X6 Z
, f3 U# A. Q) y2 r9 u
( ?; N+ {, s7 A8 _3 h* T1 z   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法
& d; ?1 v! G1 d. o9 j8 h

1. 
   
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   ( Z# C1 p. c) B3 x% V3 m$ F* D9 w
3.            if (logger.isDebugEnabled()) {
   
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   * V' T) X# y- X- g# c4 ~2 R
5.            }
   ) r9 j6 M7 R" ^6 z
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   8 a  k, d3 B- R+ H% y. y
7.            Document doc = builder.parse(inputSource);
   
8.            return registerBeanDefinitions(doc, resource);
   

复制代码

3 O! h9 T+ o+ b: @8 S
   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
- c: ~) V8 Y$ p以下内容为程序代码:
) D0 [6 O* t" Q/ [
   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
       XmlBeanDefinitionParser parser =
               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
       return parser.registerBeanDefinitions(this, doc, resource);
   }

, U2 B- I' ^' i7 _4 V
   这里创建了一个XmlBeanDefinitionParser接口的实现，这个接口的具体类是DefaultXmlBeanDefinitionParser，这个接口很简单，只有registerBeanDefinitions一个方法，这个方法的作用也很明了，就是用来注册Bean的定义的，所以说类和方法的名字一定要起得有意义，这样可以让人一看就大概了解其作用，减少了很多阅读代码的痛苦。废话不多说，我们打开DefaultXmlBeanDefinitionParser的registerBeanDefinitions方法，这个类就是解释XML配置文件的核心类了，打开registerBeanDefinitions方法后我们看到如下代码：
, W  N6 _  l" Y2 T6 Z: l以下内容为程序代码:
0 M7 i/ @' n7 {4 X3 ]' o
   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
  [- x! x9 o/ h/ o9 Z           throws BeanDefinitionStoreException {
2 A7 n$ B+ d+ v3 _7 O# h
       this.beanDefinitionReader = reader;
       this.resource = resource;

# J" }0 c- |; }% q! _/ p3 R       logger.debug("Loading bean definitions");
2 g! k) ?$ y" H8 h& f5 y8 W) v$ M       Element root = doc.getDocumentElement();
       //初始化根元素
       initDefaults(root);
       if (logger.isDebugEnabled()) {
           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
       }
  [! C! K$ {, _( K5 V! t1 z9 C6 |
       preProcessXml(root);//一个空方法用于扩展
       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
1 V- \4 q& F0 Z! y$ J# {       if (logger.isDebugEnabled()) {
           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
5 E! D1 k" E  g- ~       }
1 y& g& k: Z4 T       postProcessXml(root); //一个空方法用于扩展

       return beanDefinitionCount;
' j" k9 f$ K$ Y& {   }

9 w) T, B' E- I! S0 w
   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
以下内容为程序代码:

! x! {4 z- h1 y8 Z) D/ @   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
. u; w9 ~* ?* w$ V/ ~0 L       NodeList nl = root.getChildNodes();
       int beanDefinitionCount = 0;
$ S' z  @% f! e+ I" f; {       for (int i = 0; i < nl.getLength(); i++) {
' [9 Z& t  a  v, a) f2 ?6 S           Node node = nl.item(i);
: Q3 L, X+ [7 ~# z( F. p           if (node instanceof Element) {
               Element ele = (Element) node;
, H$ w7 G( l. b5 `               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
                   importBeanDefinitionResource(ele);
               }
               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
3 |$ F; ]$ p& @4 \* E                   String name = ele.getAttribute(NAME_ATTRIBUTE);
                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
$ Y2 A' }8 t, ^$ P0 C                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
               }
               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
/ t, ?6 v5 P% _! m( `                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
               }
           }
$ M( p4 S# \/ L. V1 L, c6 `8 ^       }
       return beanDefinitionCount;
3 ]! q' Z3 p7 p   }
! ], r$ G& l' ]4 w
$ l9 X: q# ?8 `* p! B) }4 c6 T
   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
以下内容为程序代码:
( ^  V( @$ v* S' Z
: s  B+ ?7 u1 [. r' R2 ]               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
4 k* e3 Q# N9 |% s( l( Z                   beanDefinitionCount++;
0 ^& K( i& I5 E. ~% z+ X9 [                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
5 Y7 v: l2 c$ b% ?1 a                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
2 N( \% V% L0 q% o               }
/ N# k; \6 p; b. S# h
   这里是当碰到一个bean标签的时候所进行的处理，也既是对bean的定义进行解释，可以看到parseBeanDefinitionElement方法的第一个参数就是bean则个元素，第二个参数表示该bean是否为内置的bean，从这里进行解释的bean都不可能是内置的，所以这里直接以false为参数，打开parseBeanDefinitionElement方法，就可以看到这个方法里就是对bean的内部的解释，也很简单，也不多讲了，呵呵（下班时间已经到了，所以就写这么多了，基本的流程也就这样，没什么特别难的地方。），对了，最后还有一点就是解释完后，bean的定义将会被保存到beanFactory中，这个beanFactory的实现就是XmlBeanFactory了，该beanFactory是在new的时候被传递到reader中的，就是该类中以下这行代码：
& C5 `9 y* ^0 N以下内容为程序代码:

/ N# }5 T8 ^4 r! C( e) X6 I: E0 e   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);


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