智能dom4操作xml<->转换

构建

public class SmartXmlBuilderUtil {

/**

* 需要特殊处理Bo

*/

private static Map<String,String> specialDis = new HashMap<String,String>();

static

{

specialDis.put("EmployeeRequisition", "DOCUMENTS");

specialDis.put("PurchaseRequisition", "DOCUMENTS");

}

/**

* 智能构造XML文档

*

* @param obj

* 要生成XML的实体对象

* @param element

* 节点元素

* @return 生成的XML文档

* @throws IllegalAccessException

* @throws IllegalArgumentException

* @throws InstantiationException

* @throws Exception

*/

public static void objectRecursion(Object obj, Element element,String defNodeName)

throws IllegalArgumentException, IllegalAccessException

{

Class<? extends Object> classType = obj.getClass();

Field[] fileds = classType.getDeclaredFields();// 得到实体的所有属性

//String entityName = classType.getSimpleName();

if( null != defNodeName)

element = element.addElement(defNodeName);

//Element entityElement = element;

Element cellElement = null;

for (int i = 0; i < fileds.length; i++) {

Field field = fileds[i];

// 设置private的属性值可以读取

field.setAccessible(true);

String fieldName = field.getName();

cellElement = element.addElement(fieldName.toUpperCase());

Object value = field.get(obj);

if (value != null)

{

if (value instanceof Date)

{

if (!(value instanceof Time)) {

cellElement.addText(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(value));

} else {

cellElement.addText(new SimpleDateFormat("HH:mm:ss").format(value));

}



}

else if (value instanceof List<?>) // 若为list类型装换为一个以‘，’分隔的字符串

{

StringBuffer tempString = new StringBuffer();

List<?> tempList = (List<?>) value;

for (int j = 0; j < tempList.size(); j++) {

tempString.append(tempList.get(j) + ",");

}

cellElement.addText(tempString.toString());

}

else if (value instanceof Set<?>)

{

Set<?> tempSet = (Set<?>) value;

Element setElement = null;

if(!tempSet.iterator().hasNext())

return;

String enementName = tempSet.iterator().next().getClass().getSimpleName();

if(null != specialDis.get(enementName))

{

enementName = specialDis.get(enementName);

}

setElement = element.addElement(enementName.toUpperCase());

// 此方法只处理自己定义的类型，若为元数据类型或者其他更复杂的set类型请自己进行处理

for (Iterator<?> iter = tempSet.iterator(); iter.hasNext();) {

Object object = (Object) iter.next();

objectRecursion(object,setElement,"item");

}

cellElement.detach();// 删除具有set属性的元素，因现在它已经变成一个节点

}

else

{

cellElement.addText(value.toString());

}

}

else

{

cellElement.addText("");

}

}

}

}

解析

public class SmartParsersXmlUtil {

public static final String SYS_DATE_FORMAT = "yyyy-MM-dd";

/**

* 解析XML获取，转换成对应的CLASS

*

*

* @param beanClass Class (需要转换成某个实体的Class)

* @param filepath XML文件名

* @return 单个CLASS对象

* @throws Exception 抛出

*/

public static Object parserXMLToClass(String filePath, Class<?> beanClass)

throws Exception {

File inputXml = new File(filePath);

Object bean = parserXMLToClass(inputXml,beanClass);

return bean;

}

/**

* 解析XML获取，转换成对应的CLASS

*

*

* @param beanClass Class(需要转换成某个实体的Class)

* @param file XML文件

* @return 单个CLASS对象

* @throws InstantiationException 抛出

* @throws IllegalAccessException 抛出

*/

public static Object parserXMLToClass( File file,Class<?> beanClass)throws InstantiationException, IllegalAccessException {

Object bean = beanClass.newInstance();

Long startTime = System.currentTimeMillis();

SAXReader saxReader = new SAXReader();

List<String> fields = captureClassFields(beanClass);

try {

Document document = saxReader.read(file);

Element element = document.getRootElement();

BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);

PropertyDescriptor[] pDesc = beanInfo.getPropertyDescriptors();

System.out.println(element.getName());

parserXMLToClass(bean, element, pDesc,fields);

} catch (Exception e) {

e.printStackTrace();

}

System.out.println("#----Time consuming:\t"+(System.currentTimeMillis() - startTime));

return bean;

}

/**

* 通过解析XML来获取实体LIST

*

*

* @param filePath 文件路径

* @param beanClass 实体类型 (需要转换成某个实体的Class)

* @param parentNode 所在xml父节点

* @return Class集

* @throws Exception 抛出

*/

public static List<?> parserXMLByClassList(String filePath,Class<?> beanClass) throws Exception {

File inputXml = new File(filePath);

return parserXMLByClassList(inputXml, beanClass);

}

/**

* 通过解析XML来获取实体LIST<CLASS>

*

*

*

* @param file XML文件

* @param beanClass 实体类型 (需要转换成某个实体的Class)

* @param parentNode 所在xml父节点

* @return Class集

* @throws Exception 抛出

*/

public static List<?> parserXMLByClassList(File file,Class<?> beanClass) throws Exception {

Long startTime = System.currentTimeMillis();

List<Object> beanList = new ArrayList<Object>();

//Class<? extends Object> beanClass = Class.forName(type.getName());

SAXReader saxReader = new SAXReader();

List<String> fields = captureClassFields(beanClass);

try {

BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);

PropertyDescriptor[] desc = beanInfo.getPropertyDescriptors();

Document document = saxReader.read(file);

Element element = document.getRootElement();

//System.out.println(element.getName());

parsersXmlToClassList(beanClass, beanList, desc, fields,element);

System.out.println("#----Time consuming:\t"+(System.currentTimeMillis() - startTime));

} catch (Exception e) {

e.printStackTrace();

}



return beanList;

}

//解析XML文件CLASS

private static void parserXMLToClass(Object bean,Element element, PropertyDescriptor[] pDesc,List<String> fields)

throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, ParseException {

for (PropertyDescriptor propertyDescriptor : pDesc) {

String propertyName = propertyDescriptor.getName();

for (Iterator<?> iterator = element.elementIterator(); iterator.hasNext();) {

Element tempElement = (Element) iterator.next();

String nodeName = tempElement.getName();

if(nodeName.equals(bean.getClass().getSimpleName()))

{

if (fields.contains(propertyName)) {

Method readMethod = propertyDescriptor.getWriteMethod();

//所有的属性节点都是大写，SO 需要 toUpperCase

String value = tempElement.elementText(propertyName.toUpperCase());

Object result = correctFields(captureFieldType(bean.getClass(), propertyName), value);

//System.out.println("propertyName=" + propertyName + "\tvalue = " + value);

if (value != null) {

readMethod.invoke(bean, result);

}

}

}

else

{

for (Iterator<?> ite = element.elementIterator(); ite.hasNext();) {

Element ele = (Element) ite.next();

parserXMLToClass(bean, ele, pDesc,fields);

}

}

}

}

}

//解析XML文件TOLIST<CLASS>

private static void parsersXmlToClassList(Class<?> beanClass, List<Object> beanList,PropertyDescriptor[] desc, List<String> field, Element element)

throws InstantiationException, IllegalAccessException,

NoSuchFieldException, ParseException, InvocationTargetException {

//类名对应的节点全部大写，SO 需要 toUpperCase

if (!beanClass.newInstance().getClass().getSimpleName().toUpperCase().equals(element.getName())) {

for (Iterator<?> temp = element.elementIterator(); temp.hasNext();) {

Element elm = (Element) temp.next();

//System.out.println(elm.getName());

parsersXmlToClassList(beanClass, beanList, desc,field, elm);

}

}

else

{

for (Iterator<?> temp = element.elementIterator(); temp.hasNext();) {

Element elm = (Element) temp.next();

Object bean = beanClass.newInstance();

for (PropertyDescriptor propertyDescriptor : desc) {

String propertyName = propertyDescriptor.getName();

if (field.contains(propertyName)) {

Method readMethod = propertyDescriptor.getWriteMethod();

//所有的属性节点都是大写，SO 需要 toUpperCase

String value = elm.elementText(propertyName.toUpperCase());

/*-----矫正字段类型START-----*/

Object result = correctFields(captureFieldType(beanClass, propertyName), value);

/*-----矫正字段类型END-----*/

//System.out.println("propertyName=" + propertyName+ "\tvalue = " + value);

if (value != null) {

readMethod.invoke(bean, result);

}

}

}

beanList.add(bean);

}



return;

}

}

//矫正字段类型 ----- 后续跟进补全

private static Object correctFields(Class<?> c, String value) throws NoSuchFieldException,

ParseException {

Object result = value;

if(c == String.class || result== null)

{

return result;

}

else if (c == Double.class) {

result = Double.valueOf(value);

}

else if (c == Long.class) {

result = Long.valueOf(value);

}

else if (c == Timestamp.class) {

SimpleDateFormat ft = new SimpleDateFormat(SYS_DATE_FORMAT);

Date d = (Date) ft.parse(value);

Timestamp ts = new Timestamp(d.getTime());

result = ts;

}

return result;

}

//捕获字段类型

private static Class<?> captureFieldType(Class<? extends Object> beanClass,String propName) throws NoSuchFieldException {

Field f = beanClass.getDeclaredField(propName);

Class<?> c = f.getType();

return c;

}

//捕获类所有字段

private static List<String> captureClassFields(Class<?> beanClass) {

List<String>fields = new ArrayList<String>();

Field[] fs = beanClass.getDeclaredFields();

for (Field f : fs) {

fields.add(f.getName());

}

return fields;

}

}