Xpath解析不规则节点XML

Xpath解析不规则节点XML

由于工作上要解析压缩报文,由于节点是不规则的例如:

 

<root>
    <books>
        <book-1>
           <name></name>
           <date></date>
           <author></author>
        </book-1>
        <book-2>
           <name></name>
           <date></date>
           <author></author>
        </book-2>
    </books>    
</root>

 

 

这样的xml需要解析,利用xpath可以得到解析。

解析思路: 1.先遍历的相同的父节点为止,既遍历出到/root/books节点为止。 2.找到他们的子节点,既找到book-1,book-2这一层,之后分别得到他们子节点的值。


//具体代码
​
    
​
•       // 创建Document对象
•            Document doc=null;
•            /*javax.xml.parsers 包中的DocumentBuilderFactory用于创建DOM模式的解析器对象 , DocumentBuilderFactory是一个抽象工厂类,它不能直接实例化,但该类提供了一个newInstance方法 ,这个方法会根据本地平台默认安装的解析器,自动创建一个工厂的对象并返回。*/
•            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();   
​
​
​
​
​
•        /*禁止校验,防止出错*/
•        dbf.setValidating(false);
​
•        /*调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象。*/
•        DocumentBuilder db = dbf.newDocumentBuilder();
•        /*指定方法来将string类型xml报文读取节点*/
•        doc =DOMUtils.parseXMLDocument(dataxml);
​
•        // 创建XPath对象
•        XPath xpath;
•        XPathFactory factory = XPathFactory.newInstance();
•        xpath = factory.newXPath();
​
​
//得到所有的子节点book-1,book-2
 NodeList cardRiskNodeList = (NodeList) xpath.evaluate                  ("/root/books/*", doc,
                    XPathConstants.NODESET);
  //循环遍历
  for (int i = 0; i < nodeList.getLength(); i++) {
            //System.out.println(nodeList.item(i).getNodeName() + " -------" );
            Node node = nodeList.item(i);
           //得到该节点的所有子节点
            NodeList childrenNodes = node.getChildNodes();
            if(childrenNodes!=null&&childrenNodes.getLength()>0){
                //此时子节点为name,date,author
                for (int j = 0; j < childrenNodes.getLength(); j++){
                    Node childNode = childrenNodes.item(j);
                                                                                        System.out.println(childNode.getNodeName());
                } 
​

 

DOMUtils内容,

package com.test.card;
​
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
​
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.TransformerConfigurationException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.*;
import java.util.Properties;
​
public class DOMUtils {
    /**
     * 初始化一个空Document对象返回。
     *
     * @return a Document
     */
    public static Document newXMLDocument() {
        try {
            return newDocumentBuilder().newDocument();
        } catch (ParserConfigurationException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
​
    /**
     * 初始化一个DocumentBuilder
     *
     * @return a DocumentBuilder
     * @throws ParserConfigurationException
     */
    public static DocumentBuilder newDocumentBuilder()
            throws ParserConfigurationException {
        return newDocumentBuilderFactory().newDocumentBuilder();
    }
​
    /**
     * 初始化一个DocumentBuilderFactory
     *
     * @return a DocumentBuilderFactory
     */
    public static DocumentBuilderFactory newDocumentBuilderFactory() {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        return dbf;
    }
​
    /**
     * 将传入的一个XML String转换成一个org.w3c.dom.Document对象返回。
     *
     * @param xmlString
     * 一个符合XML规范的字符串表达。
     * @return a Document
     */
    public static Document parseXMLDocument(String xmlString) {
        if (xmlString == null) {
            throw new IllegalArgumentException();
        }
        try {
            return newDocumentBuilder().parse(
                    new InputSource(new StringReader(xmlString)));
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }
    }
​
    /**
     * 给定一个输入流,解析为一个org.w3c.dom.Document对象返回。
     *
     * @param input
     * @return a org.w3c.dom.Document
     */
    public static Document parseXMLDocument(InputStream input) {
        if (input == null) {
            throw new IllegalArgumentException("参数为null!");
        }
        try {
            return newDocumentBuilder().parse(input);
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }
    }
​
    /**
     * 给定一个文件名,获取该文件并解析为一个org.w3c.dom.Document对象返回。
     *
     * @param fileName
     * 待解析文件的文件名
     * @return a org.w3c.dom.Document
     */
    public static Document loadXMLDocumentFromFile(String fileName) {
        if (fileName == null) {
            throw new IllegalArgumentException("未指定文件名及其物理路径!");
        }
        try {
            return newDocumentBuilder().parse(new File(fileName));
        } catch (SAXException e) {
            throw new IllegalArgumentException("目标文件(" + fileName
                    + ")不能被正确解析为XML!" + e.getMessage());
        } catch (IOException e) {
            throw new IllegalArgumentException("不能获取目标文件(" + fileName + ")!"
                    + e.getMessage());
        } catch (ParserConfigurationException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
​
    /*
     * 把dom文件转换为xml字符串
     */
    public static String toStringFromDoc(Document document) {
        String result = null;
​
        if (document != null) {
            StringWriter strWtr = new StringWriter();
            StreamResult strResult = new StreamResult(strWtr);
            TransformerFactory tfac = TransformerFactory.newInstance();
            try {
                javax.xml.transform.Transformer t = tfac.newTransformer();
                t.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
                t.setOutputProperty(OutputKeys.INDENT, "yes");
                t.setOutputProperty(OutputKeys.METHOD, "xml"); // xml, html,
// text
                t.setOutputProperty(
                        "{http://xml.apache.org/xslt}indent-amount", "4");
                t.transform(new DOMSource(document.getDocumentElement()),
                        strResult);
            } catch (Exception e) {
                System.err.println("XML.toString(Document): " + e);
            }
            result = strResult.getWriter().toString();
            try {
                strWtr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
​
        return result;
    }
​
    /**
     * 给定一个节点,将该节点加入新构造的Document中。
     *
     * @param node
     * a Document node
     * @return a new Document
     */public static Document newXMLDocument(Node node) {
        Document doc = newXMLDocument();
        doc.appendChild(doc.importNode(node, true));
        return doc;
    }
​
/**
* 将传入的一个DOM Node对象输出成字符串。如果失败则返回一个空字符串""。
*
* @param node
* DOM Node 对象。
* @return a XML String from node
*//*
     * public static String toString(Node node) { if (node == null) { throw new
     * IllegalArgumentException(); } Transformer transformer = new
     * Transformer(); if (transformer != null) { try { StringWriter sw = new
     * StringWriter(); transformer .transform(new DOMSource(node), new
     * StreamResult(sw)); return sw.toString(); } catch (TransformerException
     * te) { throw new RuntimeException(te.getMessage()); } } return ""; }
     *//**
* 将传入的一个DOM Node对象输出成字符串。如果失败则返回一个空字符串""。
*
* @param node
* DOM Node 对象。
* @return a XML String from node
*//*
     * public static String toString(Node node) { if (node == null) { throw new
     * IllegalArgumentException(); } Transformer transformer = new
     * Transformer(); if (transformer != null) { try { StringWriter sw = new
     * StringWriter(); transformer .transform(new DOMSource(node), new
     * StreamResult(sw)); return sw.toString(); } catch (TransformerException
     * te) { throw new RuntimeException(te.getMessage()); } } return ""; }
     *//**
     * 获取一个Transformer对象,由于使用时都做相同的初始化,所以提取出来作为公共方法。
     *
     * @return a Transformer encoding gb2312
     */public static Transformer newTransformer() {
        try {
            Transformer transformer = TransformerFactory.newInstance()
                    .newTransformer();
            Properties properties = transformer.getOutputProperties();
            properties.setProperty(OutputKeys.ENCODING, "gb2312");
            properties.setProperty(OutputKeys.METHOD, "xml");
            properties.setProperty(OutputKeys.VERSION, "1.0");
            properties.setProperty(OutputKeys.INDENT, "no");
            transformer.setOutputProperties(properties);
            return transformer;
        } catch (TransformerConfigurationException tce) {
            throw new RuntimeException(tce.getMessage());
        }
    }
​
/**
* 返回一段XML表述的错误信息。提示信息的TITLE为:系统错误。之所以使用字符串拼装,主要是这样做一般 不会有异常出现。
*
* @param errMsg
* 提示错误信息
* @return a XML String show err msg
*/
    /*
     * public static String errXMLString(String errMsg) { StringBuffer msg = new
     * StringBuffer(100);
     * msg.append("<?xml version="1.0" encoding="gb2312" ?>");
     * msg.append("<errNode title="系统错误" errMsg="" + errMsg + ""/>"); return
     * msg.toString(); }
     */
/**
* 返回一段XML表述的错误信息。提示信息的TITLE为:系统错误
*
* @param errMsg
* 提示错误信息
* @param errClass
* 抛出该错误的类,用于提取错误来源信息。
* @return a XML String show err msg
*/
    /*
     * public static String errXMLString(String errMsg, Class errClass) {
     * StringBuffer msg = new StringBuffer(100);
     * msg.append("<?xml version='1.0' encoding='gb2312' ?>");
     * msg.append("<errNode title="
     * 系统错误" errMsg=""+ errMsg + "" errSource=""+ errClass.getName()+ ""/>");
     *  return msg.toString(); }
     */
    /**
     * 返回一段XML表述的错误信息。
     *
     * @param title
     * 提示的title
     * @param errMsg
     * 提示错误信息
     * @param errClass
     * 抛出该错误的类,用于提取错误来源信息。
     * @return a XML String show err msg
     */public static String errXMLString(String title, String errMsg,
                                      Class errClass) {
        StringBuffer msg = new StringBuffer(100);
        msg.append("<?xml version='1.0' encoding='utf-8' ?>");
        msg.append("<errNode title=" + title + "errMsg=" + errMsg
                + "errSource=" + errClass.getName() + "/>");
        return msg.toString();
    }
​
}

 




posted @ 2020-08-13 15:55  无语的风  阅读(252)  评论(0编辑  收藏  举报