Xerces 简明教程

Apache Xerces - Quick Guide

Apache Xerces - XML Overview

What is XML?

XML 是一种简单的基于文本的语言，旨在以纯文本格式存储和传输数据。它代表可扩展标记语言。以下是 XML 的一些显著功能。

XML 是一种标记语言。
XML 是一种基于标记的语言，如 HTML。
XML 标记不是预定义的，如 HTML。
您可定义自己的标记，这就是为什么它被称为可扩展语言。
XML 标记旨在自我描述。
XML 是 W3C 对数据存储和传输的建议。

Example

<?xml version = "1.0"?>
<Class>
   <Name>First</Name>
   <Sections>

      <Section>
         <Name>A</Name>
         <Students>
            <Student>Rohan</Student>
            <Student>Mohan</Student>
            <Student>Sohan</Student>
            <Student>Lalit</Student>
            <Student>Vinay</Student>
         </Students>
      </Section>

      <Section>
         <Name>B</Name>
         <Students>
            <Student>Robert</Student>
            <Student>Julie</Student>
            <Student>Kalie</Student>
            <Student>Michael</Student>
         </Students>
      </Section>

   </Sections>
</Class>

Advantages

XML 提供的优点如下：

Technology agnostic − 作为纯文本，XML 与技术无关。它可被任何技术用于数据存储和传输目的。
Human readable − XML 使用简单的文本格式。它具有可读性和可理解性。
Extensible − 在 XML 中，可以非常轻松地创建和使用自定义标签。
Allow Validation − 使用 XSD、DTD 和 XML 结构可以轻松进行验证。

Disadvantages

以下是 XML 用法的缺点：

Redundant Syntax − 通常，XML 文件包含大量重复术语。
Verbose − 作为一种冗长语言，XML 文件大小会增加传输和存储成本。

Apache Xerces - Environment Setup

本教程将带你完成在 Windows 和基于 Linux 的系统中设置 Apache Xerces 的过程。按照几个简单的步骤，在没有复杂设置程序的情况下，可以轻松安装 Apache Xerces 并将其集成到你的当前 Java 环境中。安装过程中需要用户管理。

System Requirements

JDK

Java SE 2 JDK 1.5 或更高版本

Memory

1 GB RAM (recommended)

Disk Space

No minimum requirement

Operating System Version

Windows XP 或更高版本、Linux

现在，让我们继续进行安装 Apache Xerces 的步骤。

Step 1: Verify your Java Installation

首先，你所使用的系统需要安装 Java 软件开发套件 (SDK)。要验证这一点，请根据你所使用的平台执行两个命令中的任何一个。

如果 Java 安装成功，那么它将显示你的 Java 安装的当前版本和规范。一个示例输出在以下表格中给出。

Platform

Command

Sample Output

Windows

打开命令控制台并输入− java -version

Java 版本“1.7.0_60” Java™ SE 运行时环境（构建 1.7.0_60-b19）Java Hotspot™ 64 位服务器虚拟机（构建 24.60b09，混合模式）

Linux

打开命令终端并输入 − $java -version

Java 版本“1.7.0_25”Open JDK 运行时环境（rhel-2.3.10.4.el6_4-x86_64）Open JDK 64 位服务器虚拟机（构建 23.7-b01，混合模式）

我们假设本教程的读者已在他们的系统上安装了 Java SDK 版本 1.7.0_60。
如果您没有 Java SDK，请从 www.oracle.com/technetwork/java/javase/downloads/index.html 下载其当前版本并将其安装。

Step 2: Set your Java Environment

设置环境变量 JAVA_HOME 以指向计算机上安装 Java 的基本目录位置。例如，

Sr.No.

Platform & Description

Windows Set JAVA_HOME to C:\ProgramFiles\java\jdk1.7.0_60

Linux Export JAVA_HOME = /usr/local/java-current

将 Java 编译器位置的完整路径附加到系统路径。

Sr.No.

Platform & Description

Windows 将字符串“C:\Program Files\Java\jdk1.7.0_60\bin”附加到系统变量 PATH 的末尾。

Linux Export PATH = $PATH:$JAVA_HOME/bin/

如上所示从命令提示符处执行命令 java version。

Step 3: Install Apache Xerces Library

从 https://xerces.apache.org/mirrors.cgi" 下载 Apache Xerces 的最新版本，并将其内容解压到一个文件夹中，以便从该文件夹链接必需的库到你的 Java 程序中。假设这些文件已经收集到 C 驱动器上的一个文件夹 xerces-2_12_1 中。

将上图中突出显示的五个 jar 的完整路径添加到 CLASSPATH。

Sr.No.

Platform & Description

Windows 在用户变量 CLASSPATH 后追加以下字符串 −C:\xerces-2_12_1\resolver.jar;C:\xerces-2_12_1\serializer.jar;C:\xerces-2_12_1\xercesImpl.jar;C:\xerces-2_12_1\xercesSamples.jar;C:\xerces-2_12_1\xml-apis.jar;

Linux 导出 CLASSPATH = $CLASSPATH −/usr/share/xerces-2_12_1\resolver.jar;/usr/share/xerces-2_12_1\serializer.jar;/usr/share/xerces-2_12_1\xercesImpl.jar;/usr/share/xerces-2_12_1\xercesSamples.jar;/usr/share/xerces-2_12_1\xml-apis.jar;

Apache Xerces - XML Parsers

What is Apache Xerces2?

Xerces2 是基于 Java 的处理器，并提供以下 XML 解析 API 标准的标准接口和实现：

文档对象模型（DOM）第 3 级
简单 XML API（SAX）2.0.2
XML 流式 API（STAX）1.0 事件 API
用于处理 XML 的 Java API（JAXP）1.4

What is XML Parsing?

解析 XML 指的是遍历 XML 文档来访问数据或通过一种或另一种方式修改数据。

What is XML Parser?

XML 解析器提供了一种访问或修改 XML 文档中存在的数据的方法。Java 提供了多种用于解析 XML 文档的选项。以下是用于解析 XML 文档的各种类型的解析器。

Dom Parser − 通过加载文档的完整内容并在内存中创建其完整的层次化树来解析文档。
SAX Parser − 根据基于事件的触发器来解析文档。不会将完整文档加载到内存中。
StAX Parser − 以类似于 SAX 解析器的方式解析文档，但效率更高。

现在，我们将在后续章节中使用 Apache Xerces 库来详细说明每个解析器。

Apache Xerces - DOM Parser Overview

文档对象模型是万维网联盟（W3C）的正式建议。它定义了使程序能够访问和更新 XML 文档的样式、结构和内容的接口。支持 DOM 的 XML 解析器实施了该接口。

When to use?

你应在下列情况下使用 DOM 解析器：

您需要充分理解文档的结构。
您需要移动文档的各个部分（例如，您可能想要对某些元素进行排序）。
您需要多次使用文档中的信息。

What you get?

使用 DOM 解析器解析 XML 文档时，你会得到一个包含你的文档所有元素的树形结构。DOM 提供了各种函数让你能够检查文档的内容和结构。

Advantages

DOM 是用于操作文档结构的通用接口。它的一个设计目标是，为一个 DOM 兼容解析器编写的 Java 代码应该可以在任何其他 DOM 兼容解析器上运行，无需进行更改。

DOM interfaces

DOM 定义了若干 Java 接口。这里是最常见的接口 −

Node − DOM 的基本数据类型。
Element − 您将处理的大多数对象是元素。
Attr − 表示元素的一个属性。
Text − 元素或属性的实际内容。
Document − 表示整个 XML 文档。文档对象通常称为 DOM 树。

Common DOM methods

当使用 DOM 时，有几种经常使用的方法 −

Document.getDocumentElement() − 返回文档的根元素。
Node.getFirstChild() − 返回给定节点的第一个子代。
Node.getLastChild() − 返回给定节点的最后一个子代。
Node.getNextSibling() − 这些方法返回给定节点的下一个同级。
Node.getPreviousSibling() − 这些方法返回给定节点的前一个同级。
Node.getAttribute(attrName) − 对于给定的节点，返回具有请求名称的属性。

DOM Parser - Parse XML Document

Steps to Use DOM

以下是使用 DOM 解析器解析文档时使用的步骤。

Import XML-related packages.
Create a DocumentBuilder
从文件或流创建一个文档
Extract the root element
Examine attributes
Examine sub-elements

Import XML-related packages

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;

Create a DocumentBuilder

DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

Create a Document from a file or stream

StringBuilder xmlStringBuilder = new StringBuilder();
xmlStringBuilder.append("<?xml version = "1.0"?> <class> </class>");
ByteArrayInputStream input =  new ByteArrayInputStream(
   xmlStringBuilder.toString().getBytes("UTF-8"));
Document doc = builder.parse(input);

Extract the root element

Element root = document.getDocumentElement();

Examine attributes

//returns specific attribute
getAttribute("attributeName");
//returns a Map (table) of names/values
getAttributes();

Examine sub-elements

//returns a list of subelements of specified name
getElementsByTagName("subelementName");
//returns a list of all child nodes
getChildNodes();

Demo Example

下面是需要解析的输入 xml 文件 −

<?xml version = "1.0"?>
<class>

   <student rollno = "393">
      <firstname>Dinkar</firstname>
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>
   </student>

   <student rollno = "493">
      <firstname>Vineet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>

   <student rollno = "593">
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

Demo Example

DomParserDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;

public class DomParserDemo {
   public static void main(String[] args){

      try {
         File inputFile = new File("input.txt");
         DocumentBuilderFactory dbFactory
            = DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
         Document doc = dBuilder.parse(inputFile);
         doc.getDocumentElement().normalize();

         System.out.println("Root element :"
            + doc.getDocumentElement().getNodeName());
         NodeList nList = doc.getElementsByTagName("student");

         System.out.println("----------------------------");
         for (int temp = 0; temp < nList.getLength(); temp++) {
            Node nNode = nList.item(temp);

            System.out.println("\nCurrent Element :"
               + nNode.getNodeName());
            if (nNode.getNodeType() == Node.ELEMENT_NODE) {
               Element eElement = (Element) nNode;

               System.out.println("Student roll no : "
                  + eElement.getAttribute("rollno"));

               System.out.println("First Name : "
                  + eElement
                  .getElementsByTagName("firstname")
                  .item(0)
                  .getTextContent());

               System.out.println("Last Name : "
               + eElement
                  .getElementsByTagName("lastname")
                  .item(0)
                  .getTextContent());

               System.out.println("Nick Name : "
               + eElement
                  .getElementsByTagName("nickname")
                  .item(0)
                  .getTextContent());

               System.out.println("Marks : "
               + eElement
                  .getElementsByTagName("marks")
                  .item(0)
                  .getTextContent());
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

以上程序将生成以下结果：

Root element :class
----------------------------

Current Element :student
Student roll no : 393
First Name : Dinkar
Last Name : Kad
Nick Name : Dinkar
Marks : 85

Current Element :student
Student roll no : 493
First Name : Vineet
Last Name : Gupta
Nick Name : Vinni
Marks : 95

Current Element :student
Student roll no : 593
First Name : Jasvir
Last Name : Singh
Nick Name : Jazz
Marks : 90

DOM Parser - Query XML Document

Demo Example

以下是我们必须查询的输入 xml 文件：

<?xml version = "1.0"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferarri 101</carname>
      <carname type = "sports car">Ferarri 201</carname>
      <carname type = "sports car">Ferarri 301</carname>
   </supercars>

   <supercars company = "Lamborgini">
      <carname>Lamborgini 001</carname>
      <carname>Lamborgini 002</carname>
      <carname>Lamborgini 003</carname>
   </supercars>

   <luxurycars company = "Benteley">
      <carname>Benteley 1</carname>
      <carname>Benteley 2</carname>
      <carname>Benteley 3</carname>
   </luxurycars>
</cars>

Demo Example

QueryXmlFileDemo.java

package com.tutorialspoint.xml;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import java.io.File;

public class QueryXmlFileDemo {

   public static void main(String argv[]) {

      try {
         File inputFile = new File("input.txt");
         DocumentBuilderFactory dbFactory =
            DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
         Document doc = dBuilder.parse(inputFile);
         doc.getDocumentElement().normalize();
         System.out.print("Root element: ");
         System.out.println(doc.getDocumentElement().getNodeName());
         NodeList nList = doc.getElementsByTagName("supercars");
         System.out.println("----------------------------");
         for (int temp = 0; temp < nList.getLength(); temp++) {
            Node nNode = nList.item(temp);
            System.out.println("\nCurrent Element :");
            System.out.print(nNode.getNodeName());
            if (nNode.getNodeType() == Node.ELEMENT_NODE) {
               Element eElement = (Element) nNode;
               System.out.print("company : ");
               System.out.println(eElement.getAttribute("company"));
               NodeList carNameList =
                  eElement.getElementsByTagName("carname");
               for (int count = 0;
                  count < carNameList.getLength(); count++) {
                  Node node1 = carNameList.item(count);
                  if (node1.getNodeType() ==
                     node1.ELEMENT_NODE) {
                     Element car = (Element) node1;
                     System.out.print("car name : ");
                     System.out.println(car.getTextContent());
                     System.out.print("car type : ");
                     System.out.println(car.getAttribute("type"));
                  }
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

以上程序将生成以下结果：

Root element :cars
----------------------------

Current Element :supercars
company : Ferrari
car name : Ferarri 101
car type : formula one
car name : Ferarri 201
car type : sports car
car name : Ferarri 301
car type : sports car

Current Element :supercars
company : Lamborgini
car name : Lamborgini 001
car type :
car name : Lamborgini 002
car type :
car name : Lamborgini 003
car type :

DOM Parser - Create XML Document

Demo Example

以下是我们需要创建的 XML -

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars><supercars company = "Ferrari">
   <carname type = "formula one">Ferrari 101</carname>
   <carname type = "sports">Ferrari 202</carname>
</supercars></cars>

Demo Example

CreateXmlFileDemo.java

package com.tutorialspoint.xml;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import java.io.File;

public class CreateXmlFileDemo {

   public static void main(String argv[]) {

      try {
         DocumentBuilderFactory dbFactory =
         DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder =
            dbFactory.newDocumentBuilder();
         Document doc = dBuilder.newDocument();

         // root element
         Element rootElement = doc.createElement("cars");
         doc.appendChild(rootElement);

         //  supercars element
         Element supercar = doc.createElement("supercars");
         rootElement.appendChild(supercar);

         // setting attribute to element
         Attr attr = doc.createAttribute("company");
         attr.setValue("Ferrari");
         supercar.setAttributeNode(attr);

         // carname element
         Element carname = doc.createElement("carname");
         Attr attrType = doc.createAttribute("type");
         attrType.setValue("formula one");
         carname.setAttributeNode(attrType);
         carname.appendChild(
         doc.createTextNode("Ferrari 101"));
         supercar.appendChild(carname);

         Element carname1 = doc.createElement("carname");
         Attr attrType1 = doc.createAttribute("type");
         attrType1.setValue("sports");
         carname1.setAttributeNode(attrType1);
         carname1.appendChild(
         doc.createTextNode("Ferrari 202"));
         supercar.appendChild(carname1);

         // write the content into xml file
         TransformerFactory transformerFactory =
         TransformerFactory.newInstance();
         Transformer transformer =
         transformerFactory.newTransformer();
         DOMSource source = new DOMSource(doc);
         StreamResult result =
         new StreamResult(new File("C:\\cars.xml"));
         transformer.transform(source, result);

         // Output to console for testing
         StreamResult consoleResult =
         new StreamResult(System.out);
         transformer.transform(source, consoleResult);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

以上程序将生成以下结果：

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars><supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars></cars>

DOM Parser - Modify XML Document

Demo Example

以下是我们需要修改的输入 XML 文件 -

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>

   <luxurycars company = "Benteley">
      <carname>Benteley 1</carname>
      <carname>Benteley 2</carname>
      <carname>Benteley 3</carname>
   </luxurycars>
</cars>

Demo Example

ModifyXmlFileDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
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;

public class ModifyXmlFileDemo {

public static void main(String argv[]) {

   try {
      File inputFile = new File("input.txt");
      DocumentBuilderFactory docFactory =
      DocumentBuilderFactory.newInstance();
      DocumentBuilder docBuilder =
      docFactory.newDocumentBuilder();
      Document doc = docBuilder.parse(inputFile);
      Node cars = doc.getFirstChild();
      Node supercar = doc.getElementsByTagName("supercars").item(0);

      // update supercar attribute
      NamedNodeMap attr = supercar.getAttributes();
      Node nodeAttr = attr.getNamedItem("company");
      nodeAttr.setTextContent("Lamborigini");

      // loop the supercar child node
      NodeList list = supercar.getChildNodes();
      for (int temp = 0; temp < list.getLength(); temp++) {
         Node node = list.item(temp);
         if (node.getNodeType() == Node.ELEMENT_NODE) {
            Element eElement = (Element) node;
            if ("carname".equals(eElement.getNodeName())){
               if("Ferrari 101".equals(eElement.getTextContent())){
                  eElement.setTextContent("Lamborigini 001");
               }
            if("Ferrari 202".equals(eElement.getTextContent()))
               eElement.setTextContent("Lamborigini 002");
            }
         }
      }

      NodeList childNodes = cars.getChildNodes();
      for(int count = 0; count < childNodes.getLength(); count++){
         Node node = childNodes.item(count);
         if("luxurycars".equals(node.getNodeName()))
            cars.removeChild(node);
         }

         // write the content on console
         TransformerFactory transformerFactory =
         TransformerFactory.newInstance();
         Transformer transformer = transformerFactory.newTransformer();
         DOMSource source = new DOMSource(doc);
         System.out.println("-----------Modified File-----------");
         StreamResult consoleResult = new StreamResult(System.out);
         transformer.transform(source, consoleResult);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

以上程序将生成以下结果：

-----------Modified File-----------
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
<supercars company = "Lamborigini">
<carname type = "formula one">Lamborigini 001</carname>
<carname type = "sports">Lamborigini 002</carname>
</supercars></cars>

SAX Parser - Overview

SAX（XML 简单 API）是基于事件的 XML 文档解析器。与 DOM 解析器不同，SAX 解析器不创建解析树。SAX 是一个 XML 流传输接口，这意味着使用 SAX 的应用程序会针对正在处理的 XML 文档接收事件通知，包括元素、属性以及从文档顶部开始、以 ROOT 元素的结束为结尾的顺序排列的时间。

从上到下读取 XML 文档，识别构成良好形成的 XML 文档的标记。
标记按其出现在文档中的顺序进行处理。
向应用程序报告解析器在遇到解析标记时发现的标记的类型。
应用程序提供了一个“事件”处理程序，该处理程序必须在解析器中注册。
随着标记被识别，带有相关信息的回调方法将被调用。

When to use?

以下情况应使用 SAX 解析器 -

你可以从上到下线性处理 XML 文档。
文档没有深度嵌套。
您正在处理一个非常大的 XML 文档，它对应的 DOM 树会占用大量的内存。典型的 DOM 实现使用 10 个字节的内存表示一个字节的 XML。
需要解决的问题仅涉及 XML 文档的一部分。
数据一旦被解析器看到就可用，因此 SAX 非常适用于通过流到达的 XML 文档。

Disadvantages of SAX

我们无法随机访问 XML 文档，因为它是按前向方式处理的。
如果你需要跟踪解析器看过的数据或更改项目顺序，则必须自己编写代码并存储数据。

ContentHandler Interface

此接口指定 SAX 解析器用于通知应用程序程序其看到的 XML 文档组件的回调方法。

void startDocument() − 在文档开头调用。
void endDocument() − 在文档开头调用。
void startElement(String uri, String localName, String qName, Attributes atts) − 在元素开头调用。
void endElement(String uri, String localName,String qName) − 在元素结尾调用。
void characters(char[] ch, int start, int length) − 在遇到字符数据时调用。
void ignorableWhitespace( char[] ch, int start, int length) − 在存在 DTD 且遇到可忽略空白时调用。
void processingInstruction(String target, String data) − 在识别出处理指令时调用。
void setDocumentLocator(Locator locator)) − 提供一个用于标识文档中位置的定位器。
void skippedEntity(String name) − 在遇到未解析的实体时调用。
void startPrefixMapping(String prefix, String uri) − 在定义新的命名空间映射时调用。
void endPrefixMapping(String prefix) − 在命名空间定义结束其作用域时调用。

Attributes Interface

此接口为处理连接到元素的属性指定方法。

int getLength() − 返回属性的数量。
String getQName(int index)
String getValue(int index)
String getValue(String qname)

SAX Parser - Parse XML Document

Demo Example

下面是需要解析的输入 xml 文件 −

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>Dinkar</firstname>
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>
   </student>

   <student rollno = "493">
      <firstname>Vineet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>

   <student rollno = "593">
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

UserHandler.java

package com.tutorialspoint.xml;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class UserHandler extends DefaultHandler {

   boolean bFirstName = false;
   boolean bLastName = false;
   boolean bNickName = false;
   boolean bMarks = false;

   @Override
   public void startElement(String uri,
   String localName, String qName, Attributes attributes) throws SAXException {
      if (qName.equalsIgnoreCase("student")) {
         String rollNo = attributes.getValue("rollno");
         System.out.println("Roll No : " + rollNo);
      } else if (qName.equalsIgnoreCase("firstname")) {
         bFirstName = true;
      } else if (qName.equalsIgnoreCase("lastname")) {
         bLastName = true;
      } else if (qName.equalsIgnoreCase("nickname")) {
         bNickName = true;
      } else if (qName.equalsIgnoreCase("marks")) {
         bMarks = true;
      }
   }

   @Override
   public void endElement(String uri,
   String localName, String qName) throws SAXException {
      if (qName.equalsIgnoreCase("student")) {
         System.out.println("End Element :" + qName);
      }
   }

   @Override
   public void characters(char ch[], int start, int length) throws SAXException {
      if (bFirstName) {
         System.out.println("First Name: " + new String(ch, start, length));
         bFirstName = false;
      } else if (bLastName) {
         System.out.println("Last Name: " + new String(ch, start, length));
         bLastName = false;
      } else if (bNickName) {
         System.out.println("Nick Name: " + new String(ch, start, length));
         bNickName = false;
      } else if (bMarks) {
         System.out.println("Marks: " + new String(ch, start, length));
         bMarks = false;
      }
   }
}

SAXParserDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SAXParserDemo {
   public static void main(String[] args){

      try {
         File inputFile = new File("input.txt");
         SAXParserFactory factory = SAXParserFactory.newInstance();
         SAXParser saxParser = factory.newSAXParser();
         UserHandler userhandler = new UserHandler();
         saxParser.parse(inputFile, userhandler);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

class UserHandler extends DefaultHandler {

   boolean bFirstName = false;
   boolean bLastName = false;
   boolean bNickName = false;
   boolean bMarks = false;

   @Override
   public void startElement(String uri,
      String localName, String qName, Attributes attributes) throws SAXException {
      if (qName.equalsIgnoreCase("student")) {
         String rollNo = attributes.getValue("rollno");
         System.out.println("Roll No : " + rollNo);
      } else if (qName.equalsIgnoreCase("firstname")) {
         bFirstName = true;
      } else if (qName.equalsIgnoreCase("lastname")) {
         bLastName = true;
      } else if (qName.equalsIgnoreCase("nickname")) {
         bNickName = true;
      } else if (qName.equalsIgnoreCase("marks")) {
         bMarks = true;
      }
   }

   @Override
   public void endElement(String uri,
      String localName, String qName) throws SAXException {
      if (qName.equalsIgnoreCase("student")) {
         System.out.println("End Element :" + qName);
      }
   }

   @Override
   public void characters(char ch[], int start, int length) throws SAXException {
      if (bFirstName) {
         System.out.println("First Name: " + new String(ch, start, length));
         bFirstName = false;
      } else if (bLastName) {
         System.out.println("Last Name: " + new String(ch, start, length));
         bLastName = false;
      } else if (bNickName) {
         System.out.println("Nick Name: " + new String(ch, start, length));
         bNickName = false;
      } else if (bMarks) {
         System.out.println("Marks: " + new String(ch, start, length));
         bMarks = false;
      }
   }
}

以上程序将生成以下结果：

Roll No : 393
First Name: Dinkar
Last Name: Kad
Nick Name: Dinkar
Marks: 85
End Element :student
Roll No : 493
First Name: Vineet
Last Name: Gupta
Nick Name: Vinni
Marks: 95
End Element :student
Roll No : 593
First Name: Jasvir
Last Name: Singh
Nick Name: Jazz
Marks: 90
End Element :student

SAX Parser - Query XML Document

Demo Example

以下是我们要查询学号的输入文本文件：393 -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>Dinkar</firstname>
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>
   </student>

   <student rollno = "493">
      <firstname>Vineet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>

   <student rollno = "593">
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

UserHandler.java

package com.tutorialspoint.xml;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;


public class UserHandler extends DefaultHandler {

   boolean bFirstName = false;
   boolean bLastName = false;
   boolean bNickName = false;
   boolean bMarks = false;
   String rollNo = null;

   @Override
   public void startElement(String uri,
      String localName, String qName, Attributes attributes) throws SAXException {

      if (qName.equalsIgnoreCase("student")) {
         rollNo = attributes.getValue("rollno");
      }
      if(("393").equals(rollNo) && qName.equalsIgnoreCase("student")){
         System.out.println("Start Element :" + qName);
      }
      if (qName.equalsIgnoreCase("firstname")) {
         bFirstName = true;
      } else if (qName.equalsIgnoreCase("lastname")) {
         bLastName = true;
      } else if (qName.equalsIgnoreCase("nickname")) {
         bNickName = true;
      } else if (qName.equalsIgnoreCase("marks")) {
         bMarks = true;
      }
   }

   @Override
   public void endElement(String uri, String localName, String qName) throws SAXException {
      if (qName.equalsIgnoreCase("student")) {
         if(("393").equals(rollNo)
            && qName.equalsIgnoreCase("student"))
            System.out.println("End Element :" + qName);
      }
   }


   @Override
   public void characters(char ch[], int start, int length) throws SAXException {

      if (bFirstName && ("393").equals(rollNo)) {
         //age element, set Employee age
         System.out.println("First Name: " + new String(ch, start, length));
         bFirstName = false;
      } else if (bLastName && ("393").equals(rollNo)) {
         System.out.println("Last Name: " + new String(ch, start, length));
         bLastName = false;
      } else if (bNickName && ("393").equals(rollNo)) {
         System.out.println("Nick Name: " + new String(ch, start, length));
         bNickName = false;
      } else if (bMarks && ("393").equals(rollNo)) {
         System.out.println("Marks: " + new String(ch, start, length));
         bMarks = false;
      }
   }
}

SAXQueryDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SAXQueryDemo {
   public static void main(String[] args){

      try {
         File inputFile = new File("input.txt");
         SAXParserFactory factory = SAXParserFactory.newInstance();
         SAXParser saxParser = factory.newSAXParser();
         UserHandler userhandler = new UserHandler();
         saxParser.parse(inputFile, userhandler);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

class UserHandler extends DefaultHandler {

   boolean bFirstName = false;
   boolean bLastName = false;
   boolean bNickName = false;
   boolean bMarks = false;
   String rollNo = null;

   @Override
   public void startElement(String uri,
      String localName, String qName, Attributes attributes) throws SAXException {

      if (qName.equalsIgnoreCase("student")) {
         rollNo = attributes.getValue("rollno");
      }
      if(("393").equals(rollNo) &&
         qName.equalsIgnoreCase("student")){
         System.out.println("Start Element :" + qName);
      }
      if (qName.equalsIgnoreCase("firstname")) {
         bFirstName = true;
      } else if (qName.equalsIgnoreCase("lastname")) {
         bLastName = true;
      } else if (qName.equalsIgnoreCase("nickname")) {
         bNickName = true;
      } else if (qName.equalsIgnoreCase("marks")) {
         bMarks = true;
      }
   }

   @Override
   public void endElement(String uri,
      String localName, String qName) throws SAXException {
      if (qName.equalsIgnoreCase("student")) {
         if(("393").equals(rollNo)
            && qName.equalsIgnoreCase("student"))
            System.out.println("End Element :" + qName);
      }
   }


   @Override
   public void characters(char ch[], int start, int length) throws SAXException {

      if (bFirstName && ("393").equals(rollNo)) {
         //age element, set Employee age
         System.out.println("First Name: " + new String(ch, start, length));
         bFirstName = false;
      } else if (bLastName && ("393").equals(rollNo)) {
         System.out.println("Last Name: " + new String(ch, start, length));
         bLastName = false;
      } else if (bNickName && ("393").equals(rollNo)) {
         System.out.println("Nick Name: " + new String(ch, start, length));
         bNickName = false;
      } else if (bMarks && ("393").equals(rollNo)) {
         System.out.println("Marks: " + new String(ch, start, length));
         bMarks = false;
      }
   }
}

以上程序将生成以下结果：

Start Element :student
First Name: Dinkar
Last Name: Kad
Nick Name: Dinkar
Marks: 85
End Element :student

SAX Parser - Create XML Document

使用 StAX 解析器创建 XML 比使用 SAX 解析器更好。请参阅 Java StAX Parser 部分以获取相同的信息。

SAX Parser - Modify XML Document

Demo Example

以下是我们必须在 </marks> tag 末尾附加 <Result>Pass<Result/> 以进行修改的输入 xml 文件。

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>Dinkar</firstname>
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>
   </student>

   <student rollno = "493">
      <firstname>Vineet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>

   <student rollno = "593">
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

SAXModifyDemo.java

package com.tutorialspoint.xml;

import java.io.*;
import org.xml.sax.*;
import javax.xml.parsers.*;
import org.xml.sax.helpers.DefaultHandler;

public class SAXModifyDemo extends DefaultHandler {
   static String displayText[] = new String[1000];
   static int numberLines = 0;
   static String indentation = "";

   public static void main(String args[]) {

      try {
         File inputFile = new File("input.txt");
         SAXParserFactory factory =
         SAXParserFactory.newInstance();
         SAXModifyDemo obj = new SAXModifyDemo();
         obj.childLoop(inputFile);
         FileWriter filewriter = new FileWriter("newfile.xml");
         for(int loopIndex = 0; loopIndex < numberLines; loopIndex++){
            filewriter.write(displayText[loopIndex].toCharArray());
            filewriter.write('\n');
            System.out.println(displayText[loopIndex].toString());
         }
         filewriter.close();
      } catch (Exception e) {
         e.printStackTrace(System.err);
      }
   }

   public void childLoop(File input){
      DefaultHandler handler = this;
      SAXParserFactory factory = SAXParserFactory.newInstance();
      try {
         SAXParser saxParser = factory.newSAXParser();
         saxParser.parse(input, handler);
      } catch (Throwable t) {}
   }

   public void startDocument() {
      displayText[numberLines] = indentation;
      displayText[numberLines] += "<?xml version=\"1.0\" encoding=\""+
         "UTF-8" + "\"?>";
      numberLines++;
   }

   public void processingInstruction(String target, String data) {
      displayText[numberLines] = indentation;
      displayText[numberLines] += "<?";
      displayText[numberLines] += target;
      if (data != null && data.length() > 0) {
         displayText[numberLines] += ' ';
         displayText[numberLines] += data;
      }
      displayText[numberLines] += "?>";
      numberLines++;
   }

   public void startElement(String uri, String localName,
      String qualifiedName, Attributes attributes) {
      displayText[numberLines] = indentation;

      indentation += "    ";

      displayText[numberLines] += '<';
      displayText[numberLines] += qualifiedName;
      if (attributes != null) {
         int numberAttributes = attributes.getLength();
         for (int loopIndex = 0; loopIndex < numberAttributes;
            loopIndex++){
            displayText[numberLines] += ' ';
            displayText[numberLines] += attributes.getQName(loopIndex);
            displayText[numberLines] += "=\"";
            displayText[numberLines] += attributes.getValue(loopIndex);
            displayText[numberLines] += '"';
         }
      }
      displayText[numberLines] += '>';
      numberLines++;
   }

   public void characters(char characters[], int start, int length) {
      String characterData = (new String(characters, start, length)).trim();
      if(characterData.indexOf("\n") < 0 && characterData.length() > 0) {
         displayText[numberLines] = indentation;
         displayText[numberLines] += characterData;
         numberLines++;
      }
   }

   public void endElement(String uri, String localName, String qualifiedName) {
      indentation = indentation.substring(0, indentation.length() - 4);
      displayText[numberLines] = indentation;
      displayText[numberLines] += "</";
      displayText[numberLines] += qualifiedName;
      displayText[numberLines] += '>';
      numberLines++;

      if (qualifiedName.equals("marks")) {
         startElement("", "Result", "Result", null);
         characters("Pass".toCharArray(), 0, "Pass".length());
         endElement("", "Result", "Result");
      }
   }
}

以上程序将生成以下结果：

<?xml version = "1.0" encoding = "UTF-8"?>
<class>
   <student rollno = "393">
      <firstname>
         Dinkar
      </firstname>

      <lastname>
         Kad
      </lastname>

      <nickname>
         Dinkar
      </nickname>

      <marks>
         85
      </marks>

      <Result>
         Pass
      </Result>
   </student>

   <student rollno = "493">
      <firstname>
         Vineet
      </firstname>

      <lastname>
         Gupta
      </lastname>

      <nickname>
         Vinni
      </nickname>

      <marks>
         95
      </marks>

      <Result>
         Pass
      </Result>
   </student>

   <student rollno = "593">
      <firstname>
         Jasvir
      </firstname>

      <lastname>
         Singh
      </lastname>

      <nickname>
         Jazz
      </nickname>

      <marks>
        90
      </marks>

      <Result>
         Pass
      </Result>
   </student>
</class>

StAX Parser - Overview

StAX 是一个基于 JAVA 的 API，它以与 SAX 解析器类似的方式来解析 XML 文档。但这两个 API 之间有两个主要的差异点 −

StAX 是一种 PULL API，而 SAX 是一种 PUSH API。这意味着对于 StAX 解析器，客户端应用程序需要在需要时要求 StAX 解析器从 XML 中获取信息，而对于 SAX 解析器，当 SAX 解析器通知客户端应用程序信息可用时，则要求客户端应用程序获取信息。
StAX API 可以对 XML 文档进行读取和写入。使用 SAX API，只能读取 xml。

以下是 StAX API 的特性：

从上到下读取 XML 文档，识别构成良好形成的 XML 文档的标记。
标记按其出现在文档中的顺序进行处理。
向应用程序报告解析器遇到的令牌的性质，因为它们会发生。
应用程序提供一个充当迭代器的“事件”读取器，该读取器在事件上进行迭代以获取所需信息。另一个可用的读取器是充当指向 xml 节点的指针的“游标”读取器。
随着事件的标识，可以从事件对象中检索 xml 元素，并可以进一步处理。

When to use?

您应该在以下情况下使用 StAX 解析器：

你可以从上到下线性处理 XML 文档。
文档没有深度嵌套。
你正在处理一个非常大的 XML 文档，其 DOM 树会占用过多的内存。典型的 DOM 实现使用 10 个字节的内存来表示 1 字节的 XML。
需要解决的问题仅涉及 XML 文档的一部分。
解析器一看到数据便立即能用，因此 StAX 非常适用于流式传输的 XML 文档。

Disadvantages of SAX

由于只进行前向处理，因此我们无法随机访问 XML 文档。
如果你需要跟踪解析器看过的数据或更改项目顺序，则必须自己编写代码并存储数据。

XMLEventReader Class

该类提供事件的迭代器，可用在解析 XML 文档时用于迭代遇到的事件

StartElement asStartElement() − 用于检索元素的值和属性。
EndElement asEndElement() − 在元素结尾处调用。
Characters asCharacters() − 可用于获取字符，如 CDATA、空白等。

XMLEventWriter Class

此接口指定用于创建事件的方法。

add(Event event) − 添加包含元素的事件到 XML。

XMLStreamReader Class

这个类提供事件迭代器，它可用于在解析 XML 文档期间迭代事件。

int next() − 用于检索下一个事件。
boolean hasNext() − 用于检查是否存在其他事件
String getText() − 用于获取元素的文本
String getLocalName() − 用于获取元素的名称

XMLStreamWriter Class

此接口指定用于创建事件的方法。

writeStartElement(String localName) − 添加给定名称的开始元素。
writeEndElement(String localName) − 添加给定名称的结束元素。
writeAttribute(String localName, String value) − 向元素写入属性。

StAX Parser - Parse XML Document

Demo Example

下面是需要解析的输入 xml 文件 −

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>Dinkar</firstname>
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>
   </student>

   <student rollno = "493">
      <firstname>Vineet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>

   <student rollno = "593">
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

StAXParserDemo.java

package com.tutorialspoint.xml;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;

public class StAXParserDemo {
   public static void main(String[] args) {
      boolean bFirstName = false;
      boolean bLastName = false;
      boolean bNickName = false;
      boolean bMarks = false;
      try {
         XMLInputFactory factory = XMLInputFactory.newInstance();
         XMLEventReader eventReader =
         factory.createXMLEventReader(new FileReader("input.txt"));

         while(eventReader.hasNext()){
            XMLEvent event = eventReader.nextEvent();
            switch(event.getEventType()){
               case XMLStreamConstants.START_ELEMENT:
                  StartElement startElement = event.asStartElement();
                  String qName = startElement.getName().getLocalPart();
                  if (qName.equalsIgnoreCase("student")) {
                     System.out.println("Start Element : student");
                     Iterator<Attribute> attributes = startElement.getAttributes();
                     String rollNo = attributes.next().getValue();
                     System.out.println("Roll No : " + rollNo);
                  } else if (qName.equalsIgnoreCase("firstname")) {
                     bFirstName = true;
                  } else if (qName.equalsIgnoreCase("lastname")) {
                     bLastName = true;
                  } else if (qName.equalsIgnoreCase("nickname")) {
                     bNickName = true;
                  } else if (qName.equalsIgnoreCase("marks")) {
                     bMarks = true;
                  }
                  break;
               case XMLStreamConstants.CHARACTERS:
                  Characters characters = event.asCharacters();
                  if(bFirstName){
                     System.out.println("First Name: " + characters.getData());
                     bFirstName = false;
                  }
                  if(bLastName){
                     System.out.println("Last Name: " + characters.getData());
                     bLastName = false;
                  }
                  if(bNickName){
                     System.out.println("Nick Name: " + characters.getData());
                     bNickName = false;
                  }
                  if(bMarks){
                     System.out.println("Marks: " + characters.getData());
                     bMarks = false;
                  }
                  break;
               case XMLStreamConstants.END_ELEMENT:
                  EndElement endElement = event.asEndElement();
                  if(endElement.getName().getLocalPart().equalsIgnoreCase("student")){
                     System.out.println("End Element : student");
                     System.out.println();
                  }
                  break;
            }
         }
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (XMLStreamException e) {
         e.printStackTrace();
      }
   }
}

以上程序将生成以下结果：

Start Element : student
Roll No : 393
First Name: Dinkar
Last Name: Kad
Nick Name: Dinkar
Marks: 85
End Element : student

Start Element : student
Roll No : 493
First Name: Vineet
Last Name: Gupta
Nick Name: Vinni
Marks: 95
End Element : student

Start Element : student
Roll No : 593
First Name: Jasvir
Last Name: Singh
Nick Name: Jazz
Marks: 90
End Element : student

StAX Parser - Query XML Document

Demo Example

下面是需要解析的输入 xml 文件 −

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>Dinkar</firstname>
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>
   </student>

   <student rollno = "493">
      <firstname>Vineet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>

   <student rollno = "593">
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

StAXParserDemo.java

package com.tutorialspoint.xml;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;

public class StAXQueryDemo {
   public static void main(String[] args) {
      boolean bFirstName = false;
      boolean bLastName = false;
      boolean bNickName = false;
      boolean bMarks = false;
      boolean isRequestRollNo = false;
      try {
         XMLInputFactory factory = XMLInputFactory.newInstance();
         XMLEventReader eventReader = factory.createXMLEventReader(
            new FileReader("input.txt"));

         String requestedRollNo = "393";
         while(eventReader.hasNext()){
            XMLEvent event = eventReader.nextEvent();
            switch(event.getEventType()){
               case XMLStreamConstants.START_ELEMENT:
                  StartElement startElement = event.asStartElement();
                  String qName = startElement.getName().getLocalPart();
                  if (qName.equalsIgnoreCase("student")) {
                     Iterator<Attribute> attributes = startElement.getAttributes();
                     String rollNo = attributes.next().getValue();
                     if(rollNo.equalsIgnoreCase(requestedRollNo)){
                        System.out.println("Start Element : student");
                        System.out.println("Roll No : " + rollNo);
                        isRequestRollNo = true;
                     }
                  } else if (qName.equalsIgnoreCase("firstname")) {
                     bFirstName = true;
                  } else if (qName.equalsIgnoreCase("lastname")) {
                     bLastName = true;
                  } else if (qName.equalsIgnoreCase("nickname")) {
                     bNickName = true;
                  } else if (qName.equalsIgnoreCase("marks")) {
                     bMarks = true;
                  }
                  break;
               case XMLStreamConstants.CHARACTERS:
                  Characters characters = event.asCharacters();
                  if(bFirstName && isRequestRollNo){
                     System.out.println("First Name: " + characters.getData());
                     bFirstName = false;
                  }
                  if(bLastName && isRequestRollNo){
                     System.out.println("Last Name: " + characters.getData());
                     bLastName = false;
                  }
                  if(bNickName && isRequestRollNo){
                     System.out.println("Nick Name: " + characters.getData());
                     bNickName = false;
                  }
                  if(bMarks && isRequestRollNo){
                     System.out.println("Marks: " + characters.getData());
                     bMarks = false;
                  }
                  break;
               case  XMLStreamConstants.END_ELEMENT:
                  EndElement endElement = event.asEndElement();
                  if(endElement.getName().getLocalPart().equalsIgnoreCase("student") && isRequestRollNo){
                     System.out.println("End Element : student");
                     System.out.println();
                     isRequestRollNo = false;
                  }
                  break;
            }
         }
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (XMLStreamException e) {
         e.printStackTrace();
      }
   }
}

以上程序将生成以下结果：

Start Element : student
Roll No : 393
First Name: Dinkar
Last Name: Kad
Nick Name: Dinkar
Marks: 85
End Element : student

StAX Parser - Create XML Document

Demo Example

Here is the XML we need to create −

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
   <cars><supercars company = "Ferrari">
   <carname type = "formula one">Ferrari 101</carname>
   <carname type = "sports">Ferrari 202</carname>
</supercars></cars>

Demo Example

StAXCreateXMLDemo.java

package com.tutorialspoint.xml;

import java.io.IOException;
import java.io.StringWriter;

import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;

public class StAXCreateXMLDemo {
   public static void main(String[] args) {
      try {
         StringWriter stringWriter = new StringWriter();

         XMLOutputFactory xMLOutputFactory = XMLOutputFactory.newInstance();
         XMLStreamWriter xMLStreamWriter = xMLOutputFactory.createXMLStreamWriter(stringWriter);

         xMLStreamWriter.writeStartDocument();
         xMLStreamWriter.writeStartElement("cars");

         xMLStreamWriter.writeStartElement("supercars");
         xMLStreamWriter.writeAttribute("company", "Ferrari");

         xMLStreamWriter.writeStartElement("carname");
         xMLStreamWriter.writeAttribute("type", "formula one");
         xMLStreamWriter.writeCharacters("Ferrari 101");
         xMLStreamWriter.writeEndElement();

         xMLStreamWriter.writeStartElement("carname");
         xMLStreamWriter.writeAttribute("type", "sports");
         xMLStreamWriter.writeCharacters("Ferrari 202");
         xMLStreamWriter.writeEndElement();

         xMLStreamWriter.writeEndElement();
         xMLStreamWriter.writeEndDocument();

         xMLStreamWriter.flush();
         xMLStreamWriter.close();

         String xmlString = stringWriter.getBuffer().toString();

         stringWriter.close();

         System.out.println(xmlString);

      } catch (XMLStreamException e) {
         e.printStackTrace();
      } catch (IOException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   }
}

以上程序将生成以下结果：

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars><supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars></cars>

StAX Parser - Modify XML Document

Demo Example

为了运行此示例，您应该在应用程序的类路径中有 jdom.jar。下载 jdom-2.0.5.zip.

以下是我们要修改的 XML -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>Dinkar</firstname>
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>
   </student>

   <student rollno = "493">
      <firstname>Vineet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>

   <student rollno = "593">
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

Demo Example

StAXModifyDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;

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 StAXModifyDemo {
   public static void main(String[] args) {

      try {
         XMLInputFactory factory = XMLInputFactory.newInstance();
         XMLEventReader eventReader =
            factory.createXMLEventReader(
               new FileReader("input.txt"));
         SAXBuilder saxBuilder = new SAXBuilder();
         Document document = saxBuilder.build(new File("input.txt"));
         Element rootElement = document.getRootElement();
         List<Element> studentElements = rootElement.getChildren("student");
         while(eventReader.hasNext()){
            XMLEvent event = eventReader.nextEvent();
            switch(event.getEventType()){
               case XMLStreamConstants.START_ELEMENT:
               StartElement startElement = event.asStartElement();
               String qName = startElement.getName().getLocalPart();

               if (qName.equalsIgnoreCase("student")) {
                  Iterator<Attribute> attributes = startElement.getAttributes();
                  String rollNo = attributes.next().getValue();
                  if(rollNo.equalsIgnoreCase("393")){
                     //get the student with roll no 393
                     for(int i=0;i < studentElements.size();i++){
                        Element studentElement = studentElements.get(i);
                        if(studentElement.getAttribute("rollno").getValue().equalsIgnoreCase("393")){
                           studentElement.removeChild("marks");
                           studentElement.addContent(new Element("marks").setText("80"));
                        }
                    }
                  }
               }
               break;
            }
         }
         XMLOutputter xmlOutput = new XMLOutputter();
         // display xml
         xmlOutput.setFormat(Format.getPrettyFormat());
         xmlOutput.output(document, System.out);
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (XMLStreamException e) {
         e.printStackTrace();
      } catch (JDOMException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

以上程序将生成以下结果：

<student rollno = "393">
   <firstname>Dinkar</firstname>
   <lastname>Kad</lastname>
   <nickname>Dinkar</nickname>
   <marks>80</marks>
</student>

<student rollno = "493">
   <firstname>Vineet</firstname>
   <lastname>Gupta</lastname>
   <nickname>Vinni</nickname>
   <marks>95</marks>
</student>

<student rollno = "593">
   <firstname>Jasvir</firstname>
   <lastname>Singh</lastname>
   <nickname>Jazz</nickname>
   <marks>90</marks>
</student>