java xml转义方法以及中文字符的处理

对于xml的转义最方便，最简单的方法就是直接使用apache的commons.lang jar包中的StringEscapeUtils的escapeXml方法。但该方法在commons lang 2.x和commons lang 3.x的处理方式不太一样。

注意,注意,注意:commons lang3.6或更高版本把StringEscapeUtils移到了commons-text包中了.

在commons lang 2.x中StringEscapeUtils的escapeXml方法除了会对xml中的“，&，<，>和‘等字符进行转义外，还会对unicode编码大于0x7F的字符进行转义。

在StringEscapeUtils中创建了xml Entities对象。在该对象中添加了了BASIC_ARRAY和APOS_ARRAY中定义的字符，如果碰到这些字符就会进行转义。

BASIC_ARRAY中定义了

private static final String[][] BASIC_ARRAY = {{ "quot", "34"}, // " - double-quote
{ "amp", "38"}, // & - ampersand
{ "lt", "60"}, // < - less-than
{ "gt", "62"}, // > - greater-than
};

APOS_ARRAY中定义了

private static final String[][] APOS_ARRAY = {{ "apos", "39"}, // XML apostrophe
};

因此会对这些定义的字符进行转义。escapeXml方法调用Entities.XML.escape的方法进行转义的具体操作

public void escape(Writer writer, String str) throws IOException {
int len = str.length();
for ( int i = 0; i < len; i++) {
char c = str.charAt(i);
String entityName = this.entityName(c);
if (entityName == null) {
if (c > 0x7F) {
writer.write( "&#");
writer.write(Integer.toString(c, 10));
writer.write( ';');
} else {
writer.write(c);
}
} else {
writer.write( '&');
writer.write(entityName);
writer.write( ';');
}
}
}

可以看出还对Unicode编码大于ox7F的字符进行了转义。因此使用该方法会使得中文字符也会被转义。

如果不想使用中文字符被转义，要么自己可以参考上面的代码，自己改写，去掉对大于0x7F的字符的转义，要么可以使用commons lang3中的escapeXml相关方法。commons lang3中对方法使用策略模式进行了重新设计。相关的方法有escapeXml、escapeXml10和escapeXml11。

其中escapeXml方法已经被废弃。该方法只转义xml中的“，&，<，>和‘5个字符进行转义。将new LookupTranslator(EntityArrays.BASIC_ESCAPE())和new LookupTranslator(EntityArrays.APOS_ESCAPE())两个Tranlator注册到ESCAPE_XML上

escapeXml10方法除了对上述5个字符进行转义外，还会将一些控制字符，例如\b、\t、\n、\r等等替换成空字符串。因为XML1.0是纯文本格式，不能表示控制字符。另外对于不成对的代理码点也不能表示，因此会去除掉。因此注册到escapeXml10的Translator除了new LookupTranslator(EntityArrays.BASIC_ESCAPE())和new LookupTranslator(EntityArrays.APOS_ESCAPE())外，还有

new LookupTranslator(
            new String[][] {
                    { "\u0000", "" }, { "\u0001", "" },  { "\u0002", "" },  { "\u0003", "" }, { "\u0004", "" }, { "\u0005", "" },  { "\u0006", "" },  { "\u0007", "" }, { "\u0008", "" },
                    { "\u000b", "" }, { "\u000c", "" },  { "\u000e", "" },  { "\u000f", "" },  { "\u0010", "" },  { "\u0011", "" },  { "\u0012", "" },  { "\u0013", "" }, { "\u0014", "" },
                    { "\u0015", "" },  { "\u0016", "" }, { "\u0017", "" },  { "\u0018", "" }, { "\u0019", "" },  { "\u001a", "" }, { "\u001b", "" },  { "\u001c", "" },  { "\u001d", "" },
                    { "\u001e", "" },  { "\u001f", "" },  { "\ufffe", "" },  { "\uffff", "" }
            }),
    和
    new UnicodeUnpairedSurrogateRemover()。

一个是用来处理控制字符，一个是用来处理未成对的代理码点,移除掉码值在[#xD8000,#xDFFF]之间的码值字符。也就是escapeXml10会移除不在下面码值范围内的所有码值：

#x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]。

另外escapeXml10还注册了NumericEntityEscaper.between(0x7f, 0x84)和NumericEntityEscaper.between(0x86, 0x9f)两个Translator，将[#x7F-#x84] | [#x86-#x9F]}两个范围内的字符进行转义。

对于escapeXml11，由于XML 1.1可以表示一定的控制字符，所以对于控制字符的Translator和escapeXml10不太相同。

new LookupTranslator(
    new String[][] {
            { "\u0000", "" },
            { "\u000b", "&#11;" },
            { "\u000c", "&#12;" },
            { "\ufffe", "" },
            { "\uffff", "" }
})

escapeXml11将会移除不在下面码值范围内的所有码值：

[#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]

escapeXml11还注册了

NumericEntityEscaper.between(0x1, 0x8),
NumericEntityEscaper.between(0xe, 0x1f),
NumericEntityEscaper.between(0x7f, 0x84),
NumericEntityEscaper.between(0x86, 0x9f),

四个Translator，这样将会对在#x1-#x8] | [#xB-#xC] | [#xE-#x1F] | [#x7F-#x84] | [#x86-#x9F]范围内的码值进行转义。

所使用的主要函数就是这三个。下面说一下其大概的一个工作原理。

对于这三个函数都分别使用了不同的Translator。不过都是AggregateTranslator类的对象。从这个类的名字也可以看出这是个集成Translator，作用就是调用其中注册的一组Translator。所有的Translator都继承自CharSequenceTranslator抽象类，在转义方法中都是直接调用了CharSequenceTranslator的

/**
* Helper for non-Writer usage.
* @param input CharSequence to be translated
* @return String output of translation
*/
public final String translate(final CharSequence input) {
if (input == null) {
return null;
}
try {
final StringWriter writer = new StringWriter(input.length() * 2);
translate(input, writer);
return writer.toString();
} catch ( final IOException ioe) {
// this should never ever happen while writing to a StringWriter
throw new RuntimeException(ioe);
}
}

方法，这个方法又调用了

/**
* Translate an input onto a Writer. This is intentionally final as its algorithm is
* tightly coupled with the abstract method of this class.
*
* @param input CharSequence that is being translated
* @param out Writer to translate the text to
* @throws IOException if and only if the Writer produces an IOException
*/
public final void translate(final CharSequence input, final Writer out) throws IOException {
if (out == null) {
throw new IllegalArgumentException( "The Writer must not be null");
}
if (input == null) {
return;
}
int pos = 0;
final int len = input.length();
while (pos < len) {
//从pos位置开始，对该位置开始的字符进行遍历转义，并返回转义的代码点的个数。注意是代码点，而不是char的个数或者代码单元的个数，
//这个函数在CharSequenceTranslator是个虚函数，需要各继承类实现。并约定每个继承类需要处理码值代理对
//关于码值代理对的概念，可以参考我的另一篇博文“java char String中涉及到的length字符长度概念的研究”
final int consumed = translate(input, pos, out);
if (consumed == 0) { //说明调用的traslator没有需要处理的转移字符
// inlined implementation of Character.toChars(Character.codePointAt(input, pos))
// avoids allocating temp char arrays and duplicate checks
char c1 = input.charAt(pos);
out.write(c1);
pos++;
//如果当前位置是个代理对码值，那么就需要把该辅助字符的第一和第二部分同时处理输出
if (Character.isHighSurrogate(c1) && pos < len) {
char c2 = input.charAt(pos);
if (Character.isLowSurrogate(c2)) {
out.write(c2);
pos++;
}
}
continue;
}
// contract with translators is that they have to understand codepoints
// and they just took care of a surrogate pair
//consumed应该表示的是代码点的数量，因此需要获取当前位置的代码点的代码单元的个数，然后将pos指向需要处理的下一个代码点
for ( int pt = 0; pt < consumed; pt++) {
pos += Character.charCount(Character.codePointAt(input, pos));
}
}
}

该方法又调用了方法

/**
* Translate a set of codepoints, represented by an int index into a CharSequence,
* into another set of codepoints. The number of codepoints consumed must be returned,
* and the only IOExceptions thrown must be from interacting with the Writer so that
* the top level API may reliably ignore StringWriter IOExceptions.
*
* @param input CharSequence that is being translated
* @param index int representing the current point of translation
* @param out Writer to translate the text to
* @return int count of codepoints consumed
* @throws IOException if and only if the Writer produces an IOException
*/
public abstract int translate(CharSequence input, int index, Writer out) throws IOException;

这是个虚函数，继承该类都需要实现。在AggregateTranslator的translate方法中就能直接调用集成在这里面的其它对象的translate方法。

AggregateTranslator的translate方法如下：

/**
* The first translator to consume codepoints from the input is the 'winner'.
* Execution stops with the number of consumed codepoints being returned.
* {@inheritDoc}
*/
@Override
public int translate(final CharSequence input, final int index, final Writer out) throws IOException {
for ( final CharSequenceTranslator translator : translators) {
final int consumed = translator.translate(input, index, out);
if(consumed != 0) {
return consumed;
}
}
return 0;
}

此外，再看一下用的比较频繁的LookupTranslator的实现。
该类的构造函数对传进来的字符映射表进行遍历处理，将二元数组的映射表转换成map保存在lookupMap结构中，便于后续的查找处理，找出每个映射组的前缀保存在prefxSet中。并记录每个二元数组中字符长度最长的和最短的保存在longest和shortest变量中。
其继承实现的translate函数如下：

@Override
public int translate(final CharSequence input, final int index, final Writer out) throws IOException {
//从 input的index位置进行比较，只要找到一个就返回
// check if translation exists for the input at position index
if (prefixSet.contains(input.charAt(index))) {
int max = longest;
if (index + longest > input.length()) {
max = input.length() - index;
}
//先从最长的字符串进行匹配
// implement greedy algorithm by trying maximum match first
for ( int i = max; i >= shortest; i--) {
final CharSequence subSeq = input.subSequence(index, index + i);
final String result = lookupMap.get(subSeq.toString());

if (result != null) {
out.write(result);
return i;
}
}
}
return 0;
}

具体实现就是这样子的。但是我认为此函数有问题。因为它返回的是char的length而不是代码点的长度。如果lookupTable中的key是含有辅助字符的，在CharSequenceTranslator的tanslate函数处理地方：

// contract with translators is that they have to understand codepoints
// and they just took care of a surrogate pair
for ( int pt = 0; pt < consumed; pt++) {
pos += Character.charCount(Character.codePointAt(input, pos));
}

应该就会有bug了。这里需要注意一下。
好了，现在对于escapeXml相关函数的工作原理了解清楚了。其实质就是创建CharSequenceTranslator，调用translate函数进行转义。其实我们也可以根据自己的需要组合出自己的CharSequenceTranslator来进行转义，而不调用定制的escapeXml函数。