Java 구문 분석 xml의 샘플 코드 요약

[소개]

현재 Java에서 XML을 구문 분석하는 데 사용되는 기술은 많이 있습니다. 주류에는 DOM, SAX, JDOM 및 다음은 주로 이 네 가지 XML 문서 구문 분석 기술의 사용, 장점과 단점 및 성능 테스트를 소개합니다.

1. [기본 지식 - 문해력]

Sax와 dom은 xml 문서를 구문 분석하는 두 가지 방법입니다(구체적인 구현 없음, 단지 interface ), 따라서 그들만으로는 xml 문서를 구문 분석할 수 없습니다. jaxp는 sax 및 dom 인터페이스를 추가로 캡슐화하고 DomcumentBuilderFactory/DomcumentBuilder 및 SAXParserFactory /SAXParser(기본값은 xerces 인터프리터 사용)를 제공하는 api입니다.

2. [DOM, SAX, JDOM, DOM4j에 대한 간단한 소개]

1. Object Model) ]
W3C에서 제공하는 XML 문서 전체를 읽어오는 인터페이스 Memory , 각 노드(Node)를 운영하기 위한 DOM 트리를 구축합니다.
샘플 코드:

<?xml version="1.0" encoding="UTF-8"?>  
<university name="pku">  
    <college name="c1">  
        <class name="class1">  
            <student name="stu1" sex=&#39;male&#39; age="21" />  
            <student name="stu2" sex=&#39;female&#39; age="20" />  
            <student name="stu3" sex=&#39;female&#39; age="20" />  
        </class>  
        <class name="class2">  
            <student name="stu4" sex=&#39;male&#39; age="19" />  
            <student name="stu5" sex=&#39;female&#39; age="20" />  
            <student name="stu6" sex=&#39;female&#39; age="21" />  
        </class>  
    </college>  
    <college name="c2">  
        <class name="class3">  
            <student name="stu7" sex=&#39;male&#39; age="20" />  
        </class>  
    </college>  
    <college name="c3">  
    </college>  
</university>

text.xml은 다음 코드에서 사용됩니다. (이 문서는 src 경로에 위치하며 클래스에서 컴파일됩니다. 경로(아래)는 모두 xml 문서를 참조합니다.

package test.xml;  
  
import java.io.File;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import javax.xml.parsers.ParserConfigurationException;  
import javax.xml.transform.Transformer;  
import javax.xml.transform.TransformerConfigurationException;  
import javax.xml.transform.TransformerException;  
import javax.xml.transform.TransformerFactory;  
import javax.xml.transform.dom.DOMSource;  
import javax.xml.transform.stream.StreamResult;  
  
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
import org.w3c.dom.Node;  
import org.w3c.dom.NodeList;  
import org.w3c.dom.Text;  
import org.xml.sax.SAXException;  
  
/** 
 * dom读写xml 
 * @author whwang 
 */  
public class TestDom {  
      
    public static void main(String[] args) {  
        read();  
        //write();   
    }  
      
    public static void read() {  
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
        try {  
            DocumentBuilder builder = dbf.newDocumentBuilder();  
            InputStream in = TestDom.class.getClassLoader().getResourceAsStream("test.xml");  
            Document doc = builder.parse(in);  
            // root <university>   
            Element root = doc.getDocumentElement();  
            if (root == null) return;  
            System.err.println(root.getAttribute("name"));  
            // all college node   
            NodeList collegeNodes = root.getChildNodes();  
            if (collegeNodes == null) return;  
            for(int i = 0; i < collegeNodes.getLength(); i++) {  
                Node college = collegeNodes.item(i);  
                if (college != null && college.getNodeType() == Node.ELEMENT_NODE) {  
                    System.err.println("\t" + college.getAttributes().getNamedItem("name").getNodeValue());  
                    // all class node   
                    NodeList classNodes = college.getChildNodes();  
                    if (classNodes == null) continue;  
                    for (int j = 0; j < classNodes.getLength(); j++) {  
                        Node clazz = classNodes.item(j);  
                        if (clazz != null && clazz.getNodeType() == Node.ELEMENT_NODE) {  
                            System.err.println("\t\t" + clazz.getAttributes().getNamedItem("name").getNodeValue());  
                            // all student node   
                            NodeList studentNodes = clazz.getChildNodes();  
                            if (studentNodes == null) continue;  
                            for (int k = 0; k < studentNodes.getLength(); k++) {  
                                Node student = studentNodes.item(k);  
                                if (student != null && student.getNodeType() == Node.ELEMENT_NODE) {  
                                    System.err.print("\t\t\t" + student.getAttributes().getNamedItem("name").getNodeValue());  
                                    System.err.print(" " + student.getAttributes().getNamedItem("sex").getNodeValue());  
                                    System.err.println(" " + student.getAttributes().getNamedItem("age").getNodeValue());  
                                }  
                            }  
                        }  
                    }  
                }  
            }  
        } catch (ParserConfigurationException e) {  
            e.printStackTrace();  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (SAXException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
          
    }  
      
    public static void write() {  
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
        try {  
            DocumentBuilder builder = dbf.newDocumentBuilder();  
            InputStream in = TestDom.class.getClassLoader().getResourceAsStream("test.xml");  
            Document doc = builder.parse(in);  
            // root <university>   
            Element root = doc.getDocumentElement();  
            if (root == null) return;  
            // 修改属性   
            root.setAttribute("name", "tsu");  
            NodeList collegeNodes = root.getChildNodes();  
            if (collegeNodes != null) {  
                for (int i = 0; i <collegeNodes.getLength() - 1; i++) {  
                    // 删除节点   
                    Node college = collegeNodes.item(i);  
                    if (college.getNodeType() == Node.ELEMENT_NODE) {  
                        String collegeName = college.getAttributes().getNamedItem("name").getNodeValue();  
                        if ("c1".equals(collegeName) || "c2".equals(collegeName)) {  
                            root.removeChild(college);  
                        } else if ("c3".equals(collegeName)) {  
                            Element newChild = doc.createElement("class");  
                            newChild.setAttribute("name", "c4");  
                            college.appendChild(newChild);  
                        }  
                    }  
                }  
            }  
            // 新增节点   
            Element addCollege = doc.createElement("college");  
            addCollege.setAttribute("name", "c5");  
            root.appendChild(addCollege);  
            Text text = doc.createTextNode("text");  
            addCollege.appendChild(text);  
              
            // 将修改后的文档保存到文件   
            TransformerFactory transFactory = TransformerFactory.newInstance();  
            Transformer transFormer = transFactory.newTransformer();  
            DOMSource domSource = new DOMSource(doc);  
            File file = new File("src/dom-modify.xml");  
            if (file.exists()) {  
                file.delete();  
            }  
            file.createNewFile();  
            FileOutputStream out = new FileOutputStream(file);           
            StreamResult xmlResult = new StreamResult(out);  
            transFormer.transform(domSource, xmlResult);  
            System.out.println(file.getAbsolutePath());  
        } catch (ParserConfigurationException e) {  
            e.printStackTrace();  
        } catch (SAXException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (TransformerConfigurationException e) {  
            e.printStackTrace();  
        } catch (TransformerException e) {  
            e.printStackTrace();  
        }  
    }  
}

코드를 조금만 수정하면 더 간결해질 수 있습니다. 자식 노드가 있는지 확인하기 위해 매번 작성할 필요가 없습니다.

2. [SAX(Simple API for XML)]
SAX는 전체 문서를 메모리에 로드할 필요가 없으며, 이벤트를 기반으로 (관찰자모드) API를 구동합니다. SAX는 구문 분석 엔터티 이벤트, DTD 처리 이벤트, 텍스트 처리 이벤트 및 처리 오류 이벤트를 각각 모니터링하는 데 사용되는 EntityResolver, DTDHandler, ContentHandler 및 ErrorHandler 인터페이스를 제공합니다. AWT와 유사하게 이 네 가지 인터페이스에 대한 기본 클래스 DefaultHandler도 제공합니다(여기서 기본 구현은 실제로 빈 메소드입니다). 일반적으로 DefaultHandler를 상속하고 관심 있는 이벤트를 다시 작성하면 됩니다. 샘플 코드:

package test.xml;  
  
import java.io.IOException;  
import java.io.InputStream;  
  
import javax.xml.parsers.ParserConfigurationException;  
import javax.xml.parsers.SAXParser;  
import javax.xml.parsers.SAXParserFactory;  
  
import org.xml.sax.Attributes;  
import org.xml.sax.InputSource;  
import org.xml.sax.Locator;  
import org.xml.sax.SAXException;  
import org.xml.sax.SAXParseException;  
import org.xml.sax.helpers.DefaultHandler;  
  
/** 
 * 
 * @author whwang 
 */  
public class TestSAX {  
  
    public static void main(String[] args) {  
        read();  
        write();  
    }  
      
    public static void read() {  
        try {  
            SAXParserFactory factory = SAXParserFactory.newInstance();  
            SAXParser parser = factory.newSAXParser();  
            InputStream in = TestSAX.class.getClassLoader().getResourceAsStream("test.xml");  
            parser.parse(in, new MyHandler());  
        } catch (ParserConfigurationException e) {  
            e.printStackTrace();  
        } catch (SAXException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
      
    public static void write() {  
        System.err.println("纯SAX对于写操作无能为力");  
    }  
      
}  
  
// 重写对自己感兴趣的事件处理方法   
class MyHandler extends DefaultHandler {  
  
    @Override  
    public InputSource resolveEntity(String publicId, String systemId)  
            throws IOException, SAXException {  
        return super.resolveEntity(publicId, systemId);  
    }  
  
    @Override  
    public void notationDecl(String name, String publicId, String systemId)  
            throws SAXException {  
        super.notationDecl(name, publicId, systemId);  
    }  
  
    @Override  
    public void unparsedEntityDecl(String name, String publicId,  
            String systemId, String notationName) throws SAXException {  
        super.unparsedEntityDecl(name, publicId, systemId, notationName);  
    }  
  
    @Override  
    public void setDocumentLocator(Locator locator) {  
        super.setDocumentLocator(locator);  
    }  
  
    @Override  
    public void startDocument() throws SAXException {  
        System.err.println("开始解析文档");  
    }  
  
    @Override  
    public void endDocument() throws SAXException {  
        System.err.println("解析结束");  
    }  
  
    @Override  
    public void startPrefixMapping(String prefix, String uri)  
            throws SAXException {  
        super.startPrefixMapping(prefix, uri);  
    }  
  
    @Override  
    public void endPrefixMapping(String prefix) throws SAXException {  
        super.endPrefixMapping(prefix);  
    }  
  
    @Override  
    public void startElement(String uri, String localName, String qName,  
            Attributes attributes) throws SAXException {  
        System.err.print("Element: " + qName + ", attr: ");  
        print(attributes);  
    }  
  
    @Override  
    public void endElement(String uri, String localName, String qName)  
            throws SAXException {  
        super.endElement(uri, localName, qName);  
    }  
  
    @Override  
    public void characters(char[] ch, int start, int length)  
            throws SAXException {  
        super.characters(ch, start, length);  
    }  
  
    @Override  
    public void ignorableWhitespace(char[] ch, int start, int length)  
            throws SAXException {  
        super.ignorableWhitespace(ch, start, length);  
    }  
  
    @Override  
    public void processingInstruction(String target, String data)  
            throws SAXException {  
        super.processingInstruction(target, data);  
    }  
  
    @Override  
    public void skippedEntity(String name) throws SAXException {  
        super.skippedEntity(name);  
    }  
  
    @Override  
    public void warning(SAXParseException e) throws SAXException {  
        super.warning(e);  
    }  
  
    @Override  
    public void error(SAXParseException e) throws SAXException {  
        super.error(e);  
    }  
  
    @Override  
    public void fatalError(SAXParseException e) throws SAXException {  
        super.fatalError(e);  
    }  
      
    private void print(Attributes attrs) {  
        if (attrs == null) return;  
        System.err.print("[");  
        for (int i = 0; i < attrs.getLength(); i++) {  
            System.err.print(attrs.getQName(i) + " = " + attrs.getValue(i));  
            if (i != attrs.getLength() - 1) {  
                System.err.print(", ");  
            }  
        }  
        System.err.println("]");  
    }  
}

3. [JDOM] JDOM은 다음과 매우 유사합니다. DOM은 XML을 처리하는 순수 JAVA API이며 API는 Collections 클래스를 광범위하게 사용하고 JDOM은 인터페이스 대신 구체적인 클래스만 사용합니다. JDOM 자체에는 파서가 포함되어 있지 않습니다. 일반적으로 SAX2 파서를 사용하여 입력 XML 문서를 구문 분석하고 검증합니다(이전에 구성된 DOM 표현을 입력으로 사용할 수도 있음). 여기에는 JDOM 표현을 SAX2 이벤트 스트림, DOM
모델 또는 XML 텍스트 문서 로 출력하는 변환기가 포함되어 있습니다. 예제 코드:

package test.xml;  
  
import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
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.XMLOutputter;  
  
/** 
 * JDom读写xml 
 * @author whwang 
 */  
public class TestJDom {  
    public static void main(String[] args) {  
        //read();   
        write();  
    }  
      
    public static void read() {  
        try {  
            boolean validate = false;  
            SAXBuilder builder = new SAXBuilder(validate);  
            InputStream in = TestJDom.class.getClassLoader().getResourceAsStream("test.xml");  
            Document doc = builder.build(in);  
            // 获取根节点 <university>   
            Element root = doc.getRootElement();  
            readNode(root, "");  
        } catch (JDOMException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
      
    @SuppressWarnings("unchecked")  
    public static void readNode(Element root, String prefix) {  
        if (root == null) return;  
        // 获取属性   
        List<Attribute> attrs = root.getAttributes();  
        if (attrs != null && attrs.size() > 0) {  
            System.err.print(prefix);  
            for (Attribute attr : attrs) {  
                System.err.print(attr.getValue() + " ");  
            }  
            System.err.println();  
        }  
        // 获取他的子节点   
        List<Element> childNodes = root.getChildren();  
        prefix += "\t";  
        for (Element e : childNodes) {  
            readNode(e, prefix);  
        }  
    }  
      
    public static void write() {  
        boolean validate = false;  
        try {  
            SAXBuilder builder = new SAXBuilder(validate);  
            InputStream in = TestJDom.class.getClassLoader().getResourceAsStream("test.xml");  
            Document doc = builder.build(in);  
            // 获取根节点 <university>   
            Element root = doc.getRootElement();  
            // 修改属性   
            root.setAttribute("name", "tsu");  
            // 删除   
            boolean isRemoved = root.removeChildren("college");  
            System.err.println(isRemoved);  
            // 新增   
            Element newCollege = new Element("college");  
            newCollege.setAttribute("name", "new_college");  
            Element newClass = new Element("class");  
            newClass.setAttribute("name", "ccccc");  
            newCollege.addContent(newClass);  
            root.addContent(newCollege);  
            XMLOutputter out = new XMLOutputter();  
            File file = new File("src/jdom-modify.xml");  
            if (file.exists()) {  
                file.delete();  
            }  
            file.createNewFile();  
            FileOutputStream fos = new FileOutputStream(file);  
            out.output(doc, fos);  
        } catch (JDOMException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
      
}

4. [DOM4j]dom4j는 현재 XML 구문 분석에서 최고이며(Hibernate 및 Sun의 JAXM도 XML 구문 분석에 dom4j를 사용함) 기본 XML 문서 표현 이상의 많은 기능을 포함합니다. , 통합
XPath 지원, XML 스키마 지원, 대규모 또는 스트리밍 문서에 대한 이벤트 기반 처리 포함 :

package test.xml;  
  
import java.io.File;  
import java.io.FileWriter;  
import java.io.IOException;  
import java.io.InputStream;  
import java.util.List;  
  
import org.dom4j.Attribute;  
import org.dom4j.Document;  
import org.dom4j.DocumentException;  
import org.dom4j.DocumentHelper;  
import org.dom4j.Element;  
import org.dom4j.ProcessingInstruction;  
import org.dom4j.VisitorSupport;  
import org.dom4j.io.SAXReader;  
import org.dom4j.io.XMLWriter;  
  
/** 
 * Dom4j读写xml 
 * @author whwang 
 */  
public class TestDom4j {  
    public static void main(String[] args) {  
        read1();  
        //read2();   
        //write();   
    }  
  
    public static void read1() {  
        try {  
            SAXReader reader = new SAXReader();  
            InputStream in = TestDom4j.class.getClassLoader().getResourceAsStream("test.xml");  
            Document doc = reader.read(in);  
            Element root = doc.getRootElement();  
            readNode(root, "");  
        } catch (DocumentException e) {  
            e.printStackTrace();  
        }  
    }  
      
    @SuppressWarnings("unchecked")  
    public static void readNode(Element root, String prefix) {  
        if (root == null) return;  
        // 获取属性   
        List<Attribute> attrs = root.attributes();  
        if (attrs != null && attrs.size() > 0) {  
            System.err.print(prefix);  
            for (Attribute attr : attrs) {  
                System.err.print(attr.getValue() + " ");  
            }  
            System.err.println();  
        }  
        // 获取他的子节点   
        List<Element> childNodes = root.elements();  
        prefix += "\t";  
        for (Element e : childNodes) {  
            readNode(e, prefix);  
        }  
    }  
      
    public static void read2() {  
        try {  
            SAXReader reader = new SAXReader();  
            InputStream in = TestDom4j.class.getClassLoader().getResourceAsStream("test.xml");  
            Document doc = reader.read(in);  
            doc.accept(new MyVistor());  
        } catch (DocumentException e) {  
            e.printStackTrace();  
        }  
    }  
      
    public static void write() {  
        try {  
            // 创建一个xml文档   
            Document doc = DocumentHelper.createDocument();  
            Element university = doc.addElement("university");  
            university.addAttribute("name", "tsu");  
            // 注释   
            university.addComment("这个是根节点");  
            Element college = university.addElement("college");  
            college.addAttribute("name", "cccccc");  
            college.setText("text");  
              
            File file = new File("src/dom4j-modify.xml");  
            if (file.exists()) {  
                file.delete();  
            }  
            file.createNewFile();  
            XMLWriter out = new XMLWriter(new FileWriter(file));  
            out.write(doc);  
            out.flush();  
            out.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  
  
class MyVistor extends VisitorSupport {  
    public void visit(Attribute node) {  
        System.out.println("Attibute: " + node.getName() + "="  
                + node.getValue());  
    }  
  
    public void visit(Element node) {  
        if (node.isTextOnly()) {  
            System.out.println("Element: " + node.getName() + "="  
                    + node.getText());  
        } else {  
            System.out.println(node.getName());  
        }  
    }  
  
    @Override  
    public void visit(ProcessingInstruction node) {  
        System.out.println("PI:" + node.getTarget() + " " + node.getText());  
    }  
}

三、【性能测试】

环境：AMD4400+ 2.0+GHz主频 JDK6.0
运行参数：-Xms400m -Xmx400m
xml文件大小：10.7M
结果：
DOM: >581297ms
SAX: 8829ms
JDOM: 581297ms
DOM4j: 5309ms
时间包括IO的，只是进行了简单的测试，仅供参考！！！！

四、【对比】

1、【DOM】
DOM是基于树的结构，通常需要加载整文档和构造DOM树，然后才能开始工作。
优点：
    a、由于整棵树在内存中，因此可以对xml文档随机访问
    b、可以对xml文档进行修改操作
    c、较sax，dom使用也更简单。
缺点：
    a、整个文档必须一次性解析完
    a、由于整个文档都需要载入内存，对于大文档成本高
2、【SAX】
SAX类似流媒体，它基于事件驱动的，因此无需将整个文档载入内存，使用者只需要监听自己感兴趣的事件即可。
优点：
    a、无需将整个xml文档载入内存，因此消耗内存少
    b、可以注册多个ContentHandler
缺点：
    a、不能随机的访问xml中的节点
    b、不能修改文档
3、【JDOM】
JDOM是纯Java的处理XML的API，其API中大量使用Collections类，
优点：
    a、DOM方式的优点
    b、具有SAX的Java规则
缺点
    a、DOM方式的缺点
4、【DOM4J】
这4中xml解析方式中，最优秀的一个，集易用和性能于一身。

五、【小插曲XPath】

XPath 是一门在 XML 文档中查找信息的语言， 可用来在 XML 文档中对元素和属性进行遍历。XPath 是 W3C XSLT 标准的主要元素，并且 XQuery 和 XPointer 同时被构建于 XPath 表达之上。因此，对 XPath 的理解是很多高级 XML 应用的基础。
XPath非常类似对数据库操作的SQL语言，或者说JQuery，它可以方便开发者抓起文档中需要的东西。（dom4j也支持xpath）
示例代码：

package test.xml;  
  
import java.io.IOException;  
import java.io.InputStream;  
  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import javax.xml.parsers.ParserConfigurationException;  
import javax.xml.xpath.XPath;  
import javax.xml.xpath.XPathConstants;  
import javax.xml.xpath.XPathExpression;  
import javax.xml.xpath.XPathExpressionException;  
import javax.xml.xpath.XPathFactory;  
  
import org.w3c.dom.Document;  
import org.w3c.dom.NodeList;  
import org.xml.sax.SAXException;  
  
public class TestXPath {  
  
    public static void main(String[] args) {  
        read();  
    }  
      
    public static void read() {  
        try {  
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
            DocumentBuilder builder = dbf.newDocumentBuilder();  
            InputStream in = TestXPath.class.getClassLoader().getResourceAsStream("test.xml");  
            Document doc = builder.parse(in);  
            XPathFactory factory = XPathFactory.newInstance();  
            XPath xpath = factory.newXPath();  
            // 选取所有class元素的name属性   
            // XPath语法介绍： http://w3school.com.cn/xpath/   
            XPathExpression expr = xpath.compile("//class/@name");  
            NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);  
            for (int i = 0; i < nodes.getLength(); i++) {  
                System.out.println("name = " + nodes.item(i).getNodeValue());  
                    }  
        } catch (XPathExpressionException e) {  
            e.printStackTrace();  
        } catch (ParserConfigurationException e) {  
            e.printStackTrace();  
        } catch (SAXException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
      
}

六、【补充】

注意4种解析方法对TextNode（文本节点）的处理：

1、在使用DOM时，调用node.getChildNodes()获取该节点的子节点，文本节点也会被当作一个Node来返回，如：

<?xml version="1.0" encoding="UTF-8"?>  
<university name="pku">  
    <college name="c1">  
        <class name="class1">  
            <student name="stu1" sex=&#39;male&#39; age="21" />  
            <student name="stu2" sex=&#39;female&#39; age="20" />  
            <student name="stu3" sex=&#39;female&#39; age="20" />  
        </class>  
    </college>  
</university>

package test.xml;  
  
import java.io.FileNotFoundException;  
import java.io.IOException;  
import java.io.InputStream;  
import java.util.Arrays;  
  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import javax.xml.parsers.ParserConfigurationException;  
  
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
import org.w3c.dom.Node;  
import org.w3c.dom.NodeList;  
import org.xml.sax.SAXException;  
  
/** 
 * dom读写xml 
 * @author whwang 
 */  
public class TestDom2 {  
      
    public static void main(String[] args) {  
        read();  
    }  
      
    public static void read() {  
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
        try {  
            DocumentBuilder builder = dbf.newDocumentBuilder();  
            InputStream in = TestDom2.class.getClassLoader().getResourceAsStream("test.xml");  
            Document doc = builder.parse(in);  
            // root <university>   
            Element root = doc.getDocumentElement();  
            if (root == null) return;  
//          System.err.println(root.getAttribute("name"));   
            // all college node   
            NodeList collegeNodes = root.getChildNodes();  
            if (collegeNodes == null) return;  
            System.err.println("university子节点数：" + collegeNodes.getLength());  
            System.err.println("子节点如下：");  
            for(int i = 0; i < collegeNodes.getLength(); i++) {  
                Node college = collegeNodes.item(i);  
                if (college == null) continue;  
                if (college.getNodeType() == Node.ELEMENT_NODE) {  
                    System.err.println("\t元素节点：" + college.getNodeName());  
                } else if (college.getNodeType() == Node.TEXT_NODE) {  
                    System.err.println("\t文本节点：" + Arrays.toString(college.getTextContent().getBytes()));  
                }  
            }  
        } catch (ParserConfigurationException e) {  
            e.printStackTrace();  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (SAXException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
          
    }  
}

输出的结果是：

university子节点数：3  
子节点如下：  
    文本节点：[10, 9]  
    元素节点：college  
    文本节点：[10]

其中\n的ASCII码为10，\t的ASCII码为9。结果让人大吃一惊，university的子节点数不是1，也不是2，而是3，这3个子节点都是谁呢？为了看得更清楚点，把xml文档改为：

<?xml version="1.0" encoding="UTF-8"?>  
<university name="pku">11  
    <college name="c1">  
        <class name="class1">  
            <student name="stu1" sex=&#39;male&#39; age="21" />  
            <student name="stu2" sex=&#39;female&#39; age="20" />  
            <student name="stu3" sex=&#39;female&#39; age="20" />  
        </class>  
    </college>22  
</university>

还是上面的程序，输出结果为：

university子节点数：3  
子节点如下：  
    文本节点：[49, 49, 10, 9]  
    元素节点：college  
    文本节点：[50, 50, 10]

其中数字1的ASCII码为49，数字2的ASCII码为50。

2、使用SAX来解析同DOM，当你重写它的public void characters(char[] ch, int start, int length)方法时，你就能看到。

3、JDOM，调用node.getChildren()只返回子节点，不包括TextNode节点（不管该节点是否有Text信息）。如果要获取该节点的Text信息，可以调用node.getText()方法，该方法返回节点的Text信息，也包括\n\t等特殊字符。

4、DOM4j同JDOM

위 내용은 Java 구문 분석 xml의 샘플 코드 요약의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!