XMLUtil

package com.common.util;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileWriter;

import java.io.IOException;

import java.lang.reflect.Field;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.List;

import org.dom4j.Document;

import org.dom4j.io.OutputFormat;

import org.dom4j.io.XMLWriter;

import com.common.constant.Constant;

import com.thoughtworks.xstream.XStream;

import com.thoughtworks.xstream.converters.Converter;

import com.thoughtworks.xstream.converters.MarshallingContext;

import com.thoughtworks.xstream.converters.UnmarshallingContext;

import com.thoughtworks.xstream.io.HierarchicalStreamReader;

import com.thoughtworks.xstream.io.HierarchicalStreamWriter;

import com.thoughtworks.xstream.io.xml.DomDriver;

import com.zjrs.xml.componentbean.responsebean.Header;

import com.zjrs.xml.componentbean.responsebean.Order;

import com.zjrs.xml.componentbean.responsebean.Package;

import com.zjrs.xml.componentbean.responsebean.Policy;

import com.zjrs.xml.componentbean.responsebean.PolicyValue;

import com.zjrs.xml.componentbean.responsebean.Proposal;

import com.zjrs.xml.componentbean.responsebean.RefundCharge;

import com.zjrs.xml.componentbean.responsebean.Response;

/**

 * @author xu qian

 * @since 2015-05-05

 * @version 1.0 此类依赖的包有：xstream-1.2.1.jar

 */

/*

 * 本类提供了对于XML进行加工的所有静态方法

 */

public class XMLUtil {

private static final XStream mXStream;

/**

* 此方法用于将实体bean转换xml格式的string字符串

* 

* @param entityList是需要注入xml的实体bean注入到xml

* @param header是要生成xml的root

*            header 名称

* @param tail是要生成xml的root

*            tail名称

*/

public static String convertEntityToXML(List entityList, String header,

String tail) {

// 设置实体bean对应的element节点名称

for (Object param : entityList) {

mXStream.alias(param.getClass().getSimpleName(), param.getClass());

checkAliasName(mXStream, param.getClass());

}

StringBuffer xml = new StringBuffer();

xml.append(header);

// 将 实体bean注入xml

for (Object entity : entityList) {

xml.append(mXStream.toXML(entity));

}

xml.append(tail);

return xml.toString();

}

/**

* 此方法用于将实体Doc对象存为xml文件

* 

* @param document是需要存入xml的Doc

* @param XMLPathAndName

*            ,生成的xml要存放的的路径及名称

* @param Encoding

*            XML的字符集，默认是：GBK

*/

public static void saveXML(Document document, String XMLPathAndName,

String Encoding) {

OutputFormat format = OutputFormat.createPrettyPrint();

format.setEncoding(Encoding);// 设置XML文件的编码格式

String filePath = XMLPathAndName;// 获得要保存的文件地址

File file = new File(filePath);// 获得要保存的文件路径及名称

if (!file.exists()) {// 如果文件及路径不存在，则创建路径及文件

file.mkdirs();

}

if (file.exists()) {// 如果文件存在，则删除该文件

file.delete();

}

XMLWriter writer = null;// 声明写XML的对象

try {

writer = new XMLWriter(new FileWriter(file), format);

writer.write(document);

writer.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

/**

* 循环遍历实体，如果实体里面包含List集合，则取出集合中的实体与标签进行关联

* 

* @param xstream

*            XStream对象

* @param param

*            传入要遍历的实体类

*/

public static void checkAliasName(XStream xstream, Class param) {

Field[] properties = param.getDeclaredFields();// 获得实体类的所有属性

for (Field field : properties) {

if (field.getType().isAssignableFrom(List.class)) {// 如果属性的类型是List集合则继续进行

try {

Type type = field.getGenericType();// 取得List<T>,T代表实体类

if (type != null && type instanceof ParameterizedType) {

ParameterizedType pt = (ParameterizedType) type;

Class genericClass = (Class) pt

.getActualTypeArguments()[0];// 取得List集合中的实体类

xstream.alias(genericClass.getSimpleName(),

genericClass);

checkAliasName(xstream, genericClass);// 继续循环该实体类

}

} catch (SecurityException e) {

e.printStackTrace();

}

} else if (field.getType().isPrimitive()

|| field.getType() == (String.class)

|| field.getType() == (Long.class)

|| field.getType() == (Integer.class)

|| field.getType() == (Date.class)) {

} else {

checkAliasName(xstream, field.getType());

}

}

}

/**

* 此方法将XML的string字符串转换成对象

* 

* @param XMLString是String格式的字符串

* @return Package是返回的实体类(com.zjrs.xml.componentbean.responsebean.Package)

*/

public static Package convertXMLToEntity(String XMLString) {

mXStream.alias("Package", Package.class);

mXStream.alias("Header", Header.class);

mXStream.alias("Order", Order.class);

mXStream.alias("PolicyValue", PolicyValue.class);

mXStream.alias("Proposal", Proposal.class);

mXStream.alias("RefundCharge", RefundCharge.class);

mXStream.alias("Policy", Policy.class);

mXStream.alias("Response", Response.class);

Package pkg = new Package();

try {

pkg = (Package) mXStream.fromXML(XMLString);

} catch (Exception e) {

Header header = new Header("001", "内部错误，请联系接口");// 出现错误的原因要么是有List集合要么就出现了上面没有的实体类

pkg.setHeader(header);

}

return pkg;

}

public static XStream getXStream() {

return mXStream;

}

/**

* 自定义日期转换类

*/

private static Converter dateConverter = new Converter() {

@SuppressWarnings("rawtypes")

@Override

public boolean canConvert(Class clazz) {

return clazz == Date.class;

}

// 把时间格式化成需要的格式

@Override

public void marshal(Object bean, HierarchicalStreamWriter writer,

MarshallingContext ctx) {

DateFormat sdf = new SimpleDateFormat(Constant.DATE_FORMAT);

Date date = (Date) bean;

writer.setValue(sdf.format(date));

}

// 格式化解析时间字符串

@Override

public Object unmarshal(HierarchicalStreamReader reader,

UnmarshallingContext ctx) {

DateFormat sdf = new SimpleDateFormat(Constant.DATE_FORMAT);

String dateValue = reader.getValue();

if (dateValue != null && !dateValue.equals("")) {// StringUtils.isNotBlank(dateValue)

try {

return sdf.parse(dateValue);

} catch (Exception e) {

throw new RuntimeException(e);

}

}

return null;

}

};

static {

mXStream = new XStream(new DomDriver(Constant.GBK_Encoding));

mXStream.registerConverter(dateConverter);// 注册时间转换器

}

}