在Java中过滤非法XML字符

Question

XML规范定义了XML文档中允许的Unicode字符的子集： http://www.w3.org/TR/REC-xml/#charsets。

如何从Java中的字符串中筛选出这些字符？

简单的测试案例：

Assert.equals("", filterIllegalXML(""+Character.valueOf((char) 2))) 

Answer 1

找到XML的所有无效字符并不是微不足道的。你需要调用或者重新从Xerces的的XMLChar.isInvalid（），

http://kickjava.com/src/org/apache/xerces/util/XMLChar.java.htm

Answer 2

使用StringEscapeUtils.escapeXml(xml)从commons-lang会逃跑，不过滤的字符。

Answer 3

您可以使用regex (Regular Expression)做的工作，看到评论here

Answer 4

This page包括通过测试每个字符是否是规范中剥离出来invalid XML characters Java方法的例子，虽然它不检查highly discouraged字符

顺便说一句，转义字符并不是解决方案，因为XML 1.0和1.1规范不允许转义形式的无效字符。

Answer 5

这里有一个解决方案，它负责将原料炭以及逃脱字符流中使用StAX或SAX的原理。它需要对其他无效字符延长，但你的想法

import java.io.BufferedReader; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.InputStreamReader; 
import java.io.OutputStreamWriter; 
import java.io.Reader; 
import java.io.UnsupportedEncodingException; 
import java.io.Writer; 

import org.apache.commons.io.IOUtils; 
import org.apache.xerces.util.XMLChar; 

public class IgnoreIllegalCharactersXmlReader extends Reader { 

    private final BufferedReader underlyingReader; 
    private StringBuilder buffer = new StringBuilder(4096); 
    private boolean eos = false; 

    public IgnoreIllegalCharactersXmlReader(final InputStream is) throws UnsupportedEncodingException { 
     underlyingReader = new BufferedReader(new InputStreamReader(is, "UTF-8")); 
    } 

    private void fillBuffer() throws IOException { 
     final String line = underlyingReader.readLine(); 
     if (line == null) { 
      eos = true; 
      return; 
     } 
     buffer.append(line); 
     buffer.append('\n'); 
    } 

    @Override 
    public int read(char[] cbuf, int off, int len) throws IOException { 
     if(buffer.length() == 0 && eos) { 
      return -1; 
     } 
     int satisfied = 0; 
     int currentOffset = off; 
     while (false == eos && buffer.length() < len) { 
      fillBuffer(); 
     } 
     while (satisfied < len && buffer.length() > 0) { 
      char ch = buffer.charAt(0); 
      final char nextCh = buffer.length() > 1 ? buffer.charAt(1) : '\0'; 
      if (ch == '&' && nextCh == '#') { 
    final StringBuilder entity = new StringBuilder(); 
    // Since we're reading lines it's safe to assume entity is all 
    // on one line so next char will/could be the hex char 
    int index = 0; 
    char entityCh = '\0'; 
    // Read whole entity 
    while (entityCh != ';') { 
     entityCh = buffer.charAt(index++); 
     entity.append(entityCh); 
    } 
    // if it's bad get rid of it and clean it from the buffer and point to next valid char 
    if (entity.toString().equals("&#2;")) { 
     buffer.delete(0, entity.length()); 
     continue; 
    } 
      } 
      if (XMLChar.isValid(ch)) { 
    satisfied++; 
    cbuf[currentOffset++] = ch; 
      } 
      buffer.deleteCharAt(0); 
     } 
     return satisfied; 
    } 

    @Override 
    public void close() throws IOException { 
     underlyingReader.close(); 
    } 

    public static void main(final String[] args) { 
     final File file = new File(
    <XML>); 
     final File outFile = new File(file.getParentFile(), file.getName() 
    .replace(".xml", ".cleaned.xml")); 
     Reader r = null; 
     Writer w = null; 
     try { 
      r = new IgnoreIllegalCharactersXmlReader(new FileInputStream(file)); 
      w = new OutputStreamWriter(new FileOutputStream(outFile),"UTF-8"); 
      IOUtils.copyLarge(r, w); 
      w.flush(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } finally { 
      IOUtils.closeQuietly(r); 
      IOUtils.closeQuietly(w); 
     } 
    } 
} 

Answer 6

松散的基础上，从斯蒂芬C'S答案的链接comment，和维基百科的XML 1.1 spec这里将告诉您如何删除Java方法使用正则表达式替换的非法字符：

boolean isAllValidXmlChars(String s) { 
    // xml 1.1 spec http://en.wikipedia.org/wiki/Valid_characters_in_XML 
    if (!s.matches("[\\u0001-\\uD7FF\\uE000-\uFFFD\\x{10000}-\\x{10FFFF}]")) { 
    // not in valid ranges 
    return false; 
    } 
    if (s.matches("[\\u0001-\\u0008\\u000b-\\u000c\\u000E-\\u001F\\u007F-\\u0084\\u0086-\\u009F]")) { 
    // a control character 
    return false; 
    } 

    // "Characters allowed but discouraged" 
    if (s.matches(
    "[\\uFDD0-\\uFDEF\\x{1FFFE}-\\x{1FFFF}\\x{2FFFE}–\\x{2FFFF}\\x{3FFFE}–\\x{3FFFF}\\x{4FFFE}–\\x{4FFFF}\\x{5FFFE}-\\x{5FFFF}\\x{6FFFE}-\\x{6FFFF}\\x{7FFFE}-\\x{7FFFF}\\x{8FFFE}-\\x{8FFFF}\\x{9FFFE}-\\x{9FFFF}\\x{AFFFE}-\\x{AFFFF}\\x{BFFFE}-\\x{BFFFF}\\x{CFFFE}-\\x{CFFFF}\\x{DFFFE}-\\x{DFFFF}\\x{EFFFE}-\\x{EFFFF}\\x{FFFFE}-\\x{FFFFF}\\x{10FFFE}-\\x{10FFFF}]" 
)) { 
    return false; 
    } 

    return true; 
}