文档章节

XML Utility

markGao
 markGao
发布于 2013/12/31 11:38
字数 830
阅读 26
收藏 0
package sample;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringReader;
import java.io.Writer;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * XML utility class.
 * 
 * @author $Author: Lihong Gao $
 */
public final class XMLUtil {

    /** Hide default constructor */
    private XMLUtil() {
    }

    /**
     * Selects single node specified by the XPath expression.
     * 
     * @param current
     *            XPath query root node
     * @param xpath
     *            XPath expression
     * @return Selected node
     * @throws AIUException
     *             Indicates more than one nodes are selected
     */
    public static Node selectSingleNode(Node current, String xpath)
            throws Exception {
        // final String method = "selectSingleNode(Node,String)";

        NodeList list = selectNodes(current, xpath);
        if (list == null || list.getLength() == 0) {
            return null;
        } else if (list.getLength() == 1) {
            return list.item(0);
        } else {
            throw new Exception("More than one nodes are selected");
        }
    }

    /**
     * Selects list of nodes specified by the XPath expression.
     * 
     * @param current
     *            XPath query root node
     * @param xpath
     *            XPath expression
     * @return Selected node list
     * @throws AIUException
     *             Indicates XML transform failure
     */
    public static NodeList selectNodes(Node current, String xpath)
            throws Exception {
        // final String method = "selectNodes(Node,String)";

        if (current instanceof Element && xpath.indexOf('/') == -1
                && xpath.indexOf('[') == -1) {
            return ((Element) current).getElementsByTagName(xpath);
        } else {
            String xltString = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
                    + "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">"
                    + "<xsl:output version=\"1.0\" method=\"xml\" encoding=\"utf-8\" />"
                    + "<xsl:template match=\"" + xpath + "\">"
                    + "<xsl:copy-of select=\".\" />" + "</xsl:template>"
                    + "<xsl:template match=\"text()\"/>" + "</xsl:stylesheet>";

            try {
                Element result = (Element) current.cloneNode(false);
                StreamSource template = new StreamSource(new StringReader(
                        xltString));

                TransformerFactory transformerFactory = TransformerFactory
                        .newInstance();
                Transformer transformer = transformerFactory
                        .newTransformer(template);
                transformer.transform(new DOMSource(current), new DOMResult(
                        result));
                return result.getChildNodes();
            } catch (TransformerException ex) {
                throw new Exception(ex.getMessage(), ex);
            }
        }
    }

    /**
     * Retrieves text node values as text recursively.
     * 
     * @param root
     *            Root node
     * @param xpath
     *            XPath expression
     * @return String representation of text nodes
     * @throws Exception
     *             Indicates more than one nodes are selected
     */
    public static String getTextValue(Node root, String xpath) throws Exception {
        StringBuffer buf = new StringBuffer();

        Node node = selectSingleNode(root, xpath);
        if (node == null) {
            return null;
        }

        NodeList children = node.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node child = children.item(i);
            if (child.getNodeType() == Node.TEXT_NODE) {
                buf.append(child.getNodeValue());
            }
        }

        return buf.toString();
    }

    /**
     * Removes all elements specified by element name.
     * 
     * @param node
     *            Node to modify
     * @param name
     *            Element name
     */
    public static void removeNode(Node node, String name) {
        NodeList nodes = ((Element) node).getElementsByTagName(name);
        if (nodes != null) {
            for (int i = 0; i < nodes.getLength(); i++) {
                node.removeChild(nodes.item(i));
            }
        }
    }

    /**
     * Exports DOM node tree to specified output stream.
     * 
     * @param root
     *            Root node
     * @param out
     *            Output writer
     * @throws Exception
     *             Indicates failed to export nodes
     */
    public static void exportNodes(Node root, Writer out) throws Exception {
        exportNodes(root, new StreamResult(out));
    }

    /**
     * Exports DOM node tree to specified output stream.
     * 
     * @param root
     *            Root node
     * @param out
     *            Output stream
     * @throws Exception
     *             Indicates failed to export nodes
     */
    public static void exportNodes(Node root, OutputStream out)
            throws Exception {
        exportNodes(root, new StreamResult(out));
    }

    /**
     * Exports DOM node tree to specified output stream.
     * 
     * @param root
     *            Root node
     * @param result
     *            Result
     * @throws Exception
     *             Indicates failed to export nodes
     */
    public static void exportNodes(Node root, StreamResult result)
            throws Exception {
        // final String method = "exportNodes(Node,OutputStream)";
        final String xltString = "<?xml version=\"1.0\" encoding=\"Shift_JIS\"?>"
                + "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">"
                + "<xsl:output method=\"xml\" version=\"1.0\" encoding=\"Shift_JIS\" omit-xml-declaration=\"yes\" />"
                + "<xsl:template match=\"*\">"
                + "<xsl:copy-of select=\".\" />"
                + "</xsl:template>" + "</xsl:stylesheet>";

        try {
            StreamSource template = new StreamSource(
                    new StringReader(xltString));
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(template);
            transformer.setOutputProperty(OutputKeys.ENCODING, "Shift_JIS");
            transformer.transform(new DOMSource(root), result);
        } catch (TransformerException ex) {
            throw new TransformerException(ex.getMessage(), ex);
        }
    }

    /**
     * Converts Node to Document.
     * 
     * @param node
     *            Node
     * @return Document
     * @throws Exception
     *             Indicates failed to convert.
     */
    public static Document convertToDocument(Node node) throws Exception {
        Document doc = createDocument();
        doc.appendChild(doc.importNode(node, true));
        return doc;
    }

    /**
     * Constructs new Document.
     * 
     * @return Document
     * @throws Exception
     *             Indicates failed to convert.
     */
    public static Document createDocument() throws Exception {
        // final String method = "createDocument()";
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory
                    .newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            return builder.newDocument();
        } catch (DOMException e) {
            throw new DOMException(ISeverityLevels.IMPORTANT, e.getMessage());
        } catch (ParserConfigurationException e) {
            throw new ParserConfigurationException(e.getMessage());
        }
    }

    /**
     * Parses specified XML and returns constructed document.
     * 
     * @param xml
     *            XML to parse
     * @return Document
     * @throws Exception
     *             Indicates failed to convert.
     */
    public static Document parseDocument(String xml) throws Exception {
        // final String method = "parseDocument(String)";
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory
                    .newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            return builder.parse(new InputSource(new StringReader(xml)));
        } catch (IOException e) {
            throw new IOException(e.getMessage(), e);
        } catch (DOMException e) {
            throw new DOMException(ISeverityLevels.IMPORTANT, e.getMessage());
        } catch (ParserConfigurationException e) {
            throw new ParserConfigurationException(e.getMessage());
        } catch (SAXException e) {
            throw new SAXException(e.getMessage(), e);
        }
    }

    public interface ISeverityLevels {
        // severity levels for Exceptions and Logging
        public final static short CRITICAL = 1;
        public final static short IMPORTANT = 4;
        public final static short WARNING = 7;
        public final static short INFORMATIONAL = 10;
        public final static short DEBUG = 13;
        public final static short VERBOSE = 16;
    }

    public static String getXmlString(String inFilename) throws Exception {
        StringBuffer sb = new StringBuffer();
        BufferedReader reader = new BufferedReader(new FileReader(new File(
                inFilename)));
        try {
            String line = null;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            return sb.toString();
        } finally {
            reader.close();
        }
    }

}


© 著作权归作者所有

共有 人打赏支持
markGao
粉丝 15
博文 187
码字总数 91352
作品 0
宝山
程序员
Jenkins中使用Git和Maven之多个项目

1.应用Aggregation管理多个子项目 Maven中有一个Aggregation(聚合),可以将多个项目作为模块添加到一个pom.xml中,然后告诉Jenkins这个顶层pom.xml,就可以自动从Git中拿出这些项目的源代码...

长平狐
2012/08/28
723
0
四种Sandcastle方法生成帮助类帮助文档

方法一、Visual Studio新建documentation生成帮助文档 前段时间在网上收集和自己平时工作总结整理了《干货,比较全面的c#.net公共帮助类》,整理完成上传github之后我又想,既然是帮助类,总得...

安与生_
2017/10/18
0
0
xmlObjectifier

The end of DOM Tree walking is here! This small and fast utility converts an XML file fetched through $.ajax to a JavaScript Object, completely eliminating a need to use DOM Tre......

匿名
2008/09/19
449
0
在Eclipse下 Ant打包报错

这个是build.xml源文件

時間會抹平那些皺褶遺
2015/08/11
832
1
XMLFoundation April 2014 发布

XMLFoundation April 2014 发布,此版本更新内容如下: run the Microsoft Code Analysis in MSDev2012, reviewedall output, silenced some warnings, and added a few if(!Null) checks a......

oschina
2014/04/10
334
0

没有更多内容

加载失败,请刷新页面

加载更多

各种开源汇编、反汇编引擎的非专业比较

由于平时业余兴趣和工作需要,研究过并使用过时下流行的各种开源的x86/64汇编和反汇编引擎。如果要对汇编指令进行分析和操作,要么自己研究Intel指令集写一个,要么就用现成的开源引擎。自己...

simpower
8分钟前
1
0
(4)添加vue-router

(4)添加vue-router 1 安装vue-router cnpm install vue-router --save 2 页面准备 新建目录/src/views/common,此目录下面建立4个组件404.vue、home.vue、login.vue、theme.vue。每个文件...

neumeng
10分钟前
1
0
高可用性系统在大众点评的实践与经验

背景 所谓高可用性指的是系统如何保证比较高的服务可用率,在出现故障时如何应对,包括及时发现、故障转移、尽快从故障中恢复等等。本文主要以点评的交易系统的演进为主来描述如何做到高可用...

Skqing
18分钟前
2
0
Network protocols

The network stack does serveral seemingly-impossible things. It does reliable transmission over our unreliable networks, usually without any detactable hiccups. It adapts smooth......

nao
19分钟前
1
0
Android 生命周期方法

1,onCreate(); 2,onStart(); 3,onResume(); //打开页面,前三个方法自动执行 4,onPause(); 5,onStop(); //打开其他页面,前一个页面执行这俩方法 6,onRestart(); //onStart(),onResume //当关闭...

lanyu96
26分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部