xml工具类

package com.bestpay.messagecenter.push.common.util;

import java.io.Reader;
import java.io.Writer;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import lombok.extern.slf4j.Slf4j;

import org.xmlpull.v1.XmlPullParserException;

import com.google.common.base.Throwables;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.converters.basic.DateConverter;
import com.thoughtworks.xstream.core.util.QuickWriter;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.naming.NoNameCoder;
import com.thoughtworks.xstream.io.xml.*;
import com.thoughtworks.xstream.io.xml.xppdom.XppFactory;
import com.thoughtworks.xstream.mapper.MapperWrapper;

/**
 * xml解析工具类
 *
 * @author linxing
 * @version XmlUtil.java, v 0.1 2016/11/15 10:46 linxing Exp $$
 */
@Slf4j
public class XmlUtil {

    private XmlUtil() {
        throw new IllegalAccessError("Utility class");
    }

    /**
     * xstream静态对象
     */
    private static XStream                xstream;

    /**
     * 初始化xstream静态对象
     */
    static {
        xstream = new XStream(new DomDriver("UTF-8", new XmlFriendlyNameCoder("-_", "_")));
    }

    /**
     * XStream缓存map
     */
    protected static Map<String, XStream> xStreamMap = new ConcurrentHashMap();

    /**
     * 获取xml数据流
     *
     * @param classes
     * @return
     */
    public static XStream getStream(Class<?>[] classes) {

        String key = "";
        Class[] arrayOfClass = classes;
        int j = classes.length;
        for (int i = 0; i < j; i++) {
            Class clazz = arrayOfClass[i];
            key = key + clazz.getName();
        }

        XStream xStream = xStreamMap.get(key);
        if (xStream == null) {
            xStream = genXStream();
            xStreamMap.put(key, xStream);
        }

        xStream.processAnnotations(classes);
        return xStream;
    }

    /**
     * 解析xml数据流
     *
     * @return
     */
    public static XStream genXStream() {
        // 创建 XStream 对象
        XStream xStream = new XStream(new MyXppDriver()) {
            // 将XML映射为类对象
            @Override
            protected MapperWrapper wrapMapper(MapperWrapper next) {
                return new MapperWrapper(next) {
                    @Override
                    public boolean shouldSerializeMember(Class definedIn, String fieldName) {
                        if (definedIn == Object.class) {
                            try {
                                return realClass(fieldName) != null;
                            } catch (Exception e) {
                                log.error("XStream wrapMapper fail:{}",
                                    Throwables.getStackTraceAsString(e));
                                return false;
                            }
                        }
                        return super.shouldSerializeMember(definedIn, fieldName);
                    }
                };
            }
        };
        // 注册转换器
        xStream.registerConverter(new DateConverter());
        xStream.aliasSystemAttribute(null, "class");
        return xStream;
    }

    public static class MyXppDriver extends XppDriver {
        // 创建 Writer 输出流
        @Override
        public HierarchicalStreamWriter createWriter(Writer out) {
            return new PrettyPrintWriter(out, new XmlFriendlyNameCoder("_-", "_")) {
                @Override
                public void startNode(String name, Class clazz) {
                    super.startNode(name, clazz);
                }
                @Override
                protected void writeText(QuickWriter writer, String text) {
                    writer.write(text);
                }
            };
        }
        // 创建 Reader 输入流
        @Override
        public HierarchicalStreamReader createReader(Reader reader) {
            try {
                return new XppReader(reader, XppFactory.createDefaultParser(),
                        new NoNameCoder()) {
                };
            } catch (XmlPullParserException e) {
                log.error("XStream createReader fail:{}", Throwables.getStackTraceAsString(e));
            }
            return null;
        }
    }

    /**
     * 解析XML字符串
     *
     * @param inputXml XML字符串
     * @param types 注解对象类型
     * @return 解析对象
     */
    public static Object xml2Object(String inputXml, Class<?>[] types) {

        if (null == inputXml || "".equals(inputXml)) {
            return null;
        }
        xstream.processAnnotations(types);
        return xstream.fromXML(inputXml);
    }

}

 private IpyySendResult parseSendResult(String respMessage) {

        // 解析返回结果
        XStream xstream = XmlUtil.getStream(new Class[]{IpyySendResult.class});
        return (IpyySendResult) xstream.fromXML(respMessage);
    }