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

三双

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

1 q4 t# p# x) I2 c   首先来打开该类的代码，我们将看到如下代码：
* X5 y4 N* M0 E  E" E9 L" ?: i以下内容为程序代码:

public class XmlBeanFactory extends DefaultListableBeanFactory {
9 j7 ]  J2 E/ c1 E% m
   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
: \' m% L# J  x; U- u" K
8 @' `% y8 D/ \8 B0 {+ ^5 {) Y# v   public XmlBeanFactory(Resource resource) throws BeansException {
       this(resource, null);
5 N8 |4 e( n# q3 B/ U   }
$ ^/ Q/ L; K5 h) x4 ]5 Z  V) f
& h% A' R4 P! [" h   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
       super(parentBeanFactory);
       this.reader.loadBeanDefinitions(resource);
   }

}
7 C3 r- u- s" l) u8 D

4 [- w" L' M/ R   这个类的代码很简单，一个成员对象加两个构造函数，从这里我们可以看出，最重要的地方在于最后一个构造函数：

以下内容为程序代码:
: R  T  k) P3 c" Y: f9 [( Z' W
   super(parentBeanFactory);
% s# `! `; p( L- A* B. y8 I: W2 O   this.reader.loadBeanDefinitions(resource);


7 X  E- \. U, l   第一句就是将父亲工厂交给父类的构造函数，实际上最后也就是把父工厂保存到类的parentBeanFactory成员对象中，这个对象是在AbstractBeanFactory抽象类中定义的，而这个父工厂也会一直传递到该抽象类进行保存。第二句就是整个类中最重要的地方了，顾名思义，它的目的是通过XmlBeanDefinitionReader这个XML的Reader从资源resource中（也就是你的配置文件）读取bean的定义。接下来我们打开XmlBeanDefinitionReader的loadBeanDefinitions方法，我们可看到在这个方法里代码就一行，调用了一个同名不同参的方法，而参数是EncodedResource的一个实例，这个类实际上是Resource的一个包装类，用来保存资源的Encode的，那接下来我们再看被调用的loadBeanDefinitions方法，这个方法里最主要的部分就是：
/ h7 F, w6 j, r$ A3 \+ V/ I# {( E( ?
) E/ d' c' b7 |# U/ ]3 h! ~) }以下内容为程序代码:
8 O% l  A% {2 [( z. H: g. a
       InputSource inputSource = new InputSource(inputStream);
               if (encodedResource.getEncoding() != null) {
                   inputSource.setEncoding(encodedResource.getEncoding());
0 {, R" Q/ u" q  I- t; d3 J               }
& m. q# _: J6 {5 r0 {       return doLoadBeanDefinitions(inputSource, encodedResource.getResource());


1 v: [# m$ d& n/ H$ J   这里的目的是将资源包装成一个InputSource，连同Resource作为参数传递到doLoadBeanDefinitions方法

! B- e" S8 a" C

1. 
   0 S# I; |- q6 j0 ?1 O  S
2.            DocumentBuilderFactory factory = createDocumentBuilderFactory();
   
3.            if (logger.isDebugEnabled()) {
   5 M# v& b6 j$ W! i# ?  ^
4.                logger.debug("Using JAXP implementation [" + factory + "]");
   
5.            }
   
6.            DocumentBuilder builder = createDocumentBuilder(factory);
   ( Z) N: T# B* s7 J6 G0 h7 N
7.            Document doc = builder.parse(inputSource);
   - o) ]. G: T& K; M
8.            return registerBeanDefinitions(doc, resource);
   

复制代码

) n4 n6 ^6 \' H  s' N
. r8 A: |; V' p. w   这个方法的目的一目了然，就是为了将资源解释成为Document对象，然后调用registerBeanDefinitions方法，这里不做详细解释，不了解的话请去看看关于JAXP的介绍。接下来我们打开registerBeanDefinitions方法：
以下内容为程序代码:

) G' V) O6 M! ^* R8 E- E   public int registerBeanDefinitions(Document doc, Resource resource) throws BeansException {
+ l* J. E, ^2 n/ n: F" {0 E' a       XmlBeanDefinitionParser parser =
' E. B4 J1 Q* u7 x. t3 o6 S               (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
, a$ E. t# M# J3 e" S" a       return parser.registerBeanDefinitions(this, doc, resource);
) ?, }- e& c7 L( m$ o! U   }


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

   public int registerBeanDefinitions(BeanDefinitionReader reader, Document doc, Resource resource)
           throws BeanDefinitionStoreException {
& }+ r( \4 P9 m) p' a
$ `* P/ F. O, N5 U2 W2 G% \, S/ k       this.beanDefinitionReader = reader;
       this.resource = resource;
( s$ s' W; k& G, n1 I) q. N
       logger.debug("Loading bean definitions");
# b: a* ?2 P: r" a5 O$ m       Element root = doc.getDocumentElement();
" q3 U( F1 z' j" B       //初始化根元素
( U7 L3 c4 j- C       initDefaults(root);
- V# e& v# }% r% e: ]0 a       if (logger.isDebugEnabled()) {
           logger.debug("Default lazy init '" + getDefaultLazyInit() + "'");
           logger.debug("Default autowire '" + getDefaultAutowire() + "'");
           logger.debug("Default dependency check '" + getDefaultDependencyCheck() + "'");
6 J  @# h% w' ?       }
: ~& }( m) `+ c; ]* v" c! D
       preProcessXml(root);//一个空方法用于扩展
       int beanDefinitionCount = parseBeanDefinitions(root);//解释配置的主要方法
       if (logger.isDebugEnabled()) {
; Z! e4 O+ G. z7 b           logger.debug("Found " + beanDefinitionCount + " <bean> elements in " + resource);
) O' I. P" U1 q, N       }
5 g/ N& `4 V. x. m( N) U       postProcessXml(root); //一个空方法用于扩展

       return beanDefinitionCount;
   }
/ l0 l0 \! T0 U& t& O: a# L2 G
, P" G9 k1 d  P6 [: x6 Q
1 m) |2 R4 U3 K1 L7 w1 k7 I   在这个方法当中，主要用于解释定义的有两个方法，一个是initDefaults，一个是parseBeanDefinitions，第一个方法是用来解释根元素的属性的，例如lazy-init, autowire等，而parseBeanDefinitions就是用来解释具体的bean定义了，方法代码如下：
# ?2 Q  V8 @9 x0 p/ B$ Z* H以下内容为程序代码:
0 |# _# C4 i7 t/ i# ^" i
   protected int parseBeanDefinitions(Element root) throws BeanDefinitionStoreException {
       NodeList nl = root.getChildNodes();
       int beanDefinitionCount = 0;
3 W  x* y* l; K; l2 g" G       for (int i = 0; i < nl.getLength(); i++) {
0 p4 g: }9 _' c" |, m+ j5 R. E! H! U           Node node = nl.item(i);
. d# R7 N2 L/ l2 f& K$ S2 X           if (node instanceof Element) {
5 W) p" ^5 r3 k8 C- S# V3 C               Element ele = (Element) node;
$ r" M+ R' q: D9 t* v' g3 l; v               if (IMPORT_ELEMENT.equals(node.getNodeName())) {
6 }6 s6 ~& T, D4 x1 K: j/ H9 w                   importBeanDefinitionResource(ele);
* j/ `8 J4 m; G( X2 X5 Y6 k               }
               else if (ALIAS_ELEMENT.equals(node.getNodeName())) {
0 {4 P9 p5 v. N8 G9 [2 g                   String name = ele.getAttribute(NAME_ATTRIBUTE);
7 p- ~* }0 B: ]" _0 S                   String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
: `/ a2 M8 t0 X                   this.beanDefinitionReader.getBeanFactory().registerAlias(name, alias);
               }
               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
6 E, X- n1 B) Q$ }! d                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
& }/ k+ \" K* q- y' d  C$ A) n4 h, o                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
- M4 t2 g5 J8 A7 ]               }
           }
3 m& [. Z5 R% `       }
. ]! W4 f/ r0 i       return beanDefinitionCount;
$ `3 l- X" ]: @2 J: j& e   }


/ s! E: b  T8 t6 i; y: R   其他标签具体如何被解释这里就不多说，相信大家也能看得懂，这里主要讲一下解释bean的的处理，我们注意以下代码：
以下内容为程序代码:
$ r/ @2 f+ l8 q8 s, I) B  P
" t, A, p. V% V. [2 k& {  @               else if (BEAN_ELEMENT.equals(node.getNodeName())) {
1 A- t$ n* Z) W                   beanDefinitionCount++;
                   BeanDefinitionHolder bdHolder = parseBeanDefinitionElement(ele, false);
# r) O. p3 U' y" I: F                   BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.beanDefinitionReader.getBeanFactory());
               }

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

% M! r8 A- D9 R) @
0 d# Q0 H" y8 C. ]   好了，就这么多了，本文只作为参考，只讲解了如何加载bean定义这块，只作为一个参考，希望对其他朋友能有所帮助吧，因为时间匆忙，有错漏的地方请指正。