51. for (int i = 0; i < nl.getLength(); i++) { 52. Node node = nl.item(i);
53. if (node instanceof Element && !DomUtils.nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
54. !DomUtils.nodeNameEquals(node, META_ELEMENT)) {
55. // Child element is what we're looking for. 56. if (subElement != null) {
57. error(elementName + \n one sub-element\58. }
59. else {
60. subElement = (Element) node; 61. } 62. } 63. }
64. //这里判断property的属性，是ref还是value,不允许同时是ref和value。
65. boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
66. boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
67. if ((hasRefAttribute && hasValueAttribute) ||
68. ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
69. error(elementName +
70. \bute OR 'value' attribute OR sub-element\71. }
72. //如果是ref，创建一个ref的数据对象RuntimeBeanReference,这个对象封装了ref的信息。 73. if (hasRefAttribute) {
74. String refName = ele.getAttribute(REF_ATTRIBUTE); 75. if (!StringUtils.hasText(refName)) {
76. error(elementName + \e\77. }
78. RuntimeBeanReference ref = new RuntimeBeanReference(refName);
79. ref.setSource(extractSource(ele)); 80. return ref; 81. } //如果是value，创建一个value的数据对象TypedStringValue ,这个对象封装了value的信息。
82. else if (hasValueAttribute) {
83. TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
84. valueHolder.setSource(extractSource(ele)); 85. return valueHolder;
86. } //如果还有子元素，触发对子元素的解析 87. else if (subElement != null) {
88. return parsePropertySubElement(subElement, bd); 89. }
90. else {
91. // Neither child element nor \ found.
92. error(elementName + \);
93. return null; 94. } 95.}
比如，再往下看，我们看到像List这样的属性配置是怎样被解析的，依然在BeanDefinitionParserDelegate中：返回的 是一个List对象，这个List是Spring定义的ManagedList，作为封装List这类配置定义的数据封装，如以下代码清单所示。 Java代码
1. public List parseListElement(Element collectionEle, BeanDefinition bd) {
2. String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
3. NodeList nl = collectionEle.getChildNodes();
4. ManagedList
5. target.setSource(extractSource(collectionEle)); 6. target.setElementTypeName(defaultElementType);
7. target.setMergeEnabled(parseMergeAttribute(collectionEle));
8. //具体的List元素的解析过程。
9. parseCollectionElements(nl, target, bd, defaultElementType);
10. return target; 11.}
12.protected void parseCollectionElements(
13. NodeList elementNodes, Collection
14. //遍历所有的元素节点，并判断其类型是否为Element。
15. for (int i = 0; i < elementNodes.getLength(); i++) { 16. Node node = elementNodes.item(i);
17. if (node instanceof Element && !DomUtils.nodeNameEquals(node, DESCRIPTION_ELEMENT)) {
18. //加入到target中去，target是一个ManagedList，同时触发对下一层子元素的解析过程，这是一个递归的调用。
19. target.add(parsePropertySubElement((Element) node, bd, defaultElementType)); 20. } 21. } 22.}
经过这样一层一层的解析，我们在XML文件中定义的BeanDefinition就被整个给载入到了IoC容器中，并在容器中建立了数据映射。在 IoC容器中建立了对应的数据结构，或者说可以看成是POJO对象在IoC容器中的映像，这些数据结构可以以 AbstractBeanDefinition为入口，让IoC容器执行索引、查询和操作。
在我的感觉中，对核心数据结构的定义和处理应该可以看成是一个软件的核心部分了。所以，这里的BeanDefinition的载入可以说是IoC容器的核心，如果说IoC容器是Spring的核心，那么这些BeanDefinition就是Spring的核心的核心了！
呵呵，这部分代码数量不小，但如果掌握这条主线，其他都可以举一反三吧，就像我们掌握了操作系统启动的过程，以及在操作系统设计中的核心数据结构 像进程数据结构，文件系统数据结构，网络协议数据结构的设计和处理一样，对整个系统的设计原理，包括移植，驱动开发和应用开发，是非常有帮助的！
深入解析Spring架构与设计原理（二）AOP
关于AOP的个人理解
AOP联盟定义的AOP体系结构把与AOP相关的概念大致分为了由高到低、从使用到实现的三个层次。关于这个体系结构，个人的理解是这样的，从上 往下，最高层是语言和开发环境，在这个环境中可以看到几个重要的概念：base可以视为待增强对象，或者说目标对象；aspect指切面，通常包含对于 base的增强应用；configuration可以看成是一种编织或者说配置，通过在AOP体系中提供这个configuration配置环境，可以把 base和aspect结合起来，从而完成切面对目标对象的编织实现。
对Spring平台或者说生态系统来说，AOP是Spring框架的核心功能模块之一。AOP与IOC容器的结合使用, 为应用开发或者Spring自身功能的扩展都提供了
许多便利。Spring AOP的实现和其他特性的实现一样，非常丰富，除了可以使用Spring本身提供的AOP实现之外，还封装了业界优秀的AOP解决方案AspectJ来让 应用使用。在这里，主要对Spring自身的AOP实现原理做一些解析；在这个AOP实现中，Spring充分利用了IOC容器Proxy代理对象以及 AOP拦截器的功能特性，通过这些对AOP基本功能的封装机制，为用户提供了AOP的实现框架。所以，要了解这些AOP的基本实现，需要我们对Java 的Proxy机制有一些基本了解。
AOP实现的基本线索
AOP实现中，可以看到三个主要的步骤，一个是代理对象的生成，然后是拦截器的作用，然后是Aspect编织的实现。AOP框架的丰富，很大程度 体现在这三个具体实现中，所具有的丰富的技术选择，以及如何实现与IOC容器的无缝结合。毕竟这也是一个非常核心的模块，需要满足不同的应用需求带来的解 决方案需求。 在Spring AOP的实现原理中，我们主要举ProxyFactoryBean的实现作为例子和实现的基本线索进行分析；很大一个原因，是因为 ProxyFactoryBean是在Spring IoC环境中，创建AOP应用的最底层方法，从中，可以看到一条实现AOP的基本线索。在ProxyFactoryBean中，它的AOP实现需要依赖 JDK或者CGLIB提供的Proxy特性。从FactoryBean中获取对象，是从getObject()方法作为入口完成的。然后为proxy代理 对象配置advisor链，这个配置是在
initializeAdvisorChain方法中完成的；然后就为生成AOP代理对象做好了准备，生成代理对 象如下所示： Java代码
1. private synchronized Object getSingletonInstance() { 2. if (this.singletonInstance == null) {
3. this.targetSource = freshTargetSource();
4. if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
5. // Rely on AOP infrastructure to tell us what interfaces to proxy.
6. Class targetClass = getTargetClass(); 7. if (targetClass == null) {
8. throw new FactoryBeanNotInitializedException(\annot determine target class for proxy\9. }
10. // 这里设置代理对象的接
口 setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader)); 11. }
12. // Initialize the shared singleton instance. 13. super.setFrozen(this.freezeProxy);
