xml解析工具类

xml是用来描述一组数据的规范，在不同系统交互，或者通信的过程中，我们往往使用到它，所以对于xml解析用的也是比较多的。本文没有依赖任何第三方jar包，就是jdk本身的API完成，支持任意复杂的xml的解析，有自定义handler供实现。

package com.xxx.utility.xml;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;

import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import org.xml.sax.InputSource;

/**
 * XML读取工具类,依赖jar包:无
 *
 * @author komojoemary
 * @version [版本号, 2010-11-19]
 */
public class ReadXML
{

    /**
     * 判断依据1：节点文本内容不为空
     */
    public static final String JUDGEMENT_BASIS_TYPE1 = "textContentNotNull";

    /**
     * 判断依据2：节点文本内容为空
     */
    public static final String JUDGEMENT_BASIS_TYPE2 = "textContentNull";

    /**
     * 判断依据3：属性不为空
     */
    public static final String JUDGEMENT_BASIS_TYPE3 = "attributeNotNull";

    /**
     * 判断依据4：属性为空
     */
    public static final String JUDGEMENT_BASIS_TYPE4 = "attributeNull";

    /**
     * 默认的判断依据是节点文本内容不为空
     */
    private String judgementBasis = JUDGEMENT_BASIS_TYPE1;

    /**
     * 是否仅获取一个唯一的节点
     */
    private boolean isOnly = false;

    /**
     * 自定义xml解析接口
     */
    private XmlParserHandler xmlParserHandler = null;

    private boolean refresh = false;

    private String filePath = null;

    public ReadXML() {
    }

    public ReadXML(XmlParserHandler xmlParserHandler) {
        this.xmlParserHandler = xmlParserHandler;
    }

    public ReadXML(String judgementBasis) {
        this.judgementBasis = judgementBasis;
    }

    /************************************* 下面18个是对外公布的接口 ***********************************************/
    /**
     * 根据节点tag从xml文件中解析获取一个满足条件的xml节点的文本值
     *
     * @param filePath
     *            文件路径
     * @param tagName
     *            节点tag
     * @return String
     */
    public String getTextContentByTagFromFile(String filePath, String tagName) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, filePath, true), tagName, null, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0).getTextValue();
        }
        return null;
    }

    /**
     * 根据节点tag从xml文件中解析获取一个满足条件的xml节点
     *
     * @param filePath
     *            文件路径
     * @param tagName
     *            节点tag
     * @return XMLNode
     */
    public XMLNode getXMLNodeByTagFromFile(String filePath, String tagName) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, filePath, true), tagName, null, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0);
        }
        return null;
    }

    /**
     * 根据节点文本内容从xml文件中解析获取一个满足条件的xml节点
     *
     * @param filePath
     *            文件路径
     * @param text
     *            节点文本内容
     * @return XMLNode
     */
    public XMLNode getXMLNodeByTextFromFile(String filePath, String text) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, filePath, true), null, text, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0);
        }
        return null;
    }

    /**
     * 根据节点tag从xml文件中解析获取一组满足条件的xml节点
     *
     * @param filePath
     *            文件路径
     * @param tagName
     *            节点tag
     * @return List<XMLNode>
     */
    public List<XMLNode> getXMLNodeListByTagFromFile(String filePath, String tagName) {
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, filePath, true), tagName, null, XMLNodeList);
        return XMLNodeList;
    }

    /**
     * 根据节点文本内容从xml文件中解析获取一组满足条件的xml节点
     *
     * @param filePath
     *            文件路径
     * @param text
     *            节点文本内容
     * @return List<XMLNode>
     */
    public List<XMLNode> getXMLNodeListByTextFromFile(String filePath, String text) {
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, filePath, true), null, text, XMLNodeList);
        return XMLNodeList;
    }

    /*-----------------------------------------------------------------------------------------------*/
    /**
     * 根据节点tag从xml文件内容中解析获取一个满足条件的xml节点的文本值
     *
     * @param content
     *            xml文件内容
     * @param tagName
     *            节点tag
     * @return String
     */
    public String getTextContentByTagFromStr(String content, String tagName) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, content, false), tagName, null, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0).getTextValue();
        }
        return null;
    }

    /**
     * 根据节点tag从xml文件内容中解析获取一个满足条件的xml节点
     *
     * @param content
     *            xml文件内容
     * @param tagName
     *            节点tag
     * @return XMLNode
     */
    public XMLNode getXMLNodeByTagFromStr(String content, String tagName) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, content, false), tagName, null, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0);
        }
        return null;
    }

    /**
     * 根据节点文本内容从xml文件内容中解析获取一个满足条件的xml节点
     *
     * @param content
     *            xml文件内容
     * @param text
     *            节点文本内容
     * @return XMLNode
     */
    public XMLNode getXMLNodeByTextFromStr(String content, String text) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, content, false), null, text, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0);
        }
        return null;
    }

    /**
     * 根据节点tag从xml文件内容中解析获取一组满足条件的xml节点
     *
     * @param content
     *            xml文件内容
     * @param tagName
     *            节点tag
     * @return List<XMLNode>
     */
    public List<XMLNode> getXMLNodeListByTagFromStr(String content, String tagName) {
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, content, false), tagName, null, XMLNodeList);
        return XMLNodeList;
    }

    /**
     * 根据节点文本内容从xml文件内容中解析获取一组满足条件的xml节点
     *
     * @param content
     *            xml文件内容
     * @param text
     *            节点文本内容
     * @return List<XMLNode>
     */
    public List<XMLNode> getXMLNodeListByTextFromStr(String content, String text) {
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(null, content, false), null, text, XMLNodeList);
        return XMLNodeList;
    }

    /*-----------------------------------------------------------------------------------------------*/
    /**
     * 根据节点tag从xml文件输入流中解析获取一个满足条件的xml节点的文本值
     *
     * @param ins
     *            xml文件输入流
     * @param tagName
     *            节点tag
     * @return String
     */
    public String getTextContentByTagFromInputStream(InputStream ins, String tagName) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(ins, null, false), tagName, null, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0).getTextValue();
        }
        return null;
    }

    /**
     * 根据节点tag从xml文件输入流中解析获取一个满足条件的xml节点
     *
     * @param ins
     *            xml文件输入流
     * @param tagName
     *            节点tag
     * @return XMLNode
     */
    public XMLNode getXMLNodeByTagFromInputStream(InputStream ins, String tagName) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(ins, null, false), tagName, null, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0);
        }
        return null;
    }

    /**
     * 根据节点文本内容从xml文件输入流中解析获取一个满足条件的xml节点
     *
     * @param ins
     *            xml文件输入流
     * @param text
     *            节点文本内容
     * @return XMLNode
     */
    public XMLNode getXMLNodeByTextFromInputStream(InputStream ins, String text) {
        this.isOnly = true;
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(ins, null, false), null, text, XMLNodeList);
        if (XMLNodeList.size() > 0) {
            return XMLNodeList.get(0);
        }
        return null;
    }

    /**
     * 根据节点tag从xml文件输入流中解析获取一组满足条件的xml节点
     *
     * @param ins
     *            xml文件输入流
     * @param tagName
     *            节点tag
     * @return List<XMLNode>
     */
    public List<XMLNode> getXMLNodeListByTagFromInputStream(InputStream ins, String tagName) {
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(ins, null, false), tagName, null, XMLNodeList);
        return XMLNodeList;
    }

    /**
     * 根据节点文本内容从xml文件输入流中解析获取一组满足条件的xml节点
     *
     * @param ins
     *            xml文件输入流
     * @param text
     *            节点文本内容
     * @return List<XMLNode>
     */
    public List<XMLNode> getXMLNodeListByTextFromInputStream(InputStream ins, String text) {
        List<XMLNode> XMLNodeList = new ArrayList<XMLNode>();
        getXMLNode(getDocument(ins, null, false), null, text, XMLNodeList);
        return XMLNodeList;
    }

    /*-----------------------------------------------------------------------------------------------*/
    /**
     * 从一个xml文件中进行解析(针对于自定义解析接口的情况,实现比较复杂的xml解析逻辑)
     *
     * @param filePath
     *            文件路径
     */
    public void parserXmlFromFile(String filePath) {
        getXMLNode(getDocument(null, filePath, true), null, null, null);
    }

    /**
     * 从一个xml文件内容中进行解析(针对于自定义解析接口的情况,实现比较复杂的xml解析逻辑)
     *
     * @param filePath
     *            文件内容
     */
    public void parserXmlFromStr(String content) {
        getXMLNode(getDocument(null, content, false), null, null, null);
    }

    /**
     * 从一个xml文件输入流中进行解析(针对于自定义解析接口的情况,实现比较复杂的xml解析逻辑)
     *
     * @param ins
     *            文件输入流
     */
    public void parserXmlFromInputStream(InputStream ins) {
        getXMLNode(getDocument(ins, null, false), null, null, null);
    }

    /************************************* 上面18个是对外公布的接口 ***********************************************/
    /**
     * 获取一个Document
     *
     * @param ins
     *            输入流
     * @param pathOrContent
     *            文件路径or文件内容
     * @param file
     *            是否是文件
     * @return Document
     */
    private static Document getDocument(InputStream ins, String pathOrContent, boolean file) {
        // 创建新的输入源SAX 解析器
        SAXBuilder sb = new SAXBuilder();
        // 创建一个dom对象
        Document doc = null;
        FileInputStream fis = null;
        try {
            // 如果输入流不为空,那么直接构造
            if (ins != null) {
                doc = sb.build(ins);
            }
            else {
                InputSource source = null;
                // 如果是文件,那么先构造一个文件
                if (file) {
                    File newfile = new File(pathOrContent);
                    fis = new FileInputStream(newfile);
                    source = new InputSource(fis);
                }
                // 如果是内容,那么构造一个输入流
                else {
                    StringReader reader = new StringReader(pathOrContent);
                    source = new InputSource(reader);
                }
                // 通过输入源构造一个Document
                doc = sb.build(source);
            }
        }
        catch (JDOMException e) {
            e.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if (fis != null) {
                // 2011年3月14（关闭流）
                try {
                    fis.close();
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
       
//            Transformer transformer;
//            try {
//                transformer = TransformerFactory.newInstance().newTransformer(new JDOMSource(doc));
//                transformer.getOutputProperty("encoding");
//            }
//            catch (TransformerConfigurationException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//            catch (TransformerFactoryConfigurationError e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//            XSLTransformer transformer=new XSLTransformer(doc);
           
        return doc;
    }

    public void getXMLNode(Document doc, String tagName, String text, List<XMLNode> XMLNodeList) {
        // 取的根元素
        Element root = doc.getRootElement();
        // 递归整个dom tree
        recureDocument(root, tagName, text, XMLNodeList);
        // 如果需要更新
        if (refresh) {
            refreshXml(doc, filePath);
        }
    }

    public static void refreshXml(Document doc, String filePath) {
        Format f = Format.getPrettyFormat();   
        f.setEncoding("utf-8"); 
        f.setLineSeparator("\r\n");
        XMLOutputter outputter = new XMLOutputter(f);
        try {
            FileWriter writer = new FileWriter(filePath);
            outputter.output(doc, writer);
            writer.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
       

//        try {
//            Transformer transformer = TransformerFactory.newInstance().newTransformer();
//            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
//            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
//            transformer.transform(new JDOMSource(doc), new StreamResult(filePath));
//        }
//        catch (TransformerException e) {
//            e.printStackTrace();
//        }
//        catch (TransformerFactoryConfigurationError e) {
//            e.printStackTrace();
//        }
       
       
//
//        TransformerFactory tf = TransformerFactory.newInstance();
//        // 此实例可以用于处理来自不同源的 XML，并将转换输出写入各种接收器。
//        Transformer transformer;
//        OutputStreamWriter pw = null;
//        try {
//            transformer = tf.newTransformer();
//            // 创建带有 DOM 节点的新输入源
//            JDOMSource source = new JDOMSource(doc);
//            // 设置转换中实际的输出属性
//            transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
//            // 设置转换中实际的输出属性
//            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
//            // 编码方式
//            pw = new OutputStreamWriter(new FileOutputStream(filePath), "UTF-8");
//            // 从字节流构造 StreamResult
//            StreamResult result = new StreamResult(pw);
//            // 充当转换结果的持有者，可以为
//            // XML、纯文本、HTML
//            // 或某些其他格式的标记
//            // 将 XML Source 转换为 Result
//            transformer.transform(source, result);
//            // 关闭流
//        }
//        catch (Exception ex) {
//            Logger.getLogger(WriteXML.class.getName()).log(Level.SEVERE, null, ex);
//        }
//        finally {
//            if (pw != null) {
//                try {
//                    pw.close();
//                }
//                catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }
   
    }

    /**
     * 递归Document树：找出满足条件的节点
     *
     * @param nodeEl
     *            当前节点
     * @param tagName
     *            标签名字
     * @param text
     *            文本内容
     * @param XMLNodeList
     *            存储满足条件节点的容器
     * @return boolean 是否结束
     */
    @SuppressWarnings("unchecked")
    public boolean recureDocument(Element nodeEl, String tagName, String text, List<XMLNode> XMLNodeList) {
        // 判断是否到了解析终止点
        boolean breakPoint = checkBreakPoint(nodeEl, tagName, text);
        // 如果到了终止点
        if (breakPoint) {
            // 自定义接口的直接终止,否则根据解析过滤规则判断是否能够终止
            if (xmlParserHandler != null || endDocument(nodeEl, XMLNodeList)) {
                return true;
            }
        }
        // 没有的话继续递归后续子节点
        else {
            // 得到根元素所有子元素的集合
            List<Element> nodeList = nodeEl.getChildren();
            if (nodeList != null && nodeList.size() > 0) {
                for (Element ele : nodeList) {
                    if (recureDocument(ele, tagName, text, XMLNodeList)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 检测是否到了解析终止点
     *
     * @param nodeEl
     *            当前节点
     * @param tagName
     *            标签名字
     * @param text
     *            文本内容
     * @return 是否终止点
     */
    private boolean checkBreakPoint(Element nodeEl, String tagName, String text) {
        boolean breakPoint = false;
        // 自定义xml解析接口
        if (xmlParserHandler != null) {
            breakPoint = xmlParserHandler.parserElementNode(nodeEl);
        }
        // 查询某些特殊节点
        else {
            boolean tag = tagName == null ? false : true;
            // 查询节点的方式,tag or text,根据名字匹配规则判断是否找到了节点
            if (tag && tagName.equals(nodeEl.getName()) || !tag && text.equals(nodeEl.getText())) {
                breakPoint = true;
            }
        }
        return breakPoint;
    }

    /**
     * 添加一个XMLNode,并且判断是否已经完成
     *
     * @param root
     *            Element节点
     * @return XMLNode
     */
    @SuppressWarnings("unchecked")
    private boolean endDocument(Element root, List<XMLNode> XMLNodeList) {
        boolean end = false;
        XMLNode node = new XMLNode(root.getName(), root.getText());
        List<Attribute> list = root.getAttributes();
        if (list != null && list.size() > 0) {
            for (Attribute attribute : list) {
                node.getAttribute().add(new XMLNode(attribute.getName(), attribute.getValue()));
            }
        }
        // 是否要获取唯一节点
        if (isOnly) {
            if (judgementBasis.equals(JUDGEMENT_BASIS_TYPE1)) {
                if (root.getText() != null && !root.getText().equals("")) {
                    XMLNodeList.add(node);
                    end = true;
                }
            }
            else if (judgementBasis.equals(JUDGEMENT_BASIS_TYPE2)) {
                if (root.getText() == null || root.getText().equals("")) {
                    XMLNodeList.add(node);
                    end = true;
                }
            }
            else if (judgementBasis.equals(JUDGEMENT_BASIS_TYPE3)) {
                if (root.getAttributes() != null && root.getAttributes().size() > 0) {
                    XMLNodeList.add(node);
                    end = true;
                }
            }
            else if (judgementBasis.equals(JUDGEMENT_BASIS_TYPE4)) {
                if (root.getAttributes() == null || root.getAttributes().size() == 0) {
                    XMLNodeList.add(node);
                    end = true;
                }
            }

        }
        else {
            XMLNodeList.add(node);
        }
        return end;
    }

    public void setRefresh(boolean refresh) {
        this.refresh = refresh;
    }

    public void setFilePath(String filePath) {
        this.filePath = filePath;
    }

    // public static void main(String[] args) {
    // System.out.println(new
    // ReadXML(ReadXML.JUDGEMENT_BASIS_TYPE3).getTextContentByTagFromFile("D:\\test.xml",
    // "第一层节点"));
    // System.out.println(new
    // ReadXML().getTextContentByTagFromFile("D:\\test.xml", "第二层节点"));
    // XMLNode node = new
    // ReadXML(ReadXML.JUDGEMENT_BASIS_TYPE3).getXMLNodeByTagFromFile("D:\\test.xml",
    // "第一层节点");
    // System.out.println(node.getAttribute().get(0).getTagName());
    // System.out.println(node.getAttribute().get(0).getTextValue());

    // List<XMLNode> list = new ReadXML().getXMLNodeListByTagFromFile(
    // "D:\\test.xml", "第二层节点");
    // if (list != null && list.size() > 0) {
    // for (XMLNode nodeItem : list) {
    // System.out.println("节点名字：" + nodeItem.getTagName());
    // System.out.println("节点值：" + nodeItem.getTextValue());
    // List<XMLNode> attribute = nodeItem.getAttribute();
    // for (XMLNode item : attribute) {
    // System.out.println("属性名字：" + item.getTagName());
    // System.out.println("属性值：" + item.getTextValue());
    // }
    // }
    // }
    // }
}

package com.xxx.utility.xml;

import java.util.ArrayList;
import java.util.List;

/**
 * XML节点对象
 *
 * @author komojoemary
 * @version [版本号, 2010-11-17]
 */
public class XMLNode
{
    /**
     * 标签名字
     */
    private String tagName = null;

    /**
     * 文本值
     */
    private String textValue = null;

    /**
     * 属性列表
     */
    private List<XMLNode> attribute;

    /**
     * 子节点列表
     */
    private List<XMLNode> children;

    public XMLNode() {
    }

    /**
     * 构造函数
     *
     * @param tagName
     *            标签名字
     * @param textValue
     *            标签值
     */
    public XMLNode(String tagName, String textValue) {
        super();
        this.tagName = tagName;
        this.textValue = textValue;
    }

    /**
     * 构造函数
     *
     * @param tagName
     *            标签名字
     * @param textValue
     *            标签值
     * @param attributeName
     *            属性名字
     * @param attributeValue
     *            属性值
     */
    public XMLNode(String tagName, String textValue, String attributeName, String attributeValue) {
        super();
        this.tagName = tagName;
        this.textValue = textValue;
        if (attributeName != null && !attributeName.equals("")) {
            getAttribute().add(new XMLNode(attributeName, attributeValue));
        }
    }

    /**
     * 添加属性
     *
     * @param attribute
     *            属性节点对象
     */
    public void addAttribute(XMLNode attribute) {
        getAttribute().add(attribute);
    }

    /**
     * 添加子节点
     *
     * @param childNode
     *            子节点对象
     */
    public void addChildNode(XMLNode childNode) {
        getChildren().add(childNode);
    }

    /**
     * 添加子节点(返回添加的子节点对象)
     *
     * @param tagName
     *            标签名字
     * @param textValue
     *            标签值
     * @return XMLNode
     */
    public XMLNode addChildNode(String tagName, String textValue) {
        XMLNode node = new XMLNode(tagName, textValue);
        getChildren().add(node);
        return node;
    }

    public String getTagName() {
        return tagName;
    }

    public void setTagName(String tagName) {
        this.tagName = tagName;
    }

    public String getTextValue() {
        return textValue;
    }

    public void setTextValue(String textValue) {
        this.textValue = textValue;
    }

    public List<XMLNode> getAttribute() {
        if (attribute == null) {
            attribute = new ArrayList<XMLNode>();
        }
        return attribute;
    }

    public void setAttribute(List<XMLNode> attribute) {
        this.attribute = attribute;
    }

    public List<XMLNode> getChildren() {
        if (children == null) {
            children = new ArrayList<XMLNode>();
        }
        return children;
    }

    public void setChildren(List<XMLNode> children) {
        this.children = children;
    }

    /**
     * 是否叶子节点
     *
     * @return boolean
     */
    public boolean isLeaf() {
        return getChildren().size() == 0 ? true : false;
    }

}

package com.xxx.utility.xml;

import org.jdom.Element;

/**
 * xml解析自定义接口,用于比较复杂的xml解析,实现自己的特定业务逻辑
 *
 * @作者 komojoemary
 * @version [版本号, 2011-7-4]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public interface XmlParserHandler
{
    /**
     * 解析xml dom tree 节点
     *
     * @param nodeEl
     *            某个节点
     * @return 是否结束解析
     */
    public boolean parserElementNode(Element nodeEl);
}