XML,即可扩展标记语言(Extensible Markup Language),标准通用标记语言的子集,一种用于标记电子文件使其具有结构性的标记语言。它可以用来标记数据、定义数据类型,是一种允许用户对自己的标记语言进行定义的源语言。它非常适合万维网传输,提供统一的方法描述和交换独立于应用程序或供应商的结构化数据。
- XML是一种标记语言,类似HTML
- XML设计宗旨是传输数据,而非显示数据
- XML标签没有被预定义,需要自行定义标签
- XML被设计为具有自我描述性
- XML是W3C的推荐标准
XML解析方法分为5种:1、DOM解析;2、SAX解析;3、STAX解析;4、JDOM解析;5、DOM4J解析。其中DOM解析和SAX解析属于基础方法,是官方提供的平台无关的解析方式;JDOM解析和DOM4J属于扩展方法,它们是在基础的方法上扩展出来的,只适用于java平台。本篇文章不对Stax解析做记录,详情可在易百教程中查看。
一、DOM解析
DOM的全称是Document Object Model,即文档对象模型。在应用程序中,基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合(通常称DOM树),应用程序正是通过对这个对象模型的操作,来实现对XML文档数据的操作。通过DOM接口,应用程序可以在任何时候访问XML文档中的任何一部分数据,因此,这种利用DOM接口的机制也被称作随机访问机制。
DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式,这些分层对象模型依据XML的文档结构形成了一棵节点树。无论XML文档中所描述的是什么类型的信息,即便是制表数据、项目列表或一个文档,利用DOM所生成的模型都是节点树的形式。也就是说,DOM强制使用树模型来访问XML文档中的信息。由于XML本质上就是一种分层结构,所以这种描述方法是相当有效的。
DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性,它可以任意地控制整个XML文档中的内容。然而,由于DOM分析器把整个XML文档转化成DOM树放在了内存中,因此,当文档比较大或者结构比较复杂时,对内存的需求就比较高。而且,对于结构复杂的树的遍历也是一项耗时的操作。所以,DOM分析器对机器性能的要求比较高,实现效率不十分理想。不过,由于DOM分析器所采用的树结构的思想与XML文档的结构相吻合,同时鉴于随机访问所带来的方便,因此,DOM分析器还是有很广泛的使用价值的。
优点:
- 形成了树结构,有助于更好的理解、掌握,且代码容易编写
- 解析过程中,树结构保存在内存中,方便修改
- 可通过节点名来获取节点
缺点:
- 由于文件是一次性读取,所以对内存的耗费比较大,容易引发内存溢出等问题
下面是DOM解析与创建XML文件的完整代码
package com.xiaobaizhiqian;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.util.Date;
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.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class DOMTest {
public static void main(String[] args) {
Date string = new Date();
long str1 = string.getTime();
readeXMLByDOM();
Date string1 = new Date();
long str2 = string1.getTime();
long str = str2 - str1;
System.out.println(str);
}
public static void readeXMLByDOM() {
// 创建一个xml文件解析工厂
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
try {
// 创建一个解析工厂基本接口
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
// 通过DocumentBuilder的parse方法加载文件
Document document = documentBuilder.parse("languages.xml");
// 获取根目录
Element element = document.getDocumentElement();
document.getElementsByTagName("");
// 通过根目录,根据节点名称,获取所有该名称的节点
NodeList nodeList = element.getElementsByTagName("lan");
// 也可通过document直接获取
NodeList nodeList2 = document.getElementsByTagName("lan");
for (int i = 0; i < nodeList.getLength(); i++) {
// 获取单独的一个节点
Node node = nodeList.item(i);
// 获取该节点的名字
String nodeName = node.getNodeName();
// 获取该节点的属性集合
NamedNodeMap attrs = node.getAttributes();
// 根据属性名获得该节点的指定属性名的属性
Node nodeAttr = attrs.getNamedItem("id");
// 也可获取属性集合中指定下标的属性
Node nodeattr2 = attrs.item(0);// 这里item中使用的是具体值,在实际应用中可使用变量
// 获取属性名
String attrName = nodeAttr.getNodeName();
// 获取属性值
String attrValue = nodeAttr.getNodeValue();
// 获取节点的值。若该节点下还有节点,那么该节点的值则为空,须继续获取节点
String nodeValue = node.getNodeValue();
NodeList nodeList3 = node.getChildNodes();
for(int j = 0; j < nodeList3.getLength(); j++) {
Node node2 = nodeList3.item(j);
if (node2.getNodeType() == Node.ELEMENT_NODE) {
String nodeName1 = node2.getNodeName();
String nodeValue2 = node2.getTextContent();
// String nodeValue2 = node2.getFirstChild().getNodeValue();
System.out.println(nodeName1 + ":" + nodeValue2);
}
}
System.out.println(nodeName + ":" + attrName + ":" + attrValue + ":" + nodeValue);
}
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void writeXMLByDom() {
// 创建一个xml文件解析工厂
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
try {
// 创建一个解析工厂基本接口
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
// 通过解析工厂接口创建document
Document document = documentBuilder.newDocument();
// 创建根节点
Element rootElement = document.createElement("languagesTest");
// 给根节点设置属性
rootElement.setAttribute("category", "it");
// 创建子节点
Element lanElement = document.createElement("lan");
// 为子节点设置属性
lanElement.setAttribute("id", "1");
// 创建子节点
Element nameElement = document.createElement("name");
// 为子节点设置值
nameElement.setTextContent("java");
Element ideElement = document.createElement("ide");
ideElement.setTextContent("eclipse");
// 将二级子节点放入一级子节点中
lanElement.appendChild(nameElement);
lanElement.appendChild(ideElement);
// 将一级子节点放入根节点中
rootElement.appendChild(lanElement);
// 将根节点放入document中
document.appendChild(rootElement);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
/*
* 在将源xml输出时,有两个参数,第一个为源xml数据,固定不变的。
* 第二个参数,则可将源xml输出为字符串,也可将源xml输出为xml文件格式的文件,具体实现方式如下
* 通过StringWriter将源xml输出为字符串,通过File将源xml输出为文件
*/
// 输出为字符串格式
StringWriter stringWriter = new StringWriter();
transformer.transform(new DOMSource(document), new StreamResult(stringWriter));
System.out.println(stringWriter.toString());
// 输出为文件格式
transformer.transform(new DOMSource(document), new StreamResult(new File("languagesTest.xml")));
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TransformerConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TransformerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
二、SAX解析
SAX的全称是Simple APIs for XML,即简单应用程序接口。与DOM不同,SAX提供的访问模式是一种顺序模式,这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时,会触发一系列事件,并激活相应的事件处理函数,应用程序通过这些事件处理函数实现对XML文档的访问,因而SAX接口也被称作事件驱动接口。
优点:
- 采用事件驱动模式,对内存耗费比较小,解析速度快
- 适用于只处理XML文件中的数据时
缺点:
- 编码比较麻烦
- 很难同时访问XML文件中的多处不同数据
- 无法知道当前解析标签(节点)的上层标签,及其嵌套结构,仅仅知道当前解析的标签的名字和属性,要知道其他信息需要程序猿自己编码
- 只能读取XML,无法修改XML
- 无法随机访问某个标签(节点)
适用场合:
- 对于CPU资源宝贵的设备,如Android等移动设备
- 对于只需从xml读取信息而无需修改xml
SAX解析XML步骤:
1、创建一个与XML对应的实体类(JavaBean)
代码:
public class Languages {
private String id;
private String name;
private String ide;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIde() {
return ide;
}
public void setIde(String ide) {
this.ide = ide;
}
}
2、新建一个类XmlParseHandler.java,该类需要继承DefaultHandler
或者实现ContentHandler
接口,这里我们通过继承DefaultHandler
(实现了ContentHandler
接口)的方式,该类是SAX解析的核心所在
生命周期:
代码:
package com.xiaobaizhiqian;
import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class SAXParserHandler extends DefaultHandler {
// 解析标签内容时存放数据,便于endElement使用
private String value = null;
private Languages languages = null;
private ArrayList<Languages> languagesList = null;
/** 直接调用便可获取从xml中读取的数据
* @return 返回值可自行设置(这里是返回的ArrayList<Languages>)
*/
public ArrayList<Languages> getLanguages() {
return languagesList;
}
/** 用来标识解析开始,只会执行一次
*/
@Override
public void startDocument() throws SAXException {
super.startDocument();
System.out.println("解析开始");
languagesList = new ArrayList<Languages>();
}
/** 开始解析节点时调用
* @param uri xml文档的命名空间
* @param localName
* @param qName 标签的名字
* @param attributes 标签属性集
*/
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
// 调用父类的方法
super.startElement(uri, localName, qName, attributes);
if (qName.equals("languages")) {
//开始解析book元素的属性
System.out.println("======================开始遍历某一本书的内容=================");
//不知道book元素下属性的名称以及个数,如何获取属性名以及属性值
int num = attributes.getLength();
for(int i = 0; i < num; i++){
System.out.print("语言元素的第" + (i + 1) + "个属性名是:"
+ attributes.getQName(i));
System.out.println("---属性值是:" + attributes.getValue(i));
}
}else if (!qName.equals("lan")) {
System.out.print("节点名是:" + qName + "---");
}else {
//创建一个book对象
languages = new Languages();
int num = attributes.getLength();
for(int i = 0; i < num; i++){
System.out.print("语言元素的第" + (i + 1) + "个属性名是:"
+ attributes.getQName(i));
System.out.println("---属性值是:" + attributes.getValue(i));
if (attributes.getQName(i).equals("id")) {
languages.setId(attributes.getValue(i));
}
}
}
}
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
// TODO Auto-generated method stub
//调用DefaultHandler类的endElement方法
super.endElement(uri, localName, qName);
//判断是否针对一本书已经遍历结束
if (qName.equals("languages")) {
System.out.println(languagesList.size());
System.out.println("======================结束遍历某一本书的内容=================");
}else if(qName.equals("lan")){
languagesList.add(languages);
}else if(qName.equals("name")){
languages.setName(value);
}else if (qName.equals("ide")) {
languages.setIde(value);
}
}
/** 解析标签内容时调用
* @param ch 当前读取到的TextNode(文本节点)的字节数组
* @param start 字节开始的位置,为0则读取全部
* @param length 当前TextNode的长度
*/
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
// TODO Auto-generated method stub
super.characters(ch, start, length);
value = new String(ch, start, length);
if (!value.trim().equals("")) {
System.out.println("节点值是:" + value);
}
}
/** 用来标识解析结束,只会执行一次
* @see org.xml.sax.helpers.DefaultHandler#endDocument()
*/
@Override
public void endDocument() throws SAXException {
// TODO Auto-generated method stub
super.endDocument();
System.out.println("解析结束");
}
}
3、使用XmlParseHandler通过getLanguages直接获得数据
代码:
package com.xiaobaizhiqian;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;
import org.xml.sax.SAXException;
import com.sun.xml.internal.bind.util.AttributesImpl;
public class SAXTest {
public static void main(String[] args) {
Date string = new Date();
long str1 = string.getTime();
readXMLBySAX();
Date string1 = new Date();
long str2 = string1.getTime();
long str = str2 - str1;
System.out.println(str);
}
public static void readXMLBySAX() {
// 创建一个xml文件解析工厂
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
try {
// 创建一个解析工厂基本接口
SAXParser saxParser = saxParserFactory.newSAXParser();
// 创建一个解析工厂管理
SAXParserHandler saxParserHandler = new SAXParserHandler();
// 通过SAXParserHandler的parse方法加载文件
saxParser.parse("languages.xml", saxParserHandler);
System.out.println("~!~!~!共有" + saxParserHandler.getLanguages().size() + "本书");
for (Languages languages : saxParserHandler.getLanguages()) {
System.out.println(languages.getId());
System.out.println(languages.getName());
System.out.println(languages.getIde());
System.out.println("----finish----");
}
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void writeXMLBySAX() {
SAXTransformerFactory saxTransformerFactory = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
try {
TransformerHandler transformerHandler = saxTransformerFactory.newTransformerHandler();
Transformer transformer = transformerHandler.getTransformer();
// 设置生成的XML文件格式
transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
// 设置生成的 XML 文件自动换行
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
// 如果不存在,就创建一个新的 XML 文件
File file = new File("languagesTest.xml");
if (!file.exists()) {
file.createNewFile();
}
// 创建一个Result 对象,并且使其与 TransformerHandler 对象关联
Result result = null;
result = new StreamResult(new FileOutputStream(file));
transformerHandler.setResult(result);
//利用 handler 对象进行 XML 文件内容的编写
//打开 document
transformerHandler.startDocument();
//为了创建节点属性和属性值
AttributesImpl atts = new AttributesImpl();
//设置属性和属性值
atts.addAttribute("", "", "cat", "", "it");
//根节点开始标签
transformerHandler.startElement("", "", "languages", atts);
atts.clear();
atts.addAttribute("", "", "id", "", "1");
//子节点开始标签
transformerHandler.startElement("", "", "lan", atts);
atts.clear(); //清空子节点设的值
//子节点下name节点开始标签
transformerHandler.startElement("", "", "name", atts);
String name="java";
transformerHandler.characters(name.toCharArray(), 0, name.length());
//字节点下name节点结束标签
transformerHandler.endElement("", "", "name");
//子节点结束标签
transformerHandler.endElement("", "", "lan");
//根节点结束标签
transformerHandler.endElement("", "", "languages");
//关闭 document
transformerHandler.endDocument();
} catch (TransformerConfigurationException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
三、JDOM解析XML数据
特征:
- 可直接通过节点名获取节点
- 仅使用具体类,而不使用接口
- API大量使用了Collections类
- Jdom专用于java技术,比Dom应用占用更少内存,但内存消耗仍然较大
-
Jdom提供更加简单和逻辑性访问xml信息的基础方法
JDOM解析XML步骤
1、导入jdom.jar包。jar包下载地址http://www.jdom.org/downloads/
2、创建一个SAXBuilder的对象
3、创建一个输入流,将xml文件加载到输入流中
4、通过saxBuilder的build方法,将输入流加载到saxBuilder中
5、获取节点信息
下面是完整代码
package com.xiaobaizhiqian;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.List;
import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
public class JDomTest {
public static void main(String[] args) {
Date string = new Date();
long str1 = string.getTime();
readXMLByJdom();
Date string1 = new Date();
long str2 = string1.getTime();
long str = str2 - str1;
System.out.println(str);
}
public static void readXMLByJdom() {
// 1.创建一个SAXBuilder的对象
SAXBuilder saxBuilder = new SAXBuilder();
InputStream inputStream;
try {
// 2.创建一个输入流,将xml文件加载到输入流中
inputStream = new FileInputStream("languages.xml");
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
// 3.通过saxBuilder的build方法,将输入流加载到saxBuilder中
Document document = saxBuilder.build(inputStreamReader);
// 获取根节点
Element rootElement = document.getRootElement();
List<Element> elements = rootElement.getChildren();
for (Element element : elements) {
// 获取节点的属性
List<Attribute> attributes = element.getAttributes();
// 获取指定名称的节点
element.getChild("");
for (Attribute attribute : attributes) {
// 获取属性名
String attrName = attribute.getName();
// 获取属性值
String attrValue = attribute.getValue();
System.out.println(element.getName() + ":" + attrName + ":" + attrValue);
}
// 获取子节点
List<Element> elementsChilds = element.getChildren();
for (Element elementChild : elementsChilds) {
String elementName = elementChild.getName();
String elementValue = elementChild.getValue();
System.out.println(elementName + ":" + elementValue);
}
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JDOMException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void writeXMLByJdom() {
// 创建根节点
Element rootElement = new Element("languages");
rootElement.setAttribute("cat", "it");
// 将根节点放到document
Document document = new Document(rootElement);
Element element = new Element("lan");
element.setAttribute("id", "1");
Element nameElement = new Element("name");
nameElement.addContent("java");
rootElement.addContent(element);
element.addContent(nameElement);
XMLOutputter xmlOutputter = new XMLOutputter(Format.getCompactFormat().setEncoding("UTF-8").setIndent(" "));
// 设置xml文件编码格式可封装成方法进行
// XMLOutputter xmlOutputter1 = new XMLOutputter(getFormat());
try {
xmlOutputter.output(document, new FileOutputStream("languagesTest.xml"));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static Format getFormat() {
Format format = Format.getCompactFormat();
format.setEncoding("UTF-8");
format.setIndent(" ");
return format;
}
}
四、DOM4J解析
dom4j解析XML文件需要导入dom4j.jar包。下载地址 https://dom4j.github.io/
特征:
- JDOM的一种智能分支,它合并了许多超出基本XML文档表示的功能。
- 它使用接口和抽象基本类方法。
- 具有性能优异、灵活性好、功能强大和极端易用的特点。
- 是一个开放源码的文件
- 可移植性差
-
不可通过节点名获取节点
以下是完整测试代码
package com.xiaobaizhiqian;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Date;
import java.util.Iterator;
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.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
public class Dom4jTest {
public static void main(String[] args) {
Date string = new Date();
long str1 = string.getTime();
readeXMLByDom4j();
Date string1 = new Date();
long str2 = string1.getTime();
long str = str2 - str1;
System.out.println(str);
}
public static void readeXMLByDom4j() {
SAXReader saxReader = new SAXReader();
try {
// 通过reader对象的read方法加载xml文件,获取docuemnt对象。
Document document = saxReader.read("languages.xml");
// 通过document对象获取根节点bookstore
Element rootElement = document.getRootElement();
// 通过根节点获取迭代器
Iterator<Element> elementIterator = rootElement.elementIterator();
// 遍历迭代器,获取根节点中的信息
while (elementIterator.hasNext()) {
Element element = elementIterator.next();
List<Attribute> attributes = element.attributes();
for (Attribute attribute : attributes) {
String attrName = attribute.getName();
String attrValue = attribute.getValue();
System.out.println(element.getName() + ":" + attrName + ":" + attrValue);
}
String elementName = element.getName();
String elementValue = element.getStringValue();
Iterator<Element> iterator = element.elementIterator();
while (iterator.hasNext()) {
Element element1 = iterator.next();
String elementName1 = element1.getName();
String elementValue1 = element1.getStringValue();
System.out.println(elementName1 +":"+ elementValue1);
}
}
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void writeXMLByDom4j() {
// 创建一个xml文档
Document doc = DocumentHelper.createDocument();
// 向xml文件中添加注释
doc.addComment("这里是注释");
// 创建languages子节点
Element root = doc.addElement("languages");
// 在root节点下创建一个名为student的节点
Element stuEle = root.addElement("student");
// 给student节点添加属性
stuEle.addAttribute("id", "101");
// 给student节点添加一个子节点
Element nameEle = stuEle.addElement("name");
// 设置子节点的文本
nameEle.setText("张三");
// 用于格式化xml内容和设置头部标签
OutputFormat format = OutputFormat.createPrettyPrint();
// 设置xml文档的编码为utf-8
format.setEncoding("utf-8");
Writer out;
try {
// 创建一个输出流对象
out = new FileWriter("languagesTest.xml");
// 创建一个dom4j创建xml的对象
XMLWriter writer = new XMLWriter(out, format);
// 调用write方法将doc文档写到指定路径
writer.write(doc);
writer.close();
System.out.print("生成XML文件成功");
} catch (IOException e) {
System.out.print("生成XML文件失败");
e.printStackTrace();
}
}
}