XML解析工具类

1.         由于以前在解析XML的时候，每次都要采用获取XML中的属性名来获取对应的值，每一个bean类都要写一个XML解析器。这将会使代码变得更加冗余，而没办法做到高度抽象。幸亏Java有自身的内省机制，Introspector与反射类似，主要是对Java Bean属性、方法等的一种处理方法。
2.  
3. package com.ibm.cn.xml;
4.  
5. import java.beans.BeanInfo;
6. importjava.beans.Introspector;
7. import java.beans.PropertyDescriptor;
8. import java.io.File;
9. importjava.lang.reflect.Method;
10. import java.util.ArrayList;
11. import java.util.Iterator;
12. import java.util.List;
13.  
14. import org.dom4j.Document;
15. import org.dom4j.Element;
16. importorg.dom4j.io.SAXReader;
17.  
18.  
19. /**
20.  * XML解析工具类
21.  * @author javamickey
22.  * @date 2012-11-01
23.  * @version 2.0
24.  */
25. public class ParsersUtil {
26.  
27.  
28.                 /**
29.                  * 通过XML文件名，来解析XML对象，此函数只针对XML中存在一个bean值的情况
30.                  * @paramfileName XML文件名
31.                  * @param typebean类名
32.                  * @return 单个bean对象
33.                  * @throwsException
34.                  */
35.                 public static Object parserXMLByFileName(StringfileName, Class<?> type)
36.                                                 throws Exception {
37.                                 Class<? extends Object>beanClass = Class.forName(type.getName());
38.                                 Object bean =beanClass.newInstance();
39.                                 File inputXml = new File(fileName);
40.                                 SAXReader saxReader = new SAXReader();
41.                                 try {
42.                                                 Document document =saxReader.read(inputXml);
43.                                                 Element element =document.getRootElement();
44.                                                 BeanInfo beanInfo =Introspector.getBeanInfo(type);
45.                                                 PropertyDescriptor[]propertyDescriptors = beanInfo.getPropertyDescriptors();
46.                                                 for(PropertyDescriptor propertyDescriptor : propertyDescriptors) {
47.                                                                 StringpropertyName = propertyDescriptor.getName();
48.                                                                 for(Iterator<?> iterator = element.elementIterator(); iterator.hasNext();) {
49.                                                                                 ElementemployeeElement = (Element) iterator.next();
50.                                                                                 if(!propertyName.equals("class")) {
51.                                                                                                 MethodreadMethod = propertyDescriptor.getWriteMethod();
52.                                                                                                 Stringvalue = employeeElement.elementText(propertyName);
53.                                                                                                 System.out.println("propertyName="+ propertyName + "value = " + value);
54.                                                                                                 if(value != null) {
55.                                                                                                                 readMethod.invoke(type,value);
56.                                                                                                 }
57.                                                                                 }
58.                                                                 }
59.                                                 }
60.                                 } catch (Exception e) {
61.                                                 e.printStackTrace();
62.                                 }
63.                                 return bean;
64.                 }
65.  
66.                 /**
67.                  * 通过XML文件名，来解析XML对象，此函数针对XML中存在一个或者多个bean值的情况
68.                  * @paramfileName XML文件名
69.                  * @param typebean类名
70.                  * @return 返回一个List<bean>
71.                  * @throwsException
72.                  */
73.                 public static List<Object>parserXMLByFileNameList(String fileName, Class<?> type)
74.                                                 throws Exception {
75.                                 Class<? extends Object>beanClass = Class.forName(type.getName());
76.                                 List<Object> beanList = newArrayList<Object>();
77.                                 File inputXml = new File(fileName);
78.                                 SAXReader saxReader = newSAXReader();
79.                                 try {
80.                                                 Document document =saxReader.read(inputXml);
81.                                                 Element element =document.getRootElement();
82.                                                 BeanInfo beanInfo =Introspector.getBeanInfo(type);
83.                                                 PropertyDescriptor[]propertyDescriptors = beanInfo.getPropertyDescriptors();
84.                                                 for(Iterator<?> iterator = element.elementIterator(); iterator.hasNext();) {
85.                                                                 Objectbean = beanClass.newInstance();
86.                                                                 ElementemployeeElement = (Element) iterator.next();
87.                                                                 for(PropertyDescriptor propertyDescriptor : propertyDescriptors) {
88.                                                                                 StringpropertyName = propertyDescriptor.getName();
89.                                                                                 if(!propertyName.equals("class")) {
90.                                                                                                 MethodreadMethod = propertyDescriptor.getWriteMethod();
91.                                                                                                 Stringvalue = employeeElement.elementText(propertyName);
92.                                                                                                 System.out.println("propertyName="+ propertyName + "value = " + value);
93.                                                                                                 if(value != null) {
94.                                                                                                                 readMethod.invoke(bean,value);
95.  
96.                                                                                                 }
97.                                                                                 }
98.                                                                 }
99.                                                                 beanList.add(bean);
100.                                                 }
101.  
102.                                 } catch (Exception e) {
103.                                                 e.printStackTrace();
104.  
105.                                 }
106.                                 return beanList;
107.                 }
108.  
109. }