工作環境： myeclipse2013、jdk1.8、fastjson1.1.41、xstream1.4.3

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.Writer;
import java.lang.reflect.Field;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.commons.logging.Log;
import
 
 org.apache.commons.logging.LogFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.alibaba.fastjson.JSONObject;
import com.loe.vo.XStreamCDATA;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import
 
 com.thoughtworks.xstream.core.util.QuickWriter;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;
import com.thoughtworks.xstream.io.json.JsonWriter;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.thoughtworks.xstream.io.xml.PrettyPrintWriter;
import
 
 com.thoughtworks.xstream.io.xml.XmlFriendlyNameCoder;
import com.thoughtworks.xstream.io.xml.XppDriver;

public class XmlUtil {

    public static Log logger = LogFactory.getLog(XmlUtil.class);

    /**
     * 讀取xml標籤內容
     * 
     * @param xmlStr
     * @param tagName
     * @return
     * @throws Exception
     */
    public static String readXMLString4TagName(String xmlStr, String tagName)
            throws Exception {

        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

        DocumentBuilder builder = dbf.newDocumentBuilder();

        InputStream inputStream = new ByteArrayInputStream(xmlStr.getBytes());

        Document doc = builder.parse(inputStream); //

        // 下面開始讀取

        Element root = doc.getDocumentElement(); // 獲取根元素

        NodeList nodes = root.getElementsByTagName(tagName);
        Element e = (Element) nodes.item(0);

        Node t = e.getFirstChild();

        return t.getNodeValue();
    }

    /**
     * xmlString 轉換成物件
     * 
     * @param xml
     * @param obj
     * @return
     */
    public static Object xmlToObj(String xml, Object obj) {
        XStream xstream = new XStream();
        xstream.autodetectAnnotations(true);
        obj = xstream.fromXML(xml, obj);
        return obj;
    }

    /**
     * 物件轉換成XMLString
     * 
     * @param alias
     * @param obj
     * @return
     */
    public static String objToXmlStr(String alias, Object obj) {
        XStream xstream = createXstream();
        xstream.autodetectAnnotations(true);
        xstream.alias(alias, obj.getClass());
        String xml = xstream.toXML(obj);
        return xml;
    }

    /**
     * xmlString轉換成物件
     * @param alias
     * @param xml
     * @param obj
     * @return
     */
    public static Object xmlToObj(String alias, String xml, Object obj) {
        XStream xstream = new XStream(new DomDriver());
        xstream.alias(alias, obj.getClass());
        xstream.processAnnotations(obj.getClass());
        obj = xstream.fromXML(xml, obj);
        return obj;
    }

    public static XStream createXstream() {
        return new XStream(new XppDriver() {

            @Override
            public HierarchicalStreamWriter createWriter(Writer out) {
                // 標籤名帶下劃線
                XmlFriendlyNameCoder nameCode = new XmlFriendlyNameCoder("_-",
                        "_");
                return new PrettyPrintWriter(out, nameCode) {
                    boolean cdata = false;
                    Class<?> targetClass = null;

                    @Override
                    public void startNode(String name,
                            @SuppressWarnings("rawtypes") Class clazz) {
                        super.startNode(name, clazz);
                        // 業務處理，對於用XStreamCDATA標記的Field，需要加上CDATA標籤
                        if (!name.equals("xml")) {
                            cdata = needCDATA(targetClass, name);
                        } else {
                            targetClass = clazz;
                        }
                    }

                    protected void writeText(QuickWriter writer, String text) {
                        if (cdata) {
                            writer.write(cDATA(text));
                        } else {
                            writer.write(text);
                        }
                    }
                };
            }
        });
    }

    private static boolean needCDATA(Class<?> targetClass, String fieldAlias) {
        boolean cdata = false;
        // first, scan self
        cdata = existsCDATA(targetClass, fieldAlias);
        if (cdata)
            return cdata;
        // if cdata is false, scan supperClass until java.lang.Object
        Class<?> superClass = targetClass.getSuperclass();
        while (!superClass.equals(Object.class)) {
            cdata = existsCDATA(superClass, fieldAlias);
            if (cdata)
                return cdata;
            superClass = superClass.getClass().getSuperclass();
        }
        return false;
    }

    private static boolean existsCDATA(Class<?> clazz, String fieldAlias) {
        // scan fields
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            // 1. exists XStreamCDATA
            if (field.getAnnotation(XStreamCDATA.class) != null) {
                XStreamAlias xStreamAlias = field
                        .getAnnotation(XStreamAlias.class);
                // 2. exists XStreamAlias
                if (null != xStreamAlias) {
                    String xStreamAliasvalue = xStreamAlias.value();
                    if (fieldAlias.equalsIgnoreCase(xStreamAliasvalue)) {
                        return true;
                    }

                } else {
                    // not exists XStreamAlias
                    if (fieldAlias.equals(field.getName()))
                        return true;
                }
            }
        }
        return false;
    }

    private static String cDATA(String text) {
        StringBuffer str = new StringBuffer();
        str.append("<![CDATA[");
        str.append(text);
        str.append("]]>");
        return str.toString();
    }

    /**
     * 物件轉換成json
     * @param object
     * @return
     */
    public static JSONObject objToJSONStr(Object object){
        XStream xstream = new XStream(new JsonHierarchicalStreamDriver(){
            public HierarchicalStreamWriter createWriter(Writer writer){
                return new JsonWriter(writer, JsonWriter.DROP_ROOT_MODE);
            }
        });
        xstream.processAnnotations(object.getClass());
        return JSONObject.parseObject(xstream.toXML(object));
    }

}

XStreamCDATA.class

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@Documented 
@Inherited
public @interface XStreamCDATA {

}