xstream特殊字符转义问题

最新推荐文章于 2020-01-13 18:46:36 发布
最新推荐文章于 2020-01-13 18:46:36 发布
阅读量2.2k 收藏 5
点赞数 2
分类专栏： java 文章标签： java xstream 特殊字符转义 xstream特殊字符转义
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43613717/article/details/102709635
版权

xstream特殊字符被转义问题

1.问题描述

在这里插入图片描述
如上图显示，类似于“”，‘’这些特殊符号使用xstream，被转义成特殊字符
代码如下：

public class XmlUtils {
    private static XStream xstream=createXStream();

    private static XStream createXStream() {
        StaxDriver staxDriver=new StaxDriver();
        //不转义字符
        staxDriver.getOutputFactory().setProperty("escapeCharacters", false);
        xstream = new XStream(staxDriver);
        xstream.autodetectAnnotations(true);
        return xstream;
    }
    /**
     * 在指定路径生成xml文件
     *
     * @param t
     * @param xmlPath
     * @param <T>
     * @throws IOException
     */
    public static <T> void toXML(T t, Path xmlPath) throws IOException {
        File file = new File(xmlPath.toUri());
        if (!file.exists()) {
            file.createNewFile();
        }
        PrettyPrintWriter prettyPrintWriter = new PrettyPrintWriter(new FileWriter(file));
        xstream.marshal(t, prettyPrintWriter);
        prettyPrintWriter.close();
    }

    public static <T> T fromXML(Path xmlPath) throws MalformedURLException {
        File file = new File(xmlPath.toUri());
        return (T) xstream.fromXML(file);
    }

    /**
     * 生成xml字符串
     *
     * @param t
     * @param <T>
     * @return
     */
    public static <T> String toXML(T t) {
        return xstream.toXML(t);
    }

    public static <T> T fromXML(String xml) {
        return (T) xstream.fromXML(xml);
    }

    /**
     * 别名
     *
     * @param aliasMap 需要起别名的class，如果没有别名，Xstream会默认以Class的全限定名作为节点名称
     */
    public static void alias(Map<String, Class> aliasMap) {
        aliasMap.forEach((k, v) -> xstream.alias(k, v));
    }

    public static XStream getXstream() {
        return xstream;
    }
}

原因： PrettyPrintWriter 这里有个writeText方法这里，没有对特殊字符做了转义
在这里插入图片描述

2.解决方案

定义编写器，对特殊字符不做转义

import com.thoughtworks.xstream.core.util.FastStack;
import com.thoughtworks.xstream.core.util.QuickWriter;
import com.thoughtworks.xstream.io.AbstractWriter;
import com.thoughtworks.xstream.io.StreamException;
import com.thoughtworks.xstream.io.naming.NameCoder;

import java.io.Writer;

/**
 * @author liangwt
 * @create 2019/10/16
 * @Description :
 * @since 1.0.0
 */
public class NoneEscapePrettyPintWriter extends AbstractWriter {

    public static int XML_QUIRKS = -1;
    public static int XML_1_0 = 0;
    public static int XML_1_1 = 1;

    private final QuickWriter writer;
    private final FastStack elementStack = new FastStack(16);
    private final char[] lineIndenter;
    private final int mode;

    private boolean tagInProgress;
    protected int depth;
    private boolean readyForNewLine;
    private boolean tagIsEmpty;
    private String newLine;

    private static final char[] NULL = "&#x0;".toCharArray();
    private static final char[] AMP = "&amp;".toCharArray();
    private static final char[] LT = "&lt;".toCharArray();
    private static final char[] GT = "&gt;".toCharArray();
    private static final char[] CR = "&#xd;".toCharArray();
    private static final char[] QUOT = "&quot;".toCharArray();
    private static final char[] APOS = "&apos;".toCharArray();
    private static final char[] CLOSE = "</".toCharArray();

    private NoneEscapePrettyPintWriter(
            Writer writer, int mode, char[] lineIndenter, NameCoder nameCoder,
            String newLine) {
        super(nameCoder);
        this.writer = new QuickWriter(writer);
        this.lineIndenter = lineIndenter;
        this.newLine = newLine;
        this.mode = mode;
        if (mode < XML_QUIRKS || mode > XML_1_1) {
            throw new IllegalArgumentException("Not a valid XML mode");
        }
    }

    /**
     * @since 1.4
     */
    public NoneEscapePrettyPintWriter(Writer writer, NameCoder nameCoder) {
        this(writer, XML_QUIRKS, new char[]{' ', ' '}, nameCoder, "\n");
    }


    public void startNode(String name) {
        String escapedName = encodeNode(name);
        tagIsEmpty = false;
        finishTag();
        writer.write('<');
        writer.write(escapedName);
        elementStack.push(escapedName);
        tagInProgress = true;
        depth++;
        readyForNewLine = true;
        tagIsEmpty = true;
    }

    public void startNode(String name, Class clazz) {
        startNode(name);
    }

    public void setValue(String text) {
        readyForNewLine = false;
        tagIsEmpty = false;
        finishTag();

        writeText(writer, text);
    }

    public void addAttribute(String key, String value) {
        writer.write(' ');
        writer.write(encodeAttribute(key));
        writer.write('=');
        writer.write('\"');
        writeAttributeValue(writer, value);
        writer.write('\"');
    }

    protected void writeAttributeValue(QuickWriter writer, String text) {
        writeText(text, true);
    }

    protected void writeText(QuickWriter writer, String text) {
        writeText(text, false);
    }

    private void writeText(String text, boolean isAttribute) {
        int length = text.length();
        for (int i = 0; i < length; i++) {
            char c = text.charAt(i);
            switch (c) {
                case '\0':
                    if (mode == XML_QUIRKS) {
                        this.writer.write(NULL);
                    } else {
                        throw new StreamException("Invalid character 0x0 in XML stream");
                    }
                    break;
                case '&':
                    if (isAttribute)
                        this.writer.write(AMP);
                    else
                        this.writer.write(c);
                    break;
                case '<':
                    if (isAttribute)
                        this.writer.write(LT);
                    else
                        this.writer.write(c);
                    break;
                case '>':
                    if (isAttribute)
                        this.writer.write(GT);
                    else
                        this.writer.write(c);
                    break;
                case '"':
                    if (isAttribute)
                        this.writer.write(QUOT);
                    else
                        this.writer.write(c);
                    break;
                case '\'':
                    if (isAttribute)
                        this.writer.write(APOS);
                    else
                        this.writer.write(c);
                    break;
                case '\r':
                    if (isAttribute)
                        this.writer.write(CR);
                    else
                        this.writer.write(c);
                    break;
                case '\t':
                case '\n':
                    if (!isAttribute) {
                        this.writer.write(c);
                        break;
                    }
                default:
                    if (Character.isDefined(c) && !Character.isISOControl(c)) {
                        if (mode != XML_QUIRKS) {
                            if (c > '\ud7ff' && c < '\ue000') {
                                throw new StreamException("Invalid character 0x"
                                        + Integer.toHexString(c)
                                        + " in XML stream");
                            }
                        }
                        this.writer.write(c);
                    } else {
                        if (mode == XML_1_0) {
                            if (c < 9
                                    || c == '\u000b'
                                    || c == '\u000c'
                                    || c == '\u000e'
                                    || (c >= '\u000f' && c <= '\u001f')) {
                                throw new StreamException("Invalid character 0x"
                                        + Integer.toHexString(c)
                                        + " in XML 1.0 stream");
                            }
                        }
                        if (mode != XML_QUIRKS) {
                            if (c == '\ufffe' || c == '\uffff') {
                                throw new StreamException("Invalid character 0x"
                                        + Integer.toHexString(c)
                                        + " in XML stream");
                            }
                        }
                        this.writer.write("&#x");
                        this.writer.write(Integer.toHexString(c));
                        this.writer.write(';');
                    }
            }
        }
    }

    public void endNode() {
        depth--;
        if (tagIsEmpty) {
            writer.write('/');
            readyForNewLine = false;
            finishTag();
            elementStack.popSilently();
        } else {
            finishTag();
            writer.write(CLOSE);
            writer.write((String) elementStack.pop());
            writer.write('>');
        }
        readyForNewLine = true;
        if (depth == 0) {
            writer.flush();
        }
    }

    private void finishTag() {
        if (tagInProgress) {
            writer.write('>');
        }
        tagInProgress = false;
        if (readyForNewLine) {
            endOfLine();
        }
        readyForNewLine = false;
        tagIsEmpty = false;
    }

    protected void endOfLine() {
        writer.write(getNewLine());
        for (int i = 0; i < depth; i++) {
            writer.write(lineIndenter);
        }
    }

    public void flush() {
        writer.flush();
    }

    public void close() {
        writer.close();
    }

    /**
     * Retrieve the line terminator.
     * <p>
     * This method returns always a line feed, since according the XML specification any parser
     * must ignore a carriage return. Overload this method, if you need different behavior.
     *
     * @return the line terminator
     * @since 1.3
     */
    protected String getNewLine() {
        return newLine;
    }
}

重写 XppDriver 解析器的HierarchicalStreamWriter方法

import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.xml.XppDriver;

import java.io.Writer;

/**
 * @author liangwt
 * @create 2019/10/16
 * @Description :
 * @since 1.0.0
 */
public class NoneEscapeAppDriver extends XppDriver {

    @Override
    public HierarchicalStreamWriter createWriter(Writer out) {
        return new NoneEscapePrettyPintWriter(out, getNameCoder());
    }
}

最后调用

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.PrettyPrintWriter;
import com.thoughtworks.xstream.io.xml.StaxDriver;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.nio.file.Path;
import java.util.Map;

/**
 * @author liangwt
 * @create 2019/10/21
 * @Description :
 * @since 1.0.0
 */
public class XmlUtils {
    private static XStream xstream=createXStream();

    private static XStream createXStream() {
        xstream = new XStream(new NoneEscapeAppDriver());
        xstream.autodetectAnnotations(true);
        return xstream;
    }
    /**
     * 在指定路径生成xml文件
     *
     * @param t
     * @param xmlPath
     * @param <T>
     * @throws IOException
     */
    public static <T> void toXML(T t, Path xmlPath) throws IOException {
        File file = new File(xmlPath.toUri());
        if (!file.exists()) {
            file.createNewFile();
        }
        xstream.processAnnotations(t.getClass());
        FileOutputStream fos = new FileOutputStream(xmlPath.toString());
        fos.write(xstream.toXML(t).getBytes());
        fos.close();
    }

    public static <T> T fromXML(Path xmlPath) throws MalformedURLException {
        File file = new File(xmlPath.toUri());
        return (T) xstream.fromXML(file);
    }

    /**
     * 生成xml字符串
     *
     * @param t
     * @param <T>
     * @return
     */
    public static <T> String toXML(T t) {
        return xstream.toXML(t);
    }

    public static <T> T fromXML(String xml) {
        return (T) xstream.fromXML(xml);
    }

    /**
     * 别名
     *
     * @param aliasMap 需要起别名的class，如果没有别名，Xstream会默认以Class的全限定名作为节点名称
     */
    public static void alias(Map<String, Class> aliasMap) {
        aliasMap.forEach((k, v) -> xstream.alias(k, v));
    }

    public static XStream getXstream() {
        return xstream;
    }
}

问题解决！！

爱飞的毛毛虫
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Xstream特殊字符相关问题及处理
qq_42275953的博客
04-02 1263
例如 PayResult result = new PayResult(); result.setPayUrl(“http:abced?amount=122&payWay=weixin”); 问题描述 当使用Xstream.toXML（result）方法转换报文后，payUrl的值为：http:abced?amount=122&amp;payWay=weixin & 被转译...
xml中的特殊字符替换
12-16
xml中的一点特殊字符的转换 写xml常用的特殊字符
xtream处理特殊字符的问题
java-北京-菜鸟
09-01 3070
需求：在生成XML文档中需要支持CDATA标签，而且不是所字段都需要增加，只需要某些特定的字段增加CDATA的标签。  研究：在网上找了一些相关资料，基本采用的方法都是重载XppDriver，做一个MyXppDriver类对XppDriver进行扩展，MyXppDriver中的作用，就是将要生成的xml文件的text进行字符转义，最后使用XStream xstream = new XStre
xstream解析xml时遇到特殊字符出错
Yan456jie的专栏
06-09 2561
在xml中有“&”符号时，解析xml出错 解决办法： 将&替换成&
XStream解析xml的特殊字符支持
WWW_LJJ的博客
03-16 2965
在XStream解析xml报文时，发现无法将xml字符串转成Vo对象，认真看了报文之后发现推送回来的额policyUrl中存在一个“&”的特殊字符；原因是xml不支持这种特殊字符，需要转义。查了一下网上的解释，Firefox浏览器、谷歌Chrome浏览器以及大多数浏览器在显示xml文件时，显示的并不是文件源码，而是经过“xml解析器”解析后的结果。但是，“xml解析器”在遇到字符“&”时，会把“&
xml-XStream关于添加CDATA,特殊字符问题
大帅的博客
11-18 1563
最近处理遇到一个需求就是要在xml中添加特殊字符，其实很简单 <ccontent><![CDATA[本保单行驶证车主为&<詹姆斯/科比>]]></ccontent> 但是大部分系统用的都是自动转换工具，我们系统使用的是XStream，这个工具有个缺点就是不能修改数据，因此需要在类中添加<![CDATA[********]]标签。 ...
XML 显示双引号
Blog of Tom Chao Zhou
12-23 5166
关于XML显示引号，双引号http://topic.csdn.net/t/20030310/12/1511513.html
XML转义特殊字符
Que_Li的博客
08-24 1264
正常来说，只有”<” 字符和”&”字符对于XML来说是严格禁止使用的。 需要注意的是： a. 转义序列各字符间不能有空格； b. 转义序列必须以”；”结束； c. 单独的&不被认为是转义开始； d. 区分大小写。 以下是XML中需要的转义字符:[/size] &(逻辑与) & <(小于) < (大于) > “(双引号) " ‘
XStream实现Java对象到xml的相互转换
CSDN已弃用
01-13 1936
使用xStream实现xml和object的相互转换 官方地址：http://x-stream.github.io/index.html 1.xStream的依赖 <!-- https://mvnrepository.com/artifact/com.thoughtworks.xstream/xstream --> <dependency> <...
xstream1.4.15.JAR
02-23
XStream < 1.4.15 反序列化漏洞修复
XStream：Object与Xml字符串 互相转换
06-12
XStream：Object与Xml字符串 互相转换 多个同名子节点以及节点属性的处理
XStream解析字符串不同的标签
09-05
如果是android的项目请使用xstream-1.4.4.jar
xstream-1.4.19.jar
05-04
xstream-1.4.19.jar
xstream最新版 - xstream-1.4.18.jar
12-21
xstream最新版jar包
XStream解析XML实例
04-14
XStream解析XML实例
xstream-1.4.12.jar
06-12
最新xstreamb1.4.12出来了，功能强大及代码简洁性是JAVA的特性，欢迎大家下载使用，以提高你的开发效率。
xstream特殊字符被转义问题
sinat_32364425的博客
10-10 2240
<dependency> <groupId>com.thoughtworks.xstream</groupId> <artifactId>xstream</artifactId> <version>1.4.11.1</version> </dependency> 这篇博客有解决方案，博主试...
xstream 1.4.8
最新发布
09-11
xstream 1.4.8是一种Java XML序列化库，它允许开发人员将Java对象转换为XML格式，并在需要时将其重新转换为Java对象。它提供了一种简单且灵活的方法来处理对象之间的数据转换和传输。 xstream 1.4.8具有很多特性和功能。首先，它支持将Java对象序列化为XML，并能够自动识别对象中的字段和属性。这样，开发人员可以轻松地将对象转换为可读性较高的XML格式，并轻松地在需要时进行反序列化。其次，xstream 1.4.8具有很高的性能和效率。它使用一种高效的序列化算法，可以处理大型对象图，并在转换和传输数据时具有很低的开销。 另外，xstream 1.4.8还支持对序列化结果进行自定义。开发人员可以使用注解或配置文件来选择序列化的字段和属性，并可以定义转换规则和策略以满足自己的需求。这使得xstream 1.4.8非常灵活，并可以适应各种不同的应用场景。 总的来说，xstream 1.4.8是一个功能强大且易于使用的Java XML序列化库。它可以帮助开发人员快速、高效地进行对象数据的转换和传输，为开发人员提供了更多的选择和灵活性。无论是在Web应用程序还是在其他类型的Java应用程序中，xstream 1.4.8都可能是一个有价值的工具。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值