Dom4j解析XML中遇到的一些问题

最近在用Dom4j解析XML文件，遇到了一些问题，记录如下：

1. BOM头问题，得到的异常是：

 Nested exception: org.xml.sax.SAXParseException: Content is not allowed in prolog.

（1）http://koti.mbnet.fi/akini/java/unicodereader/，里面提供了两个删掉BOM头的方法（我用了第一个）：

/**
 version: 1.1 / 2007-01-25
 - changed BOM recognition ordering (longer boms first)

 Original pseudocode   : Thomas Weidenfeller
 Implementation tweaked: Aki Nieminen

 http://www.unicode.org/unicode/faq/utf_bom.html
 BOMs in byte length ordering:
   00 00 FE FF    = UTF-32, big-endian
   FF FE 00 00    = UTF-32, little-endian
   EF BB BF       = UTF-8,
   FE FF          = UTF-16, big-endian
   FF FE          = UTF-16, little-endian

 Win2k Notepad:
   Unicode format = UTF-16LE

This class will help you to autorecognize and skip BOMs. This will support UTF-8 as well.
***/

import java.io.*;

/**
 * This inputstream will recognize unicode BOM marks
 * and will skip bytes if getEncoding() method is called
 * before any of the read(...) methods.
 *
 * Usage pattern:
     String enc = "ISO-8859-1"; // or NULL to use systemdefault
     FileInputStream fis = new FileInputStream(file);
     UnicodeInputStream uin = new UnicodeInputStream(fis, enc);
     enc = uin.getEncoding(); // check and skip possible BOM bytes
     InputStreamReader in;
     if (enc == null) in = new InputStreamReader(uin);
     else in = new InputStreamReader(uin, enc);
 */
public class UnicodeInputStream extends InputStream {
   PushbackInputStream internalIn;
   boolean             isInited = false;
    String              defaultEnc;
    String              encoding;

    private static final int BOM_SIZE = 4;

    UnicodeInputStream(InputStream in, String defaultEnc) {
        internalIn = new PushbackInputStream(in, BOM_SIZE);
        this.defaultEnc = defaultEnc;
    }

    public String getDefaultEncoding() {
      return defaultEnc;
   }

   public String getEncoding() {
      if (!isInited) {
         try {
            init();
         } catch (IOException ex) {
            IllegalStateException ise = new IllegalStateException("Init method failed.");
            ise.initCause(ise);
            throw ise;
         }
      }
      return encoding;
   }

   /**
    * Read-ahead four bytes and check for BOM marks. Extra bytes are
    * unread back to the stream, only BOM bytes are skipped.
    */
   protected void init() throws IOException {
      if (isInited) return;

      byte bom[] = new byte[BOM_SIZE];
      int n, unread;
      n = internalIn.read(bom, 0, bom.length);

      if ( (bom[0] == (byte)0x00) && (bom[1] == (byte)0x00) &&
                  (bom[2] == (byte)0xFE) && (bom[3] == (byte)0xFF) ) {
         encoding = "UTF-32BE";
         unread = n - 4;
      } else if ( (bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) &&
                  (bom[2] == (byte)0x00) && (bom[3] == (byte)0x00) ) {
         encoding = "UTF-32LE";
         unread = n - 4;
      } else if (  (bom[0] == (byte)0xEF) && (bom[1] == (byte)0xBB) &&
            (bom[2] == (byte)0xBF) ) {
         encoding = "UTF-8";
         unread = n - 3;
      } else if ( (bom[0] == (byte)0xFE) && (bom[1] == (byte)0xFF) ) {
         encoding = "UTF-16BE";
         unread = n - 2;
      } else if ( (bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) ) {
         encoding = "UTF-16LE";
         unread = n - 2;
      } else {
         // Unicode BOM mark not found, unread all bytes
         encoding = defaultEnc;
         unread = n;
      }      
      //System.out.println("read=" + n + ", unread=" + unread);

      if (unread > 0) internalIn.unread(bom, (n - unread), unread);

      isInited = true;
   }

   public void close() throws IOException {
      //init();
      isInited = true;
      internalIn.close();
   }

   public int read() throws IOException {
      //init();
      isInited = true;
      return internalIn.read();
   }
}

/**
 version: 1.1 / 2007-01-25
 - changed BOM recognition ordering (longer boms first)

 Original pseudocode   : Thomas Weidenfeller
 Implementation tweaked: Aki Nieminen

 http://www.unicode.org/unicode/faq/utf_bom.html
 BOMs:
   00 00 FE FF    = UTF-32, big-endian
   FF FE 00 00    = UTF-32, little-endian
   EF BB BF       = UTF-8,
   FE FF          = UTF-16, big-endian
   FF FE          = UTF-16, little-endian

 Win2k Notepad:
   Unicode format = UTF-16LE

This class will do everything ever more transparently. Just instantiate it and read text.
***/

import java.io.*;

/**
 * Generic unicode textreader, which will use BOM mark
 * to identify the encoding to be used. If BOM is not found
 * then use a given default or system encoding.
 */
public class UnicodeReader extends Reader {
   PushbackInputStream internalIn;
   InputStreamReader   internalIn2 = null;
   String              defaultEnc;

   private static final int BOM_SIZE = 4;

   /**
    *
    * @param in  inputstream to be read
    * @param defaultEnc default encoding if stream does not have 
    *                   BOM marker. Give NULL to use system-level default.
    */
   UnicodeReader(InputStream in, String defaultEnc) {
      internalIn = new PushbackInputStream(in, BOM_SIZE);
      this.defaultEnc = defaultEnc;
   }

   public String getDefaultEncoding() {
      return defaultEnc;
   }

   /**
    * Get stream encoding or NULL if stream is uninitialized.
    * Call init() or read() method to initialize it.
    */
   public String getEncoding() {
      if (internalIn2 == null) return null;
      return internalIn2.getEncoding();
   }

   /**
    * Read-ahead four bytes and check for BOM marks. Extra bytes are
    * unread back to the stream, only BOM bytes are skipped.
    */
   protected void init() throws IOException {
      if (internalIn2 != null) return;

      String encoding;
      byte bom[] = new byte[BOM_SIZE];
      int n, unread;
      n = internalIn.read(bom, 0, bom.length);

      if ( (bom[0] == (byte)0x00) && (bom[1] == (byte)0x00) &&
                  (bom[2] == (byte)0xFE) && (bom[3] == (byte)0xFF) ) {
         encoding = "UTF-32BE";
         unread = n - 4;
      } else if ( (bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) &&
                  (bom[2] == (byte)0x00) && (bom[3] == (byte)0x00) ) {
         encoding = "UTF-32LE";
         unread = n - 4;
      } else if (  (bom[0] == (byte)0xEF) && (bom[1] == (byte)0xBB) &&
            (bom[2] == (byte)0xBF) ) {
         encoding = "UTF-8";
         unread = n - 3;
      } else if ( (bom[0] == (byte)0xFE) && (bom[1] == (byte)0xFF) ) {
         encoding = "UTF-16BE";
         unread = n - 2;
      } else if ( (bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) ) {
         encoding = "UTF-16LE";
         unread = n - 2;
      } else {
         // Unicode BOM mark not found, unread all bytes
         encoding = defaultEnc;
         unread = n;
      }    
      //System.out.println("read=" + n + ", unread=" + unread);

      if (unread > 0) internalIn.unread(bom, (n - unread), unread);

      // Use given encoding
      if (encoding == null) {
         internalIn2 = new InputStreamReader(internalIn);
      } else {
         internalIn2 = new InputStreamReader(internalIn, encoding);
      }
   }

   public void close() throws IOException {
      init();
      internalIn2.close();
   }

   public int read(char[] cbuf, int off, int len) throws IOException {
      init();
      return internalIn2.read(cbuf, off, len);
   }

}

（2）下面的代码分析了产生BOM头的原因：

import java.io.*;
import java.nio.charset.Charset;
import javax.xml.parsers.*;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class ContentNotAllowedInProlog {
  private static void parse(InputStream stream) throws SAXException,
      ParserConfigurationException, IOException {
    SAXParserFactory.newInstance().newSAXParser().parse(stream,
        new DefaultHandler());
  }

  public static void main(String[] args) {
    String[] encodings = { "UTF-8", "UTF-16", "ISO-8859-1" };
    for (String actual : encodings) {
      for (String declared : encodings) {
        if (actual != declared) {
          String xml = "<?xml version='1.0' encoding='" + declared
              + "'?><x/>";
          byte[] encoded = xml.getBytes(Charset.forName(actual));
          try {
            parse(new ByteArrayInputStream(encoded));
            System.out.println("HIDDEN ERROR! actual:" + actual + " " + xml);
          } catch (Exception e) {
            System.out.println(e.getMessage() + " actual:" + actual + " xml:"
                + xml);
          }
        }
      }
    }
  }
}

2. <!-- -->注释问题，得到的异常是：

Nested exception: org.xml.sax.SAXParseException: The string "--" is not permitted within comments.

产生这个异常的原因有很多。其中一个是<!--  -->中间有“--”字符；另外一个是“-->”前面不是空格，如“abc-->”则会抛出异常，而不是“abc -->”则不会。

我的解决方式就是：删掉所有注释！

 

针对这两个问题，写了个简单工具类：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PushbackInputStream;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.List;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class XmlUtil extends InputStream {
    private static final Logger log = (Logger) LoggerFactory
            .getLogger(XmlUtil.class);
    private static final int BOM_SIZE = 4;
    PushbackInputStream internalIn;
    boolean isInited = false;
    String defaultEnc;
    String encoding;

    public XmlUtil(InputStream in, String defaultEnc) {
        internalIn = new PushbackInputStream(in, BOM_SIZE);
        this.defaultEnc = defaultEnc;
    }

    public String getDefaultEncoding() {
        return defaultEnc;
    }

    /**
     * Read-ahead four bytes and check for BOM marks. Extra bytes are unread
     * back to the stream, only BOM bytes are skipped.
     */
    protected void initXmlBOM() throws IOException {
        if (isInited)
            return;

        byte bom[] = new byte[BOM_SIZE];
        int n, unread;
        n = internalIn.read(bom, 0, bom.length);

        if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00)
                && (bom[2] == (byte) 0xFE) && (bom[3] == (byte) 0xFF)) {
            encoding = "UTF-32BE";
            unread = n - 4;
        } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)
                && (bom[2] == (byte) 0x00) && (bom[3] == (byte) 0x00)) {
            encoding = "UTF-32LE";
            unread = n - 4;
        } else if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB)
                && (bom[2] == (byte) 0xBF)) {
            encoding = "UTF-8";
            unread = n - 3;
        } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) {
            encoding = "UTF-16BE";
            unread = n - 2;
        } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) {
            encoding = "UTF-16LE";
            unread = n - 2;
        } else {
            // Unicode BOM mark not found, unread all bytes
            encoding = defaultEnc;
            unread = n;
        }
        // log.info("read=" + n + ", unread=" + unread);

        if (unread > 0)
            internalIn.unread(bom, (n - unread), unread);

        isInited = true;
    }

    public String getEncoding() {
        if (!isInited) {
            try {
                initXmlBOM();
            } catch (IOException ex) {
                IllegalStateException ise = new IllegalStateException(
                        "Init method failed.");
                ise.initCause(ise);
                throw ise;
            }
        }
        return encoding;
    }

    public static void removeXmlBomAndComment(String filePath) {
        XmlUtil uins = null;
        BufferedReader bufr = null;
        OutputStreamWriter osw = null;
        String enc = "ISO-8859-1";

        String fileContent = "";
        String leftBracket = "<!--";
        String rightBracket = "-->";
        int leftBracketIndex = 0;
        int rightBracketIndex = 0;

        String line = "";
        StringBuffer fileContentBuffer = new StringBuffer();
        try {
            // 根据BOM Mark编码方式，对文件进行重新编码
            uins = new XmlUtil(new FileInputStream(filePath), enc);
            enc = uins.getEncoding();

            if (enc == null) {
                bufr = new BufferedReader(new InputStreamReader(uins));
            } else {
                bufr = new BufferedReader(new InputStreamReader(uins, enc));
            }

            while ((line = bufr.readLine()) != null) {
                fileContentBuffer.append(line);
            }
            uins.close();
            bufr.close();

            // 删除"<!-- -->"格式的注释
            fileContent = fileContentBuffer.toString();
            leftBracketIndex = fileContent.indexOf(leftBracket);
            rightBracketIndex = fileContent.indexOf(rightBracket);
            while (leftBracketIndex < rightBracketIndex
                    && rightBracketIndex != 0) {
                fileContent = fileContent.substring(0, leftBracketIndex)
                        + fileContent.substring(rightBracketIndex + 3,
                                fileContent.length());
                leftBracketIndex = fileContent.indexOf(leftBracket);
                rightBracketIndex = fileContent.indexOf(rightBracket);
            }

            // 将处理过的内容，写入文件
            osw = new OutputStreamWriter(new FileOutputStream(filePath));
            osw.write(fileContent);
            osw.flush();
            osw.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (uins != null) {
                try {
                    uins.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (bufr != null) {
                try {
                    bufr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (osw != null) {
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 如果根元素有声明命名空间，通过xpath匹配子元素时，需要特殊处理。
     * */
    public static List<Element> getNameSpaceElement(Element root, String node) {
        // 获得节点的命名空间
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("mvn", root.getNamespaceURI());
        XPath xpath = DocumentHelper.createXPath("//mvn:" + node);
        xpath.setNamespaceURIs(map);

        @SuppressWarnings("unchecked")
        List<Element> selectedNodes = (List<Element>) xpath.selectNodes(root
                .getDocument());
        return selectedNodes;
    }

    @Override
    public void close() throws IOException {
        // init();
        isInited = true;
        internalIn.close();
    }

    @Override
    public int read() throws IOException {
        // init();
        isInited = true;
        return internalIn.read();
    }
}