1 はじめに
Java では、XML ファイルを解析するさまざまな方法があり、その中で最も一般的な 4 つの方法はおそらく DOM、SAX、JDOM、および DOM4J です。このうち、XML ファイルを解析する 2 つの方法である DOM と SAX には jdk 独自の API があるため、サードパーティの jar パッケージを追加で導入する必要はありません。それどころか、JDOM と DOM4J の解析メソッドはどちらもサードパーティのオープンソース プロジェクトであるため、これら 2 つのメソッドを使用して XML ファイルを解析する場合は、追加の関連 jar パッケージを導入する必要があります
(1) DOM
DOM は、プラットフォームや言語に依存しない方法で XML ドキュメントを表現するための公式 W3C 標準。 DOM は、開発者がツリー内の特定の情報を検索できるようにする、階層構造に編成されたノードまたは情報の集合です。この構造を分析するには、通常、作業を行う前にドキュメント全体をロードし、階層を構築する必要があります。そのため、DOM を使用して XML ファイルを解析する場合、パーサーは XML ファイル全体をメモリに読み込んで、後続のツリー構造を形成する必要があります。操作
利点: ドキュメントツリー全体がメモリ内にあるため、操作が簡単です。削除、変更、再配置などの操作をサポートします
欠点: ドキュメント全体をメモリに転送することは、時間とメモリの無駄です(無駄なノードを含む)。 XML が大きすぎると、メモリ オーバーフローの問題が発生しやすくなります
(2) SAX
XML ファイルを解析するときに DOM はファイル全体を一度に読み取る必要があるため、ファイルが大きすぎると多くの欠点が生じます, そこで、この問題を解決するために、イベント駆動型の解析手法である SAX では、パーサーが開始マーク、終了マーク、テキストを見つけたときに、コンテンツを上から下に連続してメモリにロードすることで XML ファイルを解析します。 、ドキュメント開始マーク、ドキュメント 終了フラグとその他の関連フラグが使用されると、これらのイベントのメソッドにカスタム コードを記述して取得したデータを保存するだけで、いくつかの対応するイベントがトリガーされます
利点:事前にドキュメント全体をロードする必要がありません。SAX 解析を使用して記述されたコードは、DOM 解析を使用して記述されたコードよりも少ないです
欠点: データが保存されない場合。 、データは失われます; from イベントではテキストのみを取得できますが、テキストがどの要素に属しているかはわかりません
(3) JDOM を使用して XML ファイルを解析することは、DOM を使用して XML ファイルを解析することと似ています。コードの観点から見ると、解析の考え方は似ています。 JDOM は、主に 2 つの点で DOM と異なります。 まず、JDOM はインターフェイスではなく具象クラスのみを使用します。これにより、いくつかの側面で API が簡素化されますが、柔軟性も制限されます。第 2 に、JDOM の API はコレクション クラスを広範囲に使用しているため、これらのクラスに慣れている Java 開発者は簡単に使用できます。 利点: オープン ソース プロジェクトであり、欠点: JDOM 自体にはパーサーが含まれていません。通常、入力 XML ドキュメントの解析と検証には SAX2 パーサーが使用されます
(4) DOM4J
DOM4J は、優れたパフォーマンス、強力な機能、そして非常に使いやすい、非常に優れた Java XML API であり、オープン ソース ソフトウェアでもあります。 。最近では、XML の読み書きに DOM4J を使用する Java ソフトウェアが増えていることがわかります
DOM4J はパフォーマンスとコード作成の点で非常に強力であるため、特に XML ファイルが大きい場合には、DOM4J を使用して解析することもありますより高い効率。したがって、日常生活で XML ファイルを解析する必要がある場合は、可能な限り DOM4J を使用して解析することを検討することをお勧めします。もちろん、ファイルが非常に小さい場合は、DOM を使用して解析することも可能です
利点:
オープンソース プロジェクト
DOM4J は JDOM のインテリジェントなブランチであり、基本的な XML ドキュメント以上の機能を必要とする機能が組み込まれています
優れたパフォーマンスと柔軟性 優れた使いやすさとその他の機能
XML ファイルの 2 番目の DOM 解析
(1) コードを作成してテストする前に、XML ファイルを準備する必要があります。ここで用意したファイルは、demo1.xml です。
demo1.xml:
<?xml version="1.0" encoding="UTF-8" ?>
<employees>
<user id="1">
<name>zifangsky</name>
<age>10</age>
<sex>male</sex>
<contact>https://www.zifangsky.cn</contact>
</user>
<user id="2">
<name>admin</name>
<age>20</age>
<sex>male</sex>
<contact>https://www.tar.pub</contact>
</user>
</employees>(2) コード例:
package cn.zifangsky.xml;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class DomParseTest {
public static void main(String[] args) {
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
try {
DocumentBuilder dBuilder = dFactory.newDocumentBuilder();
// 加载一个xml文件
Document document = dBuilder
.parse("src/cn/zifangsky/xml/demo1.xml");
// 获取user节点集合
NodeList userList = document.getElementsByTagName("user");
int userListLength = userList.getLength();
System.out.println("此xml文件一共有" + userListLength + "个'user'节点\n");
// 遍历
for (int i = 0; i < userListLength; i++) {
// 通过item方法获取指定的节点
Node userNode = userList.item(i);
// *********************解析属性***********************
// 获取该节点的所有属性值，如：id="1"
NamedNodeMap userAttributes = userNode.getAttributes();
System.out.println("'user'节点" + i + "有"
+ userAttributes.getLength() + "个属性：");
/**
* 1 在不清楚有哪些属性的情况下可以遍历所有属性，
* 并获取每个属性对应的属性名和属性值
* */
for (int j = 0; j < userAttributes.getLength(); j++) {
// 'user'节点的每个属性组成的节点
Node attrnNode = userAttributes.item(j);
System.out.println("属性" + j + "： 属性名： "
+ attrnNode.getNodeName() + " ，属性值： "
+ attrnNode.getNodeValue());
}
/**
* 2 在知道有哪些属性值的情况下，可以获取指定属性名的属性值
* */
Element userElement = (Element) userList.item(i);
System.out.println("属性为'id'的对应值是： "
+ userElement.getAttribute("id"));
// *********************解析子节点************************
NodeList childNodes = userNode.getChildNodes();
System.out.println("\n该节点一共有" + childNodes.getLength()
+ "个子节点，分别是：");
// 遍历子节点
for (int k = 0; k < childNodes.getLength(); k++) {
Node childNode = childNodes.item(k);
// 从输出结果可以看出，每行后面的换行符也被当做了一个节点，因此是：4+5=9个子节点
// System.out.println("节点名： " + childNode.getNodeName() +
// "，节点值： " + childNode.getTextContent());
// 仅取出子节点中的'ELEMENT_NODE'，换行符组成的Node是'TEXT_NODE'
if (childNode.getNodeType() == Node.ELEMENT_NODE) {
// System.out.println("节点名： " + childNode.getNodeName()
// + "，节点值： " + childNode.getTextContent());
// 最低一层是文本节点，节点名是'#text'
System.out.println("节点名： " + childNode.getNodeName()
+ "，节点值： "
+ childNode.getFirstChild().getNodeValue());
}
}
System.out.println("***************************");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}上記のコードからわかるように、DOM を使用して XML ファイルを解析する場合、通常は次の手順を実行する必要があります:
ドキュメント ビルダーを作成するファクトリ(DocumentBuilderFactory)インスタンス
上記により、DocumentBuilderFactoryは新しいドキュメントビルダー(DocumentBuilder)を生成します
上記のDocumentBuilderを使用してXMLファイルを解析(解析)し、ドキュメントツリー(Document)を生成します
指定されたノードを取得しますドキュメントを通じて ID を取得するか、ノード名に基づいてすべての修飾ノードを取得します ノードセット
は各ノードを走査し、ノードの属性、属性値、およびその他の関連パラメーターを取得できます
ノードにまだ子がある場合ノードがある場合は、上記の方法
(3) に従って、そのすべての子ノードを引き続き走査できます。 コード出力は次のとおりです:
此xml文件一共有2个'user'节点 'user'节点0有1个属性： 属性0： 属性名： id ，属性值： 1 属性为'id'的对应值是： 1 该节点一共有9个子节点，分别是： 节点名： name，节点值： zifangsky 节点名： age，节点值： 10 节点名： sex，节点值： male 节点名： contact，节点值： https://www.zifangsky.cn *************************** 'user'节点1有1个属性： 属性0： 属性名： id ，属性值： 2 属性为'id'的对应值是： 2 该节点一共有9个子节点，分别是： 节点名： name，节点值： admin 节点名： age，节点值： 20 节点名： sex，节点值： male 节点名： contact，节点值： https://www.tar.pub ***************************
3 つの SAX 解析済み XML ファイル
在进行本次测试时，并不引入其他XML文件，仍然使用上面的demo1.xml文件
由于SAX解析XML文件跟DOM不同，它并不是将整个文档都载入到内存中。解析器在解析XML文件时，通过逐步载入文档，从上往下一行行的解析XML文件，在碰到文档开始标志、节点开始标志、文本文档、节点结束标志、文档结束标志时进行对应的事件处理。因此，我们首先需要构造一个这样的解析处理器来申明：当解析到这些标志时，我们需要进行怎样的自定义处理
（1）解析处理器SAXParseHandler.java：
package cn.zifangsky.xml;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class SAXParseHandler extends DefaultHandler {
/**
* 用来遍历XML文件的开始标签
* */
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
super.startElement(uri, localName, qName, attributes);
//解析'user'元素的属性值
// if(qName.equals("user"))
// System.out.println("'user'元素的id属性值是：" + attributes.getValue("id"));
//遍历并打印元素的属性
int length = attributes.getLength();
if(length > 0){
System.out.println("元素'" + qName + "'的属性是：");
for(int i=0;i<length;i++){
System.out.println(" 属性名：" + attributes.getQName(i) + "，属性值： " + attributes.getValue(i));
}
System.out.println();
}
System.out.print("<" + qName + ">");
}
/**
* 用来遍历XML文件的结束标签
* */
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
super.endElement(uri, localName, qName);
System.out.println("<" + qName + "/>");
}
/**
* 文本内容
* */
public void characters(char[] ch, int start, int length)
throws SAXException {
super.characters(ch, start, length);
String value = new String(ch, start, length).trim();
if(!value.equals(""))
System.out.print(value);
}
/**
* 用来标识解析开始
* */
@Override
public void startDocument() throws SAXException {
System.out.println("SAX解析开始");
super.startDocument();
}
/**
* 用来标识解析结束
* */
@Override
public void endDocument() throws SAXException {
System.out.println("SAX解析结束");
super.endDocument();
}
}关于上面代码的一些含义我这里就不再做解释了，可以自行参考注释内容
（2）测试：
SAXParseTest.java文件：
package cn.zifangsky.xml;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
public class SAXParseTest {
public static void main(String[] args) {
SAXParserFactory sFactory = SAXParserFactory.newInstance();
try {
SAXParser saxParser = sFactory.newSAXParser();
//创建自定义的SAXParseHandler解析类
SAXParseHandler saxParseHandler = new SAXParseHandler();
saxParser.parse("src/cn/zifangsky/xml/demo1.xml", saxParseHandler);
} catch (Exception e) {
e.printStackTrace();
}
}
}从上面的代码可以看出，使用SAX解析XML文件时，一共传递进去了两个参数，分别是：XML文件路径和前面定义的解析处理器。有了具体的XML文件以及对应的处理器来处理对应的标志事情，因此SAX这种解析方式就可以顺利地进行解析工作了
（3）上面测试的输出如下：
SAX解析开始
<employees>元素'user'的属性是：
属性名：id，属性值： 1
<user><name>zifangsky<name/>
<age>10<age/>
<sex>male<sex/>
<contact>https://www.zifangsky.cn<contact/>
<user/>
元素'user'的属性是：
属性名：id，属性值： 2
<user><name>admin<name/>
<age>20<age/>
<sex>male<sex/>
<contact>https://www.tar.pub<contact/>
<user/>
<employees/>
SAX解析结束四 JDOM解析XML文件
跟前面两种解析方式不同的是，使用JDOM来解析XML文件需要下载额外的jar包
（1）下载jar包并导入到项目中：
下载地址：http://www.jdom.org/downloads/index.html
目前最新版本是：JDOM 2.0.6
然后将下载得到的“jdom-2.0.6.jar”文件导入到测试项目中
注：关于如何在一个Java项目中导入额外的jar，这里将不多做解释，不太会的童鞋可以自行百度
（2）测试代码：
JDOMTest.java：
package cn.zifangsky.xml;
import java.util.List;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;
public class JDOMTest {
/**
* @param args
*/
public static void main(String[] args) {
SAXBuilder saxBuilder = new SAXBuilder();
try {
Document document = saxBuilder.build("src/cn/zifangsky/xml/demo1.xml");
//获取XML文件的根节点
Element rootElement = document.getRootElement();
// System.out.println(rootElement.getName());
List<Element> usersList = rootElement.getChildren(); //获取子节点
for(Element u : usersList){
// List<Attribute> attributes = u.getAttributes();
// for(Attribute attribute : attributes){
// System.out.println("属性名：" + attribute.getName() + "，属性值：" + attribute.getValue());
// }
System.out.println("'id'的值是: " + u.getAttributeValue("id"));
}
}catch (Exception e) {
e.printStackTrace();
}
}
}从上面的代码可以看出，使用JDOM来解析XML文件，主要需要做以下几个步骤：
新建一个SAXBuilder
通过SAXBuilder的build方法传入一个XML文件的路径得到Document
通过Document的getRootElement方法获取根节点
通过getChildren方法获取根节点的所有子节点
然后是遍历每个子节点，获取属性、属性值、节点名、节点值等内容
如果该节点也有子节点，然后同样可以通过getChildren方法获取该节点的子节点
后面的步骤跟上面一样，不断递归到文本节点截止
（3）上面测试的输出如下：
'id'的值是: 1 'id'的值是: 2
五 DOM4J解析XML文件
jar包下载地址：https://sourceforge.net/projects/dom4j/files/
同样，在使用DOM4J解析XML文件时需要往项目中引入“dom4j-1.6.1.jar”文件
（1）一个简单实例：
i）DOM4JTest.java：
package cn.zifangsky.xml;
import java.io.File;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class DOM4JTest {
public static void main(String[] args) {
SAXReader reader = new SAXReader();
try {
Document document = reader.read(new File("src/cn/zifangsky/xml/demo1.xml"));
//获取XML文件的根节点
Element rootElement = document.getRootElement();
System.out.println(rootElement.getName());
//通过elementIterator方法获取迭代器
Iterator<Element> iterator = rootElement.elementIterator();
//遍历
while(iterator.hasNext()){
Element user = iterator.next();
//获取属性并遍历
List<Attribute> aList = user.attributes();
for(Attribute attribute : aList){
System.out.println("属性名：" + attribute.getName() + "，属性值：" + attribute.getValue());
}
//子节点
Iterator<Element> childList = user.elementIterator();
while(childList.hasNext()){
Element child = childList.next();
// System.out.println(child.getName() + " : " + child.getTextTrim());
System.out.println(child.getName() + " : " + child.getStringValue());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}从上面的代码可以看出，跟前面的JDOM解析方式流程是差不多的，并且关键地方也有注释，因此这里就不多做解释了
ii）上面的代码输出如下：
employees 属性名：id，属性值：1 name : zifangsky age : 10 sex : male contact : https://www.zifangsky.cn 属性名：id，属性值：2 name : admin age : 20 sex : male contact : https://www.tar.pub
（2）将XML文件解析成Java对象：
i）为了方便测试，这里准备一个新的XML文件：
demo2.xml：
<?xml version="1.0" encoding="UTF-8" ?>
<user id="2">
<name>zifangsky</name>
<age>100</age>
<sex>男</sex>
<contact>https://www.zifangsky.cn</contact>
<ownPet id="1">旺财</ownPet>
<ownPet id="2">九头猫妖</ownPet>
</user>ii）同时准备一个Java实体类，恰好跟上面的XML文件中的属性相对应：
User.java：
package cn.zifangsky.xml;
import java.util.List;
public class User {
private String name;
private String sex;
private int age;
private String contact;
private List<String> ownPet;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getContact() {
return contact;
}
public void setContact(String contact) {
this.contact = contact;
}
protected List<String> getOwnPet() {
return ownPet;
}
protected void setOwnPet(List<String> ownPet) {
this.ownPet = ownPet;
}
@Override
public String toString() {
return "User [name=" + name + ", sex=" + sex + ", age=" + age
+ ", contact=" + contact + ", ownPet=" + ownPet + "]";
}
}iii）测试代码：
XMLtoJava.java：
package cn.zifangsky.xml;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class XMLtoJava {
public User parseXMLtoJava(String xmlPath){
User user = new User();
List<String> ownPet = new ArrayList<String>();
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(new File(xmlPath));
Element rootElement = document.getRootElement(); //获取根节点
List<Element> children = rootElement.elements(); //获取根节点的子节点
//遍历
for(Element child : children){
String elementName = child.getName(); //节点名
String elementValue = child.getStringValue(); //节点值
switch (elementName) {
case "name":
user.setName(elementValue);
break;
case "sex":
user.setSex(elementValue);
break;
case "age":
user.setAge(Integer.valueOf(elementValue));
break;
case "contact":
user.setContact(elementValue);
break;
case "ownPet":
ownPet.add(elementValue);
break;
default:
break;
}
}
user.setOwnPet(ownPet);
} catch (Exception e) {
e.printStackTrace();
}
return user;
}
public static void main(String[] args) {
XMLtoJava demo = new XMLtoJava();
User user = demo.parseXMLtoJava("src/cn/zifangsky/xml/demo2.xml");
System.out.println(user);
}
}经过前面的分析之后，上面这个代码也是很容易理解的：通过遍历节点，如果节点名跟Java类中的某个属性名相对应，那么就将节点值赋值给该属性
iv）上面的代码输出如下：
User [name=zifangsky, sex=男, age=100, contact=https://www.zifangsky.cn, ownPet=[旺财, 九头猫妖]]
（3）解析一个XML文件并尽可能原样输出：
DOM4JTest2:
package cn.zifangsky.xml;
import java.io.File;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class DOM4JTest2 {
/**
* 解析XML文件并尽可能原样输出
*
* @param xmlPath
* 待解析的XML文件路径
* @return null
* */
public void parse(String xmlPath) {
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(new File(xmlPath));
Element rootElement = document.getRootElement();
print(rootElement, 0);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 打印一个XML节点的详情
*
* @param element
* 一个XML节点
* @param level
* 用于判断xml节点前缩进多少的标识，每深入一层则多输出4个空格
* @return null
* */
public void print(Element element, int level) {
List<Element> elementList = element.elements(); // 当前节点的子节点List
// 空格
StringBuffer spacebBuffer = new StringBuffer("");
for (int i = 0; i < level; i++)
spacebBuffer.append(" ");
String space = spacebBuffer.toString();
// 输出开始节点及其属性值
System.out.print(space + "<" + element.getName());
List<Attribute> attributes = element.attributes();
for (Attribute attribute : attributes)
System.out.print(" " + attribute.getName() + "=\""
+ attribute.getText() + "\"");
// 有子节点
if (elementList.size() > 0) {
System.out.println(">");
// 遍历并递归
for (Element child : elementList) {
print(child, level + 1);
}
// 输出结束节点
System.out.println(space + "</" + element.getName() + ">");
} else {
// 如果节点没有文本则简化输出
if (element.getStringValue().trim().equals(""))
System.out.println(" />");
else
System.out.println(">" + element.getStringValue() + "</"
+ element.getName() + ">");
}
}
public static void main(String[] args) {
DOM4JTest2 test2 = new DOM4JTest2();
test2.parse("src/cn/zifangsky/xml/demo3.xml");
}
}这段代码同样没有什么新的东西，原理就是利用递归来不断进行解析输出，注意一下不同层次的节点的缩进即可。刚开始测试时建议用一些结构比较简单的代码，如上面的demo1.xml和demo2.xml文件。在测试没问题时可以选择一些复杂的XML文件来测试是否能够正常输出，比如：
demo3.xml：
<?xml version="1.0" encoding="UTF-8"?>
<application xmlns="http://wadl.dev.java.net/2009/02"
xmlns:xs="http://www.w3.org/2001/XMLSchema">
<grammars />
<resources base="http://localhost:9080/Demo/services/json/checkCode">
<resource path="/">
<resource path="addCheckCode">
<method name="POST">
<request>
<representation mediaType="application/octet-stream" />
</request>
<response>
<representation mediaType="application/xml">
<param name="result" style="plain" type="xs:int" />
</representation>
<representation mediaType="application/json">
<param name="result" style="plain" type="xs:int" />
</representation>
</response>
</method>
</resource>
<resource path="findCheckCodeByProfileId">
<method name="POST">
<request>
<representation mediaType="application/octet-stream">
<param name="request" style="plain" type="xs:long" />
</representation>
</request>
<response>
<representation mediaType="application/xml" />
<representation mediaType="application/json" />
</response>
</method>
</resource>
</resource>
</resources>
</application>为什么我在标题上说的是尽可能原样输出，其原因就是上面那段解析代码在碰到下面这种XML节点时，输出就不一样了：
<dc:creator><![CDATA[admin]]></dc:creator> <category><![CDATA[运维]]></category> <category><![CDATA[zabbix]]></category> <category><![CDATA[端口]]></category>
这段XML文档节点最后输出如下：
<creator>admin</creator> <category>运维</category> <category>zabbix</category> <category>端口</category>
![[Web フロントエンド] Node.js クイック スタート](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
