BeanDefinitionParserDelegate 源码分析

BeanDefinitionParserDelegate 源码分析

• 博客分类： 
• Spring

 

 

 

Java代码  

1. public class BeanDefinitionParserDelegate {  
2.   
3.     public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";  
4.   
5.     public static final String MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; ";  
6.   
7.     /** @deprecated as of Spring 3.1 in favor of {@link #MULTI_VALUE_ATTRIBUTE_DELIMITERS} */  
8.     public static final String BEAN_NAME_DELIMITERS = MULTI_VALUE_ATTRIBUTE_DELIMITERS;  
9.   
10.       
11.     public static final String TRUE_VALUE = "true";  
12.   
13.     public static final String FALSE_VALUE = "false";  
14.   
15.     public static final String DEFAULT_VALUE = "default";  
16.   
17.     public static final String DESCRIPTION_ELEMENT = "description";  
18.   
19.     public static final String AUTOWIRE_NO_VALUE = "no";  
20.   
21.     public static final String AUTOWIRE_BY_NAME_VALUE = "byName";  
22.   
23.     public static final String AUTOWIRE_BY_TYPE_VALUE = "byType";  
24.   
25.     public static final String AUTOWIRE_CONSTRUCTOR_VALUE = "constructor";  
26.   
27.     public static final String AUTOWIRE_AUTODETECT_VALUE = "autodetect";  
28.   
29.     public static final String DEPENDENCY_CHECK_ALL_ATTRIBUTE_VALUE = "all";  
30.   
31.     public static final String DEPENDENCY_CHECK_SIMPLE_ATTRIBUTE_VALUE = "simple";  
32.   
33.     public static final String DEPENDENCY_CHECK_OBJECTS_ATTRIBUTE_VALUE = "objects";  
34.   
35.     public static final String NAME_ATTRIBUTE = "name";  
36.   
37.     public static final String BEAN_ELEMENT = "bean";  
38.   
39.     public static final String META_ELEMENT = "meta";  
40.   
41.     public static final String ID_ATTRIBUTE = "id";  
42.   
43.     public static final String PARENT_ATTRIBUTE = "parent";  
44.   
45.     public static final String CLASS_ATTRIBUTE = "class";  
46.   
47.     public static final String ABSTRACT_ATTRIBUTE = "abstract";  
48.   
49.     public static final String SCOPE_ATTRIBUTE = "scope";  
50.   
51.     public static final String SINGLETON_ATTRIBUTE = "singleton";  
52.   
53.     public static final String LAZY_INIT_ATTRIBUTE = "lazy-init";  
54.   
55.     public static final String AUTOWIRE_ATTRIBUTE = "autowire";  
56.   
57.     public static final String AUTOWIRE_CANDIDATE_ATTRIBUTE = "autowire-candidate";  
58.   
59.     public static final String PRIMARY_ATTRIBUTE = "primary";  
60.   
61.     public static final String DEPENDENCY_CHECK_ATTRIBUTE = "dependency-check";  
62.   
63.     public static final String DEPENDS_ON_ATTRIBUTE = "depends-on";  
64.   
65.     public static final String INIT_METHOD_ATTRIBUTE = "init-method";  
66.   
67.     public static final String DESTROY_METHOD_ATTRIBUTE = "destroy-method";  
68.   
69.     public static final String FACTORY_METHOD_ATTRIBUTE = "factory-method";  
70.   
71.     public static final String FACTORY_BEAN_ATTRIBUTE = "factory-bean";  
72.   
73.     public static final String CONSTRUCTOR_ARG_ELEMENT = "constructor-arg";  
74.   
75.     public static final String INDEX_ATTRIBUTE = "index";  
76.   
77.     public static final String TYPE_ATTRIBUTE = "type";  
78.   
79.     public static final String VALUE_TYPE_ATTRIBUTE = "value-type";  
80.   
81.     public static final String KEY_TYPE_ATTRIBUTE = "key-type";  
82.   
83.     public static final String PROPERTY_ELEMENT = "property";  
84.   
85.     public static final String REF_ATTRIBUTE = "ref";  
86.   
87.     public static final String VALUE_ATTRIBUTE = "value";  
88.   
89.     public static final String LOOKUP_METHOD_ELEMENT = "lookup-method";  
90.   
91.     public static final String REPLACED_METHOD_ELEMENT = "replaced-method";  
92.   
93.     public static final String REPLACER_ATTRIBUTE = "replacer";  
94.   
95.     public static final String ARG_TYPE_ELEMENT = "arg-type";  
96.   
97.     public static final String ARG_TYPE_MATCH_ATTRIBUTE = "match";  
98.   
99.     public static final String REF_ELEMENT = "ref";  
100.   
101.     public static final String IDREF_ELEMENT = "idref";  
102.   
103.     public static final String BEAN_REF_ATTRIBUTE = "bean";  
104.   
105.     public static final String LOCAL_REF_ATTRIBUTE = "local";  
106.   
107.     public static final String PARENT_REF_ATTRIBUTE = "parent";  
108.   
109.     public static final String VALUE_ELEMENT = "value";  
110.   
111.     public static final String NULL_ELEMENT = "null";  
112.   
113.     public static final String ARRAY_ELEMENT = "array";  
114.   
115.     public static final String LIST_ELEMENT = "list";  
116.   
117.     public static final String SET_ELEMENT = "set";  
118.   
119.     public static final String MAP_ELEMENT = "map";  
120.   
121.     public static final String ENTRY_ELEMENT = "entry";  
122.   
123.     public static final String KEY_ELEMENT = "key";  
124.   
125.     public static final String KEY_ATTRIBUTE = "key";  
126.   
127.     public static final String KEY_REF_ATTRIBUTE = "key-ref";  
128.   
129.     public static final String VALUE_REF_ATTRIBUTE = "value-ref";  
130.   
131.     public static final String PROPS_ELEMENT = "props";  
132.   
133.     public static final String PROP_ELEMENT = "prop";  
134.   
135.     public static final String MERGE_ATTRIBUTE = "merge";  
136.   
137.     public static final String QUALIFIER_ELEMENT = "qualifier";  
138.   
139.     public static final String QUALIFIER_ATTRIBUTE_ELEMENT = "attribute";  
140.   
141.     public static final String DEFAULT_LAZY_INIT_ATTRIBUTE = "default-lazy-init";  
142.   
143.     public static final String DEFAULT_MERGE_ATTRIBUTE = "default-merge";  
144.   
145.     public static final String DEFAULT_AUTOWIRE_ATTRIBUTE = "default-autowire";  
146.   
147.     public static final String DEFAULT_DEPENDENCY_CHECK_ATTRIBUTE = "default-dependency-check";  
148.   
149.     public static final String DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE = "default-autowire-candidates";  
150.   
151.     public static final String DEFAULT_INIT_METHOD_ATTRIBUTE = "default-init-method";  
152.   
153.     public static final String DEFAULT_DESTROY_METHOD_ATTRIBUTE = "default-destroy-method";  
154.   
155.   
156.     protected final Log logger = LogFactory.getLog(getClass());  
157.   
158.     private final XmlReaderContext readerContext;  
159.   
160.     private final DocumentDefaultsDefinition defaults = new DocumentDefaultsDefinition();  
161.   
162.     private final ParseState parseState = new ParseState();  
163.   
164.     private Environment environment;  
165.   
166.     /** 
167.      *缓存所有已经解析的bean的id以及别名 
168.      */  
169.     private final Set<String> usedNames = new HashSet<String>();  
170.   
171.   
172.     /** 
173.      * 使用给定的XmlReaderContext和Environment创建一个BeanDefinitionParserDelegate实例 
174.      */  
175.     public BeanDefinitionParserDelegate(XmlReaderContext readerContext, Environment environment) {  
176.         Assert.notNull(readerContext, "XmlReaderContext must not be null");  
177.         Assert.notNull(readerContext, "Environment must not be null");  
178.         this.readerContext = readerContext;  
179.         this.environment = environment;  
180.     }  
181.   
182.       
183.     @Deprecated  
184.     public BeanDefinitionParserDelegate(XmlReaderContext readerContext) {  
185.         this(readerContext, new StandardEnvironment());  
186.     }  
187.   
188.     public final XmlReaderContext getReaderContext() {  
189.         return this.readerContext;  
190.     }  
191.   
192.       
193.     public final Environment getEnvironment() {  
194.         return this.environment;  
195.     }  
196.   
197.   
198.     protected Object extractSource(Element ele) {  
199.         return this.readerContext.extractSource(ele);  
200.     }  
201.   
202.       
203.     protected void error(String message, Node source) {  
204.         this.readerContext.error(message, source, this.parseState.snapshot());  
205.     }  
206.   
207.       
208.     protected void error(String message, Element source) {  
209.         this.readerContext.error(message, source, this.parseState.snapshot());  
210.     }  
211.   
212.       
213.     protected void error(String message, Element source, Throwable cause) {  
214.         this.readerContext.error(message, source, this.parseState.snapshot(), cause);  
215.     }  
216.   
217.   
218.     /** 
219.      *初始化默认值 
220.      */  
221.     public void initDefaults(Element root, BeanDefinitionParserDelegate parent) {  
222.         populateDefaults(this.defaults, (parent != null ? parent.defaults : null), root);  
223.         this.readerContext.fireDefaultsRegistered(this.defaults);  
224.     }  
225.   
226.     /** 
227.      * 初始化默认值 
228.      */  
229.     public void initDefaults(Element root) {  
230.         initDefaults(root, null);  
231.     }  
232.   
233.     /** 
234.      * 设置defualt数据， 
235.      */  
236.     protected void populateDefaults(DocumentDefaultsDefinition defaults, DocumentDefaultsDefinition parentDefaults, Element root) {  
237.         //从根节点即<beans>节点中获取default-lazy-init参数  
238.         String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE);  
239.         //如果lazyInit的值为default,如果parentDefaults不为null则侧其中获取lazyInit，否则设置为false  
240.         if (DEFAULT_VALUE.equals(lazyInit)) {  
241.             lazyInit = parentDefaults != null ? parentDefaults.getLazyInit() : FALSE_VALUE;  
242.         }  
243.         defaults.setLazyInit(lazyInit);  
244.         //获取default-merge属性  
245.         String merge = root.getAttribute(DEFAULT_MERGE_ATTRIBUTE);  
246.         if (DEFAULT_VALUE.equals(merge)) {  
247.             merge = parentDefaults != null ? parentDefaults.getMerge() : FALSE_VALUE;  
248.         }  
249.         defaults.setMerge(merge);  
250.         //获取default-autowire属性  
251.         String autowire = root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE);  
252.         if (DEFAULT_VALUE.equals(autowire)) {  
253.             autowire = parentDefaults != null ? parentDefaults.getAutowire() : AUTOWIRE_NO_VALUE;  
254.         }  
255.         defaults.setAutowire(autowire);  
256.   
257.         //设置defult-dependecny-check  
258.         defaults.setDependencyCheck(root.getAttribute(DEFAULT_DEPENDENCY_CHECK_ATTRIBUTE));  
259.           
260.         if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {  
261.             defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));  
262.         }  
263.         else if (parentDefaults != null) {  
264.             defaults.setAutowireCandidates(parentDefaults.getAutowireCandidates());  
265.         }  
266.   
267.         if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {  
268.             defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));  
269.         }  
270.         else if (parentDefaults != null) {  
271.             defaults.setInitMethod(parentDefaults.getInitMethod());  
272.         }  
273.   
274.         if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {  
275.             defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));  
276.         }  
277.         else if (parentDefaults != null) {  
278.             defaults.setDestroyMethod(parentDefaults.getDestroyMethod());  
279.         }  
280.   
281.         defaults.setSource(this.readerContext.extractSource(root));  
282.     }  
283.   
284.     /** 
285.      * 获取默认值 
286.      */  
287.     public DocumentDefaultsDefinition getDefaults() {  
288.         return this.defaults;  
289.     }  
290.   
291.       
292.     public BeanDefinitionDefaults getBeanDefinitionDefaults() {  
293.         BeanDefinitionDefaults bdd = new BeanDefinitionDefaults();  
294.         bdd.setLazyInit("TRUE".equalsIgnoreCase(this.defaults.getLazyInit()));  
295.         bdd.setDependencyCheck(this.getDependencyCheck(DEFAULT_VALUE));  
296.         bdd.setAutowireMode(this.getAutowireMode(DEFAULT_VALUE));  
297.         bdd.setInitMethodName(this.defaults.getInitMethod());  
298.         bdd.setDestroyMethodName(this.defaults.getDestroyMethod());  
299.         return bdd;  
300.     }  
301.   
302.       
303.     public String[] getAutowireCandidatePatterns() {  
304.         String candidatePattern = this.defaults.getAutowireCandidates();  
305.         return (candidatePattern != null ? StringUtils.commaDelimitedListToStringArray(candidatePattern) : null);  
306.     }  
307.   
308.   
309.     /** 
310.      * 解析<bean>节点，如果在解析过程中发生异常可能返回null 
311.      */  
312.     public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {  
313.         return parseBeanDefinitionElement(ele, null);  
314.     }  
315.   
316.     /** 
317.      */  
318.     public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {  
319.         //获取<bean>节点的id属性，如<bean id="man" ... />,则id=man  
320.         String id = ele.getAttribute(ID_ATTRIBUTE);  
321.         //获取name属性值  
322.         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  
323.           
324.         List<String> aliases = new ArrayList<String>();  
325.         //如果name属性值不为空，拆分多个name,并保存到list中  
326.         if (StringUtils.hasLength(nameAttr)) {  
327.             String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);  
328.             aliases.addAll(Arrays.asList(nameArr));  
329.         }  
330.         //将id赋值给beanName  
331.         String beanName = id;  
332.         //如果beanName不为空且别名的列表不为空则将别名集合中的第一个值赋值为beanName  
333.         if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {  
334.             beanName = aliases.remove(0);  
335.             if (logger.isDebugEnabled()) {  
336.                 logger.debug("No XML 'id' specified - using '" + beanName +  
337.                         "' as bean name and " + aliases + " as aliases");  
338.             }  
339.         }  
340.         //beanName的唯一性检查,beanName和别名都不能和已有的bean id或别名重复  
341.         if (containingBean == null) {  
342.             checkNameUniqueness(beanName, aliases, ele);  
343.         }  
344.         // 如果当前bean 的id和别名都没有重复值则解析bean节点  
345.         AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);  
346.         if (beanDefinition != null) {  
347.             if (!StringUtils.hasText(beanName)) {  
348.                 try {  
349.                     if (containingBean != null) {  
350.                         beanName = BeanDefinitionReaderUtils.generateBeanName(  
351.                                 beanDefinition, this.readerContext.getRegistry(), true);  
352.                     }  
353.                     else {  
354.                         beanName = this.readerContext.generateBeanName(beanDefinition);  
355.                         // Register an alias for the plain bean class name, if still possible,  
356.                         // if the generator returned the class name plus a suffix.  
357.                         // This is expected for Spring 1.2/2.0 backwards compatibility.  
358.                         String beanClassName = beanDefinition.getBeanClassName();  
359.                         if (beanClassName != null &&  
360.                                 beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&  
361.                                 !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {  
362.                             aliases.add(beanClassName);  
363.                         }  
364.                     }  
365.                     if (logger.isDebugEnabled()) {  
366.                         logger.debug("Neither XML 'id' nor 'name' specified - " +  
367.                                 "using generated bean name [" + beanName + "]");  
368.                     }  
369.                 }  
370.                 catch (Exception ex) {  
371.                     error(ex.getMessage(), ele);  
372.                     return null;  
373.                 }  
374.             }  
375.             String[] aliasesArray = StringUtils.toStringArray(aliases);  
376.             return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);  
377.         }  
378.   
379.         return null;  
380.     }  
381.   
382.     /** 
383.      * 校验制定的bean的名称和别名在当前级别的beans嵌套内没有使用过 
384.      */  
385.     protected void checkNameUniqueness(String beanName, List<String> aliases, Element beanElement) {  
386.         //定义一个找到的beanName,初始化值为null  
387.         String foundName = null;  
388.         //beanName不为空且userNames中包含这个beanName则将beanName赋值为foundName  
389.         if (StringUtils.hasText(beanName) && this.usedNames.contains(beanName)) {  
390.             foundName = beanName;  
391.         }  
392.         //如果foundName不为null,则判断usedNames中是否包含别名，将包含的第一个别名赋值给foundName  
393.         if (foundName == null) {  
394.             foundName = (String) CollectionUtils.findFirstMatch(this.usedNames, aliases);  
395.         }  
396.         //如果foundName不为null则进行错误处理  
397.         if (foundName != null) {  
398.             error("Bean name '" + foundName + "' is already used in this <beans> element", beanElement);  
399.         }  
400.         //向usedNames中添加beanName  
401.         this.usedNames.add(beanName);  
402.         //将aliases添加到usedNames  
403.         this.usedNames.addAll(aliases);  
404.     }  
405.   
406.     /** 
407.      * 解析Bean 
408.      */  
409.     public AbstractBeanDefinition parseBeanDefinitionElement(  
410.             Element ele, String beanName, BeanDefinition containingBean) {  
411.         //使用beanName创建一个BeanEntriy对象并放入parseState中  
412.         this.parseState.push(new BeanEntry(beanName));  
413.           
414.         String className = null;  
415.         //如果bean节点中含有class属性，则将该获取该属性值  
416.         if (ele.hasAttribute(CLASS_ATTRIBUTE)) {  
417.             className = ele.getAttribute(CLASS_ATTRIBUTE).trim();  
418.         }  
419.   
420.         try {  
421.          // 如果bean节点含有parent属性则获取该属性  
422.             String parent = null;  
423.             if (ele.hasAttribute(PARENT_ATTRIBUTE)) {  
424.                 parent = ele.getAttribute(PARENT_ATTRIBUTE);  
425.             }  
426.             //使用className和parent创建一个beanDefinition  
427.             AbstractBeanDefinition bd = createBeanDefinition(className, parent);  
428.   
429.             parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);  
430.             //设置description  
431.             bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));  
432.   
433.             parseMetaElements(ele, bd);  
434.             //解析lookup-method元素  
435.             parseLookupOverrideSubElements(ele, bd.getMethodOverrides());  
436.             //解析 replace-method元素  
437.             parseReplacedMethodSubElements(ele, bd.getMethodOverrides());  
438.             //解析构造参数元素  
439.             parseConstructorArgElements(ele, bd);  
440.             //解析属性  
441.             parsePropertyElements(ele, bd);  
442.               
443.             parseQualifierElements(ele, bd);  
444.   
445.             bd.setResource(this.readerContext.getResource());  
446.               
447.             bd.setSource(extractSource(ele));  
448.   
449.             return bd;  
450.         }  
451.         catch (ClassNotFoundException ex) {  
452.             error("Bean class [" + className + "] not found", ele, ex);  
453.         }  
454.         catch (NoClassDefFoundError err) {  
455.             error("Class that bean class [" + className + "] depends on not found", ele, err);  
456.         }  
457.         catch (Throwable ex) {  
458.             error("Unexpected failure during bean definition parsing", ele, ex);  
459.         }  
460.         finally {  
461.             this.parseState.pop();  
462.         }  
463.   
464.         return null;  
465.     }  
466.   
467.     /** 
468.      * 解析给定的节点的属性值 
469.      *  
470.      */  
471.     public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,  
472.             BeanDefinition containingBean, AbstractBeanDefinition bd) {  
473.         //如果bean节点含有scope属性则设置BeanDefinition的scope属性  
474.         if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {  
475.             bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));  
476.                 //如果设置了scope属性同时设置了singleton，则进行错误处理！不允许同时设置scope和singleton  
477.             if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {  
478.                 error("Specify either 'scope' or 'singleton', not both", ele);  
479.             }  
480.         }  
481.         else if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {  
482.             //如果bean节点中包含singletone属性且值为true，则设置scope属性为singleton否则设置为prototype  
483.             bd.setScope(TRUE_VALUE.equals(ele.getAttribute(SINGLETON_ATTRIBUTE)) ?  
484.                     BeanDefinition.SCOPE_SINGLETON : BeanDefinition.SCOPE_PROTOTYPE);  
485.         }  
486.         else if (containingBean != null) {  
487.             // 如果含有内部bean则作用域以内部bean为准.  
488.             bd.setScope(containingBean.getScope());  
489.         }  
490.         //如果bean节点包含abstract值且值为true则设置beanDefinition的值为true否则设置为false  
491.         if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {  
492.             bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));  
493.         }  
494.         //获取lazy-init属性  
495.         String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);  
496.         //如果lazyInit的值等于default则使用beans根节点中设置的default-lazy-init值  
497.         if (DEFAULT_VALUE.equals(lazyInit)) {  
498.             lazyInit = this.defaults.getLazyInit();  
499.         }  
500.         bd.setLazyInit(TRUE_VALUE.equals(lazyInit));  
501.         //获取bean节点autowire属性值  
502.         String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);  
503.         //设置beanDefinition的AutowireMode  
504.         bd.setAutowireMode(getAutowireMode(autowire));  
505.         //获取dependency-check属性  
506.         String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);  
507.         bd.setDependencyCheck(getDependencyCheck(dependencyCheck));  
508.         //如果bean节点中包含depends-on属性值  
509.         if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {  
510.           //获取depends-on节点值  
511.             String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);  
512.             //设置beandefinition的dependsOn属性  
513.             bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));  
514.         }  
515.         //获取autowire-candidate属性值  
516.         String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);  
517.         //如果autowireCandidate的值是空获取是default  
518.         if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {  
519.             //获取beans节点中设置的default-autowire-candidates属性值  
520.             String candidatePattern = this.defaults.getAutowireCandidates();  
521.             //如果candidatePattern不为null  
522.             if (candidatePattern != null) {  
523.                 //将candidatePattern使用,分割为字符串数组  
524.                 String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);  
525.                 //如果正则匹配beanName则设置为true否则设置为false  
526.                 bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));  
527.             }  
528.         }  
529.         else {  
530.             //如果没有设置autowire-candidate或者值不是false，如果其值是true则设置为true否则设置为false  
531.             bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));  
532.         }  
533.         // 如果bean节点包含primary属性，则设置beanDefinition的primary属性  
534.         if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {  
535.             bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));  
536.         }  
537.         //如果bean节点中包含init-method属性  
538.         if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {  
539.             //获取init-method属性值  
540.             String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);  
541.             //如果initMethodName不是空字符串则设置initMethodName  
542.             if (!"".equals(initMethodName)) {  
543.                 bd.setInitMethodName(initMethodName);  
544.             }  
545.         }  
546.         else {  
547.             //如果bean节点没有设置init-method，但是beans节点中设置了default-init-method  
548.             if (this.defaults.getInitMethod() != null) {  
549.                 bd.setInitMethodName(this.defaults.getInitMethod());  
550.                 bd.setEnforceInitMethod(false);  
551.             }  
552.         }  
553.         //如果bean节点中包含destory-method或者beans节点中设置了defult-destory-method属性则设置beanDefinition的destroyMethod  
554.         if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {  
555.             String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);  
556.             if (!"".equals(destroyMethodName)) {  
557.                 bd.setDestroyMethodName(destroyMethodName);  
558.             }  
559.         }  
560.         else {  
561.             if (this.defaults.getDestroyMethod() != null) {  
562.                 bd.setDestroyMethodName(this.defaults.getDestroyMethod());  
563.                 bd.setEnforceDestroyMethod(false);  
564.             }  
565.         }  
566.         //如果bean节点中包含了factory-method，则设置beanDefinition的factoryMethod  
567.         if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {  
568.             bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));  
569.         }  
570.         //如果bean节点设置了factory-bean则设置beanDefinition的factoryBean  
571.         if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {  
572.             bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));  
573.         }  
574.   
575.         return bd;  
576.     }  
577.   
578.     /** 
579.      * 使用给定的类名称和父类名称创建一个BeanDifinition 
580.      */  
581.     protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)  
582.             throws ClassNotFoundException {  
583.   
584.         return BeanDefinitionReaderUtils.createBeanDefinition(  
585.                 parentName, className, this.readerContext.getBeanClassLoader());  
586.     }  
587.     //解析Bean的元节点  
588.     public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {  
589.         //获取bean所有子节点  
590.         NodeList nl = ele.getChildNodes();  
591.         //遍历所有元节点  
592.         for (int i = 0; i < nl.getLength(); i++) {  
593.             Node node = nl.item(i);  
594.             /  
595.             if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {  
596.             // 强制类型转换  
597.                 Element metaElement = (Element) node;  
598.                 //获取key  
599.                 String key = metaElement.getAttribute(KEY_ATTRIBUTE);  
600.                 //获取value  
601.                 String value = metaElement.getAttribute(VALUE_ATTRIBUTE);  
602.                 //使用key,value构成一个元属性  
603.                 BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);  
604.                 attribute.setSource(extractSource(metaElement));  
605.                 attributeAccessor.addMetadataAttribute(attribute);  
606.             }  
607.         }  
608.     }  
609.   
610.     public int getAutowireMode(String attValue) {  
611.         String att = attValue;  
612.         if (DEFAULT_VALUE.equals(att)) {  
613.             att = this.defaults.getAutowire();  
614.         }  
615.         int autowire = AbstractBeanDefinition.AUTOWIRE_NO;  
616.         if (AUTOWIRE_BY_NAME_VALUE.equals(att)) {  
617.             autowire = AbstractBeanDefinition.AUTOWIRE_BY_NAME;  
618.         }  
619.         else if (AUTOWIRE_BY_TYPE_VALUE.equals(att)) {  
620.             autowire = AbstractBeanDefinition.AUTOWIRE_BY_TYPE;  
621.         }  
622.         else if (AUTOWIRE_CONSTRUCTOR_VALUE.equals(att)) {  
623.             autowire = AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR;  
624.         }  
625.         else if (AUTOWIRE_AUTODETECT_VALUE.equals(att)) {  
626.             autowire = AbstractBeanDefinition.AUTOWIRE_AUTODETECT;  
627.         }  
628.         // Else leave default value.  
629.         return autowire;  
630.     }  
631.   
632.     public int getDependencyCheck(String attValue) {  
633.         String att = attValue;  
634.         if (DEFAULT_VALUE.equals(att)) {  
635.             att = this.defaults.getDependencyCheck();  
636.         }  
637.         if (DEPENDENCY_CHECK_ALL_ATTRIBUTE_VALUE.equals(att)) {  
638.             return AbstractBeanDefinition.DEPENDENCY_CHECK_ALL;  
639.         }  
640.         else if (DEPENDENCY_CHECK_OBJECTS_ATTRIBUTE_VALUE.equals(att)) {  
641.             return AbstractBeanDefinition.DEPENDENCY_CHECK_OBJECTS;  
642.         }  
643.         else if (DEPENDENCY_CHECK_SIMPLE_ATTRIBUTE_VALUE.equals(att)) {  
644.             return AbstractBeanDefinition.DEPENDENCY_CHECK_SIMPLE;  
645.         }  
646.         else {  
647.             return AbstractBeanDefinition.DEPENDENCY_CHECK_NONE;  
648.         }  
649.     }  
650.   
651.     /** 
652.      * 解析构造参数元素 
653.      */  
654.     public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {  
655.         NodeList nl = beanEle.getChildNodes();  
656.         for (int i = 0; i < nl.getLength(); i++) {  
657.             Node node = nl.item(i);  
658.             if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {  
659.                 parseConstructorArgElement((Element) node, bd);  
660.             }  
661.         }  
662.     }  
663.   
664.     /** 
665.      * 解析给定bean节点的属性元素 
666.      */  
667.     public void parsePropertyElements(Element beanEle, BeanDefinition bd) {  
668.         NodeList nl = beanEle.getChildNodes();  
669.         for (int i = 0; i < nl.getLength(); i++) {  
670.             Node node = nl.item(i);  
671.             if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {  
672.                 parsePropertyElement((Element) node, bd);  
673.             }  
674.         }  
675.     }  
676.   
677.     /** 
678.      * 解析给定元素的 qualifier 子节点 
679.      */  
680.     public void parseQualifierElements(Element beanEle, AbstractBeanDefinition bd) {  
681.         NodeList nl = beanEle.getChildNodes();  
682.         for (int i = 0; i < nl.getLength(); i++) {  
683.             Node node = nl.item(i);  
684.             if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ELEMENT)) {  
685.                 parseQualifierElement((Element) node, bd);  
686.             }  
687.         }  
688.     }  
689.   
690.     /** 
691.      *解析给定节点的lookup-method子节点 
692.      */  
693.     public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {  
694.         //获取bean节点的所有子节点  
695.         NodeList nl = beanEle.getChildNodes();  
696.         for (int i = 0; i < nl.getLength(); i++) {  
697.             Node node = nl.item(i);  
698.             //如果节点是lookup-method  
699.             if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {  
700.                 Element ele = (Element) node;  
701.                 String methodName = ele.getAttribute(NAME_ATTRIBUTE);  
702.                 String beanRef = ele.getAttribute(BEAN_ELEMENT);  
703.                 LookupOverride override = new LookupOverride(methodName, beanRef);  
704.                 override.setSource(extractSource(ele));  
705.                 overrides.addOverride(override);  
706.             }  
707.         }  
708.     }  
709.   
710.     /** 
711.      * 
712.      */  
713.     public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {  
714.         NodeList nl = beanEle.getChildNodes();  
715.         for (int i = 0; i < nl.getLength(); i++) {  
716.             Node node = nl.item(i);  
717.             if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {  
718.                 Element replacedMethodEle = (Element) node;  
719.                 String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);  
720.                 String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);  
721.                 ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);  
722.                 // Look for arg-type match elements.  
723.                 List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);  
724.                 for (Element argTypeEle : argTypeEles) {  
725.                     String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);  
726.                     match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));  
727.                     if (StringUtils.hasText(match)) {  
728.                         replaceOverride.addTypeIdentifier(match);  
729.                     }                     
730.                 }  
731.                 replaceOverride.setSource(extractSource(replacedMethodEle));  
732.                 overrides.addOverride(replaceOverride);  
733.             }  
734.         }  
735.     }  
736.   
737.     /** 
738.      *  
739.      */  
740.     public void parseConstructorArgElement(Element ele, BeanDefinition bd) {  
741.         String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);  
742.         String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);  
743.         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  
744.         if (StringUtils.hasLength(indexAttr)) {  
745.             try {  
746.                 int index = Integer.parseInt(indexAttr);  
747.                 if (index < 0) {  
748.                     error("'index' cannot be lower than 0", ele);  
749.                 }  
750.                 else {  
751.                     try {  
752.                         this.parseState.push(new ConstructorArgumentEntry(index));  
753.                         Object value = parsePropertyValue(ele, bd, null);  
754.                         ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);  
755.                         if (StringUtils.hasLength(typeAttr)) {  
756.                             valueHolder.setType(typeAttr);  
757.                         }  
758.                         if (StringUtils.hasLength(nameAttr)) {  
759.                             valueHolder.setName(nameAttr);  
760.                         }  
761.                         valueHolder.setSource(extractSource(ele));  
762.                         if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {  
763.                             error("Ambiguous constructor-arg entries for index " + index, ele);  
764.                         }  
765.                         else {  
766.                             bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);  
767.                         }  
768.                     }  
769.                     finally {  
770.                         this.parseState.pop();  
771.                     }  
772.                 }  
773.             }  
774.             catch (NumberFormatException ex) {  
775.                 error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);  
776.             }  
777.         }  
778.         else {  
779.             try {  
780.                 this.parseState.push(new ConstructorArgumentEntry());  
781.                 Object value = parsePropertyValue(ele, bd, null);  
782.                 ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);  
783.                 if (StringUtils.hasLength(typeAttr)) {  
784.                     valueHolder.setType(typeAttr);  
785.                 }  
786.                 if (StringUtils.hasLength(nameAttr)) {  
787.                     valueHolder.setName(nameAttr);  
788.                 }  
789.                 valueHolder.setSource(extractSource(ele));  
790.                 bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);  
791.             }  
792.             finally {  
793.                 this.parseState.pop();  
794.             }  
795.         }  
796.     }  
797.   
798.     /** 
799.      *  
800.      */  
801.     public void parsePropertyElement(Element ele, BeanDefinition bd) {  
802.         String propertyName = ele.getAttribute(NAME_ATTRIBUTE);  
803.         if (!StringUtils.hasLength(propertyName)) {  
804.             error("Tag 'property' must have a 'name' attribute", ele);  
805.             return;  
806.         }  
807.         this.parseState.push(new PropertyEntry(propertyName));  
808.         try {  
809.             if (bd.getPropertyValues().contains(propertyName)) {  
810.                 error("Multiple 'property' definitions for property '" + propertyName + "'", ele);  
811.                 return;  
812.             }  
813.             Object val = parsePropertyValue(ele, bd, propertyName);  
814.             PropertyValue pv = new PropertyValue(propertyName, val);  
815.             parseMetaElements(ele, pv);  
816.             pv.setSource(extractSource(ele));  
817.             bd.getPropertyValues().addPropertyValue(pv);  
818.         }  
819.         finally {  
820.             this.parseState.pop();  
821.         }  
822.     }  
823.   
824.     /** 
825.      *  
826.      */  
827.     public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {  
828.         String typeName = ele.getAttribute(TYPE_ATTRIBUTE);  
829.         if (!StringUtils.hasLength(typeName)) {  
830.             error("Tag 'qualifier' must have a 'type' attribute", ele);  
831.             return;  
832.         }  
833.         this.parseState.push(new QualifierEntry(typeName));  
834.         try {  
835.             AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);  
836.             qualifier.setSource(extractSource(ele));  
837.             String value = ele.getAttribute(VALUE_ATTRIBUTE);  
838.             if (StringUtils.hasLength(value)) {  
839.                 qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);  
840.             }  
841.             NodeList nl = ele.getChildNodes();  
842.             for (int i = 0; i < nl.getLength(); i++) {  
843.                 Node node = nl.item(i);  
844.                 if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ATTRIBUTE_ELEMENT)) {  
845.                     Element attributeEle = (Element) node;  
846.                     String attributeName = attributeEle.getAttribute(KEY_ATTRIBUTE);  
847.                     String attributeValue = attributeEle.getAttribute(VALUE_ATTRIBUTE);  
848.                     if (StringUtils.hasLength(attributeName) && StringUtils.hasLength(attributeValue)) {  
849.                         BeanMetadataAttribute attribute = new BeanMetadataAttribute(attributeName, attributeValue);  
850.                         attribute.setSource(extractSource(attributeEle));  
851.                         qualifier.addMetadataAttribute(attribute);  
852.                     }  
853.                     else {  
854.                         error("Qualifier 'attribute' tag must have a 'name' and 'value'", attributeEle);  
855.                         return;  
856.                     }  
857.                 }  
858.             }  
859.             bd.addQualifier(qualifier);  
860.         }  
861.         finally {  
862.             this.parseState.pop();  
863.         }  
864.     }  
865.   
866.     /** 
867.      * 获取指定属性的值 
868.      */  
869.     public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {  
870.         String elementName = (propertyName != null) ?  
871.                         "<property> element for property '" + propertyName + "'" :  
872.                         "<constructor-arg> element";  
873.   
874.         // Should only have one child element: ref, value, list, etc.  
875.         NodeList nl = ele.getChildNodes();  
876.         Element subElement = null;  
877.         for (int i = 0; i < nl.getLength(); i++) {  
878.             Node node = nl.item(i);  
879.             if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&  
880.                     !nodeNameEquals(node, META_ELEMENT)) {  
881.                 // Child element is what we're looking for.  
882.                 if (subElement != null) {  
883.                     error(elementName + " must not contain more than one sub-element", ele);  
884.                 }  
885.                 else {  
886.                     subElement = (Element) node;  
887.                 }  
888.             }  
889.         }  
890.   
891.         boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);  
892.         boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);  
893.         if ((hasRefAttribute && hasValueAttribute) ||  
894.                 ((hasRefAttribute || hasValueAttribute) && subElement != null)) {  
895.             error(elementName +  
896.                     " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);  
897.         }  
898.   
899.         if (hasRefAttribute) {  
900.             String refName = ele.getAttribute(REF_ATTRIBUTE);  
901.             if (!StringUtils.hasText(refName)) {  
902.                 error(elementName + " contains empty 'ref' attribute", ele);  
903.             }  
904.             RuntimeBeanReference ref = new RuntimeBeanReference(refName);  
905.             ref.setSource(extractSource(ele));  
906.             return ref;  
907.         }  
908.         else if (hasValueAttribute) {  
909.             TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));  
910.             valueHolder.setSource(extractSource(ele));  
911.             return valueHolder;  
912.         }  
913.         else if (subElement != null) {  
914.             return parsePropertySubElement(subElement, bd);  
915.         }  
916.         else {  
917.             // Neither child element nor "ref" or "value" attribute found.  
918.             error(elementName + " must specify a ref or value", ele);  
919.             return null;  
920.         }  
921.     }  
922.   
923.     public Object parsePropertySubElement(Element ele, BeanDefinition bd) {  
924.         return parsePropertySubElement(ele, bd, null);  
925.     }  
926.   
927.     /** 
928.      *解析一个属性的子节点 
929.      */  
930.     public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {  
931.         //如果子节点的命名空间是默认命名空间的  
932.         if (!isDefaultNamespace(ele)) {  
933.             return parseNestedCustomElement(ele, bd);  
934.         }  
935.         else if (nodeNameEquals(ele, BEAN_ELEMENT)) {  
936.         //如果子节点是bean则解析该bean配置  
937.             BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);  
938.             if (nestedBd != null) {  
939.                 nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);  
940.             }  
941.             //返回嵌套bean  
942.             return nestedBd;  
943.         }  
944.         else if (nodeNameEquals(ele, REF_ELEMENT)) {  
945.             //如果子节是ref,获取引用bean 名称  
946.             String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);  
947.             boolean toParent = false;  
948.             //如果引用bean名称为空  
949.             if (!StringUtils.hasLength(refName)) {  
950.                 //获取local值  
951.                 refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);  
952.                 //如果local值为空  
953.                 if (!StringUtils.hasLength(refName)) {  
954.                     // 获取parent值  
955.                     refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);  
956.                     toParent = true;  
957.                     //如果parent值也为空则进行错误处理  
958.                     if (!StringUtils.hasLength(refName)) {  
959.                         error("'bean', 'local' or 'parent' is required for <ref> element", ele);  
960.                         return null;  
961.                     }  
962.                 }  
963.             }  
964.             // 如果refName中不包含文字则进行错误处理  
965.             if (!StringUtils.hasText(refName)) {  
966.                 error("<ref> element contains empty target attribute", ele);  
967.                 return null;  
968.             }  
969.             //创建一个RuntimeBeanReference对象  
970.             RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);  
971.             ref.setSource(extractSource(ele));  
972.             return ref;  
973.         }  
974.         else if (nodeNameEquals(ele, IDREF_ELEMENT)) {  
975.             //如果节点是idref  
976.             return parseIdRefElement(ele);  
977.         }  
978.         else if (nodeNameEquals(ele, VALUE_ELEMENT)) {  
979.            // 如果节点是value  
980.             return parseValueElement(ele, defaultValueType);  
981.         }  
982.         else if (nodeNameEquals(ele, NULL_ELEMENT)) {  
983.             //如果节点是null  
984.             TypedStringValue nullHolder = new TypedStringValue(null);  
985.             nullHolder.setSource(extractSource(ele));  
986.             return nullHolder;  
987.         }  
988.         else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {  
989.           //如果节点是array  
990.             return parseArrayElement(ele, bd);  
991.         }  
992.         else if (nodeNameEquals(ele, LIST_ELEMENT)) {  
993.             //如果节点是list  
994.             return parseListElement(ele, bd);  
995.         }  
996.         else if (nodeNameEquals(ele, SET_ELEMENT)) {  
997.             //如果节点是set  
998.             return parseSetElement(ele, bd);  
999.         }  
1000.         else if (nodeNameEquals(ele, MAP_ELEMENT)) {  
1001.             //如果节点是map  
1002.             return parseMapElement(ele, bd);  
1003.         }  
1004.         else if (nodeNameEquals(ele, PROPS_ELEMENT)) {  
1005.         //如果节点是props  
1006.             return parsePropsElement(ele);  
1007.         }  
1008.         else {  
1009.             error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);  
1010.             return null;  
1011.         }  
1012.     }  
1013.   
1014.     /** 
1015.      *  
1016.      */  
1017.     public Object parseIdRefElement(Element ele) {  
1018.         // A generic reference to any name of any bean.  
1019.         String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);  
1020.         if (!StringUtils.hasLength(refName)) {  
1021.             // A reference to the id of another bean in the same XML file.  
1022.             refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);  
1023.             if (!StringUtils.hasLength(refName)) {  
1024.                 error("Either 'bean' or 'local' is required for <idref> element", ele);  
1025.                 return null;  
1026.             }  
1027.         }  
1028.         if (!StringUtils.hasText(refName)) {  
1029.             error("<idref> element contains empty target attribute", ele);  
1030.             return null;  
1031.         }  
1032.         RuntimeBeanNameReference ref = new RuntimeBeanNameReference(refName);  
1033.         ref.setSource(extractSource(ele));  
1034.         return ref;  
1035.     }  
1036.   
1037.     /** 
1038.      * Return a typed String value Object for the given value element. 
1039.      */  
1040.     public Object parseValueElement(Element ele, String defaultTypeName) {  
1041.         // It's a literal value.  
1042.         String value = DomUtils.getTextValue(ele);  
1043.         String specifiedTypeName = ele.getAttribute(TYPE_ATTRIBUTE);  
1044.         String typeName = specifiedTypeName;  
1045.         if (!StringUtils.hasText(typeName)) {  
1046.             typeName = defaultTypeName;  
1047.         }  
1048.         try {  
1049.             TypedStringValue typedValue = buildTypedStringValue(value, typeName);  
1050.             typedValue.setSource(extractSource(ele));  
1051.             typedValue.setSpecifiedTypeName(specifiedTypeName);  
1052.             return typedValue;  
1053.         }  
1054.         catch (ClassNotFoundException ex) {  
1055.             error("Type class [" + typeName + "] not found for <value> element", ele, ex);  
1056.             return value;  
1057.         }  
1058.     }  
1059.   
1060.     /** 
1061.      * 根据给定的值，已经类型创建一个TypedStringValue 
1062.      */  
1063.     protected TypedStringValue buildTypedStringValue(String value, String targetTypeName)  
1064.             throws ClassNotFoundException {  
1065.   
1066.         ClassLoader classLoader = this.readerContext.getBeanClassLoader();  
1067.         TypedStringValue typedValue;  
1068.         if (!StringUtils.hasText(targetTypeName)) {  
1069.             typedValue = new TypedStringValue(value);  
1070.         }  
1071.         else if (classLoader != null) {  
1072.             Class<?> targetType = ClassUtils.forName(targetTypeName, classLoader);  
1073.             typedValue = new TypedStringValue(value, targetType);  
1074.         }  
1075.         else {  
1076.             typedValue = new TypedStringValue(value, targetTypeName);  
1077.         }  
1078.         return typedValue;  
1079.     }  
1080.   
1081.     /** 
1082.      * 解析array节点 
1083.      */  
1084.     public Object parseArrayElement(Element arrayEle, BeanDefinition bd) {  
1085.         //获取value-type  
1086.         String elementType = arrayEle.getAttribute(VALUE_TYPE_ATTRIBUTE);  
1087.         //获取子节点  
1088.         NodeList nl = arrayEle.getChildNodes();  
1089.         //根据value-type和子节点长度创建一个ManagedArray  
1090.         ManagedArray target = new ManagedArray(elementType, nl.getLength());  
1091.         target.setSource(extractSource(arrayEle));  
1092.         target.setElementTypeName(elementType);  
1093.         target.setMergeEnabled(parseMergeAttribute(arrayEle));  
1094.         parseCollectionElements(nl, target, bd, elementType);  
1095.         return target;  
1096.     }  
1097.   
1098.     /** 
1099.      * Parse a list element. 
1100.      */  
1101.     public List parseListElement(Element collectionEle, BeanDefinition bd) {  
1102.         String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);  
1103.         NodeList nl = collectionEle.getChildNodes();  
1104.         ManagedList<Object> target = new ManagedList<Object>(nl.getLength());  
1105.         target.setSource(extractSource(collectionEle));  
1106.         target.setElementTypeName(defaultElementType);  
1107.         target.setMergeEnabled(parseMergeAttribute(collectionEle));  
1108.         parseCollectionElements(nl, target, bd, defaultElementType);  
1109.         return target;  
1110.     }  
1111.   
1112.     /** 
1113.      * Parse a set element. 
1114.      */  
1115.     public Set parseSetElement(Element collectionEle, BeanDefinition bd) {  
1116.         String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);  
1117.         NodeList nl = collectionEle.getChildNodes();  
1118.         ManagedSet<Object> target = new ManagedSet<Object>(nl.getLength());  
1119.         target.setSource(extractSource(collectionEle));  
1120.         target.setElementTypeName(defaultElementType);  
1121.         target.setMergeEnabled(parseMergeAttribute(collectionEle));  
1122.         parseCollectionElements(nl, target, bd, defaultElementType);  
1123.         return target;  
1124.     }  
1125.   
1126.     protected void parseCollectionElements(  
1127.             NodeList elementNodes, Collection<Object> target, BeanDefinition bd, String defaultElementType) {  
1128.         //遍历子节点  
1129.         for (int i = 0; i < elementNodes.getLength(); i++) {  
1130.             Node node = elementNodes.item(i);  
1131.             //如果节点是element且不是description则将其添加到target中  
1132.             if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {  
1133.                 target.add(parsePropertySubElement((Element) node, bd, defaultElementType));  
1134.             }  
1135.         }  
1136.     }  
1137.   
1138.     /** 
1139.      * 解析map节点 
1140.      */  
1141.     public Map parseMapElement(Element mapEle, BeanDefinition bd) {  
1142.         //获取key-type  
1143.         String defaultKeyType = mapEle.getAttribute(KEY_TYPE_ATTRIBUTE);  
1144.         //获取value-type  
1145.         String defaultValueType = mapEle.getAttribute(VALUE_TYPE_ATTRIBUTE);  
1146.         //获取map节点的所有entry子节点  
1147.         List<Element> entryEles = DomUtils.getChildElementsByTagName(mapEle, ENTRY_ELEMENT);  
1148.         //根据entry子节点的数量创建一个ManagedMap  
1149.         ManagedMap<Object, Object> map = new ManagedMap<Object, Object>(entryEles.size());  
1150.         map.setSource(extractSource(mapEle));  
1151.         //设置KeyType  
1152.         map.setKeyTypeName(defaultKeyType);  
1153.         //设置valueType  
1154.         map.setValueTypeName(defaultValueType);  
1155.         map.setMergeEnabled(parseMergeAttribute(mapEle));  
1156.          //遍历Entry  
1157.         for (Element entryEle : entryEles) {  
1158.              //获取entry的子节点  
1159.             NodeList entrySubNodes = entryEle.getChildNodes();  
1160.             Element keyEle = null;  
1161.             Element valueEle = null;  
1162.                 //遍历entry子节点  
1163.             for (int j = 0; j < entrySubNodes.getLength(); j++) {  
1164.                 Node node = entrySubNodes.item(j);  
1165.                 if (node instanceof Element) {  
1166.                     Element candidateEle = (Element) node;  
1167.                     if (nodeNameEquals(candidateEle, KEY_ELEMENT)) {  
1168.                         if (keyEle != null) {  
1169.                             error("<entry> element is only allowed to contain one <key> sub-element", entryEle);  
1170.                         }  
1171.                         else {  
1172.                             keyEle = candidateEle;  
1173.                         }  
1174.                     }  
1175.                     else {  
1176.                         // Child element is what we're looking for.  
1177.                         if (nodeNameEquals(candidateEle, DESCRIPTION_ELEMENT)) {  
1178.                             // the element is a <description> -> ignore it  
1179.                         }  
1180.                         else if (valueEle != null) {  
1181.                             error("<entry> element must not contain more than one value sub-element", entryEle);  
1182.                         }  
1183.                         else {  
1184.                             valueEle = candidateEle;  
1185.                         }  
1186.                     }  
1187.                 }  
1188.             }  
1189.   
1190.               
1191.             Object key = null;  
1192.             //entry节点是否包含key属性  
1193.             boolean hasKeyAttribute = entryEle.hasAttribute(KEY_ATTRIBUTE);  
1194.             //entry节点是否包含key-ref属性  
1195.             boolean hasKeyRefAttribute = entryEle.hasAttribute(KEY_REF_ATTRIBUTE);  
1196.             //key,key-ref，或者key的子节点不能同时配置，    
1197.             if ((hasKeyAttribute && hasKeyRefAttribute) ||  
1198.                     ((hasKeyAttribute || hasKeyRefAttribute)) && keyEle != null) {  
1199.                 error("<entry> element is only allowed to contain either " +  
1200.                         "a 'key' attribute OR a 'key-ref' attribute OR a <key> sub-element", entryEle);  
1201.             }  
1202.               
1203.             if (hasKeyAttribute) {  
1204.             //如果含有key属性则更具key属性值创建一个TypedStringValue  
1205.                 key = buildTypedStringValueForMap(entryEle.getAttribute(KEY_ATTRIBUTE), defaultKeyType, entryEle);  
1206.             }  
1207.             else if (hasKeyRefAttribute) {  
1208.                 //如果含有key-ref且值不为空则创建一个RuntimeBaseReference  
1209.                 String refName = entryEle.getAttribute(KEY_REF_ATTRIBUTE);  
1210.                 if (!StringUtils.hasText(refName)) {  
1211.                     error("<entry> element contains empty 'key-ref' attribute", entryEle);  
1212.                 }  
1213.                 RuntimeBeanReference ref = new RuntimeBeanReference(refName);  
1214.                 ref.setSource(extractSource(entryEle));  
1215.                 key = ref;  
1216.             }  
1217.             else if (keyEle != null) {  
1218.                 key = parseKeyElement(keyEle, bd, defaultKeyType);  
1219.             }  
1220.             else {  
1221.                 error("<entry> element must specify a key", entryEle);  
1222.             }  
1223.   
1224.               
1225.             Object value = null;  
1226.             boolean hasValueAttribute = entryEle.hasAttribute(VALUE_ATTRIBUTE);  
1227.             boolean hasValueRefAttribute = entryEle.hasAttribute(VALUE_REF_ATTRIBUTE);  
1228.             if ((hasValueAttribute && hasValueRefAttribute) ||  
1229.                     ((hasValueAttribute || hasValueRefAttribute)) && valueEle != null) {  
1230.                 error("<entry> element is only allowed to contain either " +  
1231.                         "'value' attribute OR 'value-ref' attribute OR <value> sub-element", entryEle);  
1232.             }  
1233.             if (hasValueAttribute) {  
1234.                 //如果有value属性则根据value属性的值创建一个TypeStringValue  
1235.                 value = buildTypedStringValueForMap(entryEle.getAttribute(VALUE_ATTRIBUTE), defaultValueType, entryEle);  
1236.             }  
1237.             else if (hasValueRefAttribute) {  
1238.                 String refName = entryEle.getAttribute(VALUE_REF_ATTRIBUTE);  
1239.                 if (!StringUtils.hasText(refName)) {  
1240.                     error("<entry> element contains empty 'value-ref' attribute", entryEle);  
1241.                 }  
1242.                 RuntimeBeanReference ref = new RuntimeBeanReference(refName);  
1243.                 ref.setSource(extractSource(entryEle));  
1244.                 value = ref;  
1245.             }  
1246.             else if (valueEle != null) {  
1247.                 value = parsePropertySubElement(valueEle, bd, defaultValueType);  
1248.             }  
1249.             else {  
1250.                 error("<entry> element must specify a value", entryEle);  
1251.             }  
1252.   
1253.             //向Map中添加数据  
1254.             map.put(key, value);  
1255.         }  
1256.   
1257.         return map;  
1258.     }  
1259.   
1260.     /** 
1261.      *创建一个TypedStringValue 
1262.      */  
1263.     protected final Object buildTypedStringValueForMap(String value, String defaultTypeName, Element entryEle) {  
1264.         try {  
1265.             //创建一个TypeStringValue  
1266.             TypedStringValue typedValue = buildTypedStringValue(value, defaultTypeName);  
1267.             typedValue.setSource(extractSource(entryEle));  
1268.             return typedValue;  
1269.         }  
1270.         catch (ClassNotFoundException ex) {  
1271.             error("Type class [" + defaultTypeName + "] not found for Map key/value type", entryEle, ex);  
1272.             return value;  
1273.         }  
1274.     }  
1275.   
1276.     /** 
1277.      * 解析key的子节点 
1278.      */  
1279.     protected Object parseKeyElement(Element keyEle, BeanDefinition bd, String defaultKeyTypeName) {  
1280.        //获取key的所有子节点  
1281.         NodeList nl = keyEle.getChildNodes();  
1282.         Element subElement = null;  
1283.         for (int i = 0; i < nl.getLength(); i++) {  
1284.             Node node = nl.item(i);  
1285.             if (node instanceof Element) {  
1286.                 // Child element is what we're looking for.  
1287.                 if (subElement != null) {  
1288.                     error("<key> element must not contain more than one value sub-element", keyEle);  
1289.                 }  
1290.                 else {  
1291.                     subElement = (Element) node;  
1292.                 }  
1293.             }  
1294.         }  
1295.         return parsePropertySubElement(subElement, bd, defaultKeyTypeName);  
1296.     }  
1297.   
1298.     /** 
1299.      * Parse a props element. 
1300.      */  
1301.     public Properties parsePropsElement(Element propsEle) {  
1302.         ManagedProperties props = new ManagedProperties();  
1303.         props.setSource(extractSource(propsEle));  
1304.         props.setMergeEnabled(parseMergeAttribute(propsEle));  
1305.   
1306.         List<Element> propEles = DomUtils.getChildElementsByTagName(propsEle, PROP_ELEMENT);  
1307.         for (Element propEle : propEles) {  
1308.             String key = propEle.getAttribute(KEY_ATTRIBUTE);  
1309.             // Trim the text value to avoid unwanted whitespace  
1310.             // caused by typical XML formatting.  
1311.             String value = DomUtils.getTextValue(propEle).trim();  
1312.             TypedStringValue keyHolder = new TypedStringValue(key);  
1313.             keyHolder.setSource(extractSource(propEle));  
1314.             TypedStringValue valueHolder = new TypedStringValue(value);  
1315.             valueHolder.setSource(extractSource(propEle));  
1316.             props.put(keyHolder, valueHolder);  
1317.         }  
1318.   
1319.         return props;  
1320.     }  
1321.   
1322.     /** 
1323.      * Parse the merge attribute of a collection element, if any. 
1324.      */  
1325.     public boolean parseMergeAttribute(Element collectionElement) {  
1326.         String value = collectionElement.getAttribute(MERGE_ATTRIBUTE);  
1327.         if (DEFAULT_VALUE.equals(value)) {  
1328.             value = this.defaults.getMerge();  
1329.         }  
1330.         return TRUE_VALUE.equals(value);  
1331.     }  
1332.   
1333.     public BeanDefinition parseCustomElement(Element ele) {  
1334.         return parseCustomElement(ele, null);  
1335.     }  
1336.   
1337.     public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {  
1338.         String namespaceUri = getNamespaceURI(ele);  
1339.         NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);  
1340.         if (handler == null) {  
1341.             error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);  
1342.             return null;  
1343.         }  
1344.         return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));  
1345.     }  
1346.       
1347.   /** 
1348.    * 装饰BeanDefinition 
1349.    **/  
1350.     public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {  
1351.         return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);  
1352.     }  
1353.   
1354.     public BeanDefinitionHolder decorateBeanDefinitionIfRequired(  
1355.             Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {  
1356.           
1357.         BeanDefinitionHolder finalDefinition = definitionHolder;  
1358.   
1359.         // 获取节点的所有属性，[autowire,autowire-candidate,class,id,lazy-init]  
1360.         NamedNodeMap attributes = ele.getAttributes();  
1361.         //遍历属性  
1362.         for (int i = 0; i < attributes.getLength(); i++) {  
1363.             // autowire  
1364.             Node node = attributes.item(i);  
1365.             finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);  
1366.         }  
1367.   
1368.         NodeList children = ele.getChildNodes();  
1369.         for (int i = 0; i < children.getLength(); i++) {  
1370.             Node node = children.item(i);  
1371.             if (node.getNodeType() == Node.ELEMENT_NODE) {  
1372.                 finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);  
1373.             }  
1374.         }  
1375.         return finalDefinition;  
1376.     }  
1377.   
1378.     private BeanDefinitionHolder decorateIfRequired(  
1379.             Node node, BeanDefinitionHolder originalDef, BeanDefinition containingBd) {  
1380.         //获取节点的命名空间,null  
1381.         String namespaceUri = getNamespaceURI(node);  
1382.          //如果命名空间不是默认的命名空间  
1383.         if (!isDefaultNamespace(namespaceUri)) {  
1384.             //获取命名空间处理器  
1385.             NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);  
1386.             if (handler != null) {  
1387.                 return handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));  
1388.             }  
1389.             else if (namespaceUri != null && namespaceUri.startsWith("http://www.springframework.org/")) {  
1390.                 error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);  
1391.             }  
1392.             else {  
1393.                 // A custom namespace, not to be handled by Spring - maybe "xml:...".  
1394.                 if (logger.isDebugEnabled()) {  
1395.                     logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");  
1396.                 }  
1397.             }  
1398.         }  
1399.         return originalDef;  
1400.     }  
1401.   
1402.     private BeanDefinitionHolder parseNestedCustomElement(Element ele, BeanDefinition containingBd) {  
1403.         BeanDefinition innerDefinition = parseCustomElement(ele, containingBd);  
1404.         if (innerDefinition == null) {  
1405.             error("Incorrect usage of element '" + ele.getNodeName() + "' in a nested manner. " +  
1406.                     "This tag cannot be used nested inside <property>.", ele);  
1407.             return null;  
1408.         }  
1409.         String id = ele.getNodeName() + BeanDefinitionReaderUtils.GENERATED_BEAN_NAME_SEPARATOR +  
1410.                 ObjectUtils.getIdentityHexString(innerDefinition);  
1411.         if (logger.isDebugEnabled()) {  
1412.             logger.debug("Using generated bean name [" + id +  
1413.                     "] for nested custom element '" + ele.getNodeName() + "'");  
1414.         }  
1415.         return new BeanDefinitionHolder(innerDefinition, id);  
1416.     }  
1417.   
1418.   
1419.     /** 
1420.      *获取指定节点的NamespaceURI 
1421.      */  
1422.     public String getNamespaceURI(Node node) {  
1423.         return node.getNamespaceURI();  
1424.     }  
1425.   
1426.       
1427.     public String getLocalName(Node node) {  
1428.         return node.getLocalName();  
1429.     }  
1430.   
1431.       
1432.     public boolean nodeNameEquals(Node node, String desiredName) {  
1433.         return desiredName.equals(node.getNodeName()) || desiredName.equals(getLocalName(node));  
1434.     }  
1435.     /** 
1436.      * 如果给定的namespaceUri不为空且等于http://www.springframework.org/schema/beans 则是默认的命名空间 
1437.      **/  
1438.     public boolean isDefaultNamespace(String namespaceUri) {  
1439.         return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));  
1440.     }  
1441.      
1442.     /** 
1443.      * 判断给定的节点的namespaceUri是不是默认的命名空间值 
1444.      **/  
1445.     public boolean isDefaultNamespace(Node node) {  
1446.         return isDefaultNamespace(getNamespaceURI(node));  
1447.     }  
1448.   
1449.     private boolean isCandidateElement(Node node) {  
1450.         return (node instanceof Element && (isDefaultNamespace(node) || !isDefaultNamespace(node.getParentNode())));  
1451.     }  
1452.   
1453. }