原文：http://zetcode.com/java/sax/

Java SAX 教程展示了如何使用 Java SAX API 来读取和验证 XML 文档。

SAX

SAX（XML 的简单 API）是事件驱动的算法，用于解析 XML 文档。 SAX 是文档对象模型（DOM）的替代方法。 在 DOM 读取整个文档以对 XML 进行操作的地方，SAX 解析器逐个节点读取 XML，发出解析事件，同时逐步遍历输入流。 SAX 独立于状态处理文档（元素的处理不依赖于之前的元素）。 SAX 解析器是只读的。

SAX 解析器更快并且需要更少的内存。 另一方面，DOM 更易于使用，并且有些任务（例如，排序元素，重新排列元素或查找元素）使用 DOM 更快。

SADK 解析器是 JDK 附带的，因此不需要下载依赖项。

Java SAX 解析示例

在下面的示例中，我们使用 SAX 解析器读取 XML 文件。

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.codehaus.mojo</groupId>
  5.             <artifactId>exec-maven-plugin</artifactId>
  6.             <version>1.6.0</version>
  7.             <configuration>
  8.                 <mainClass>com.zetcode.JavaReadXmlSaxEx</mainClass>
  9.             </configuration>
  10.         </plugin>
  11.     </plugins>
  12. </build>

我们使用exec-maven-plugin从 Maven 执行 Java 主类。

users.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <users>
  3.     <user id="1">
  4.         <firstname>Peter</firstname>
  5.         <lastname>Brown</lastname>
  6.         <occupation>programmer</occupation>
  7.     </user>
  8.     <user id="2">
  9.         <firstname>Martin</firstname>
  10.         <lastname>Smith</lastname>
  11.         <occupation>accountant</occupation>
  12.     </user>
  13.     <user id="3">
  14.         <firstname>Lucy</firstname>
  15.         <lastname>Gordon</lastname>
  16.         <occupation>teacher</occupation>
  17.     </user>    
  18. </users>

我们将阅读此 XML 文件。

User.java

  1. package com.zetcode;
  3. public class User {
  5.     int id;
  6.     private String firstName;
  7.     private String lastName;
  8.     private String occupation;
  10.     public User() {
  11.     }
  13.     public int getId() {
  14.         return id;
  15.     }
  17.     public void setId(int id) {
  18.         this.id = id;
  19.     }
  21.     public String getFirstName() {
  22.         return firstName;
  23.     }
  25.     public void setFirstName(String firstName) {
  26.         this.firstName = firstName;
  27.     }
  29.     public String getLastName() {
  30.         return lastName;
  31.     }
  33.     public void setLastName(String lastName) {
  34.         this.lastName = lastName;
  35.     }
  37.     public String getOccupation() {
  38.         return occupation;
  39.     }
  41.     public void setOccupation(String occupation) {
  42.         this.occupation = occupation;
  43.     }
  45.     @Override
  46.     public String toString() {
  48.         StringBuilder builder = new StringBuilder();
  49.         builder.append("User{").append("id=").append(id)
  50.                 .append(", firstName=").append(firstName)
  51.                 .append(", lastName=").append(lastName)
  52.                 .append(", occupation=").append(occupation).append("}");
  54.         return builder.toString();
  55.     }
  56. }

这是用户 bean。 它将保存来自 XML 节点的数据。

MyRunner.java

  1. package com.zetcode;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.nio.file.Paths;
  6. import java.util.List;
  7. import java.util.logging.Level;
  8. import java.util.logging.Logger;
  9. import javax.xml.parsers.ParserConfigurationException;
  10. import javax.xml.parsers.SAXParser;
  11. import javax.xml.parsers.SAXParserFactory;
  12. import org.xml.sax.SAXException;
  14. public class MyRunner {
  16.     private SAXParser createSaxParser() {
  18.         SAXParser saxParser = null;
  20.         try {
  22.             SAXParserFactory factory = SAXParserFactory.newInstance();
  23.             saxParser = factory.newSAXParser();
  25.             return saxParser;
  26.         } catch (ParserConfigurationException | SAXException ex) {
  28.             Logger lgr = Logger.getLogger(MyRunner.class.getName());
  29.             lgr.log(Level.SEVERE, ex.getMessage(), ex);
  30.         }
  32.         return saxParser;
  33.     }
  35.     public List<User> parseUsers() {
  37.         MyHandler handler = new MyHandler();
  38.         String fileName = "src/main/resources/users.xml";
  39.         File xmlDocument = Paths.get(fileName).toFile();
  41.         try {
  43.             SAXParser parser = createSaxParser();
  44.             parser.parse(xmlDocument, handler);
  46.         } catch (SAXException | IOException ex) {
  48.             Logger lgr = Logger.getLogger(MyRunner.class.getName());
  49.             lgr.log(Level.SEVERE, ex.getMessage(), ex);
  50.         }
  52.         return handler.getUsers();
  53.     }
  54. }

MyRunner创建一个 SAX 解析器并启动解析。 parseUsers返回User对象列表中的解析数据。

  1. SAXParserFactory factory = SAXParserFactory.newInstance();
  2. saxParser = factory.newSAXParser();

从SAXParserFactory获得SAXParser。

  1. SAXParser parser = createSaxParser();
  2. parser.parse(xmlDocument, handler);

我们使用parse()方法解析文档。 方法的第二个参数是处理器对象，其中包含事件处理器。

MyHandler.java

  1. package com.zetcode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import org.xml.sax.Attributes;
  6. import org.xml.sax.SAXException;
  7. import org.xml.sax.helpers.DefaultHandler;
  9. public class MyHandler extends DefaultHandler {
  11.     private List<User> users = new ArrayList<>();
  12.     private User user;
  14.     private boolean bfn = false;
  15.     private boolean bln = false;
  16.     private boolean boc = false;
  18.     @Override
  19.     public void startElement(String uri, String localName,
  20.             String qName, Attributes attributes) throws SAXException {
  22.         if ("user".equals(qName)) {
  24.             user = new User();
  26.             int id = Integer.valueOf(attributes.getValue("id"));
  27.             user.setId(id);
  28.         }
  30.         switch (qName) {
  32.             case "firstname":
  33.                 bfn = true;
  34.                 break;
  36.             case "lastname":
  37.                 bln = true;
  38.                 break;
  40.             case "occupation":
  41.                 boc = true;
  42.                 break;
  43.         }
  44.     }
  46.     @Override
  47.     public void characters(char[] ch, int start, int length) throws SAXException {
  49.         if (bfn) {
  50.             user.setFirstName(new String(ch, start, length));
  51.             bfn = false;
  52.         }
  54.         if (bln) {
  55.             user.setLastName(new String(ch, start, length));
  56.             bln = false;
  57.         }
  59.         if (boc) {
  60.             user.setOccupation(new String(ch, start, length));
  61.             boc = false;
  62.         }
  63.     }
  65.     @Override
  66.     public void endElement(String uri, String localName,
  67.             String qName) throws SAXException {
  69.         if ("user".equals(qName)) {
  70.             users.add(user);
  71.         }
  72.     }
  74.     public List<User> getUsers() {
  76.         return users;
  77.     }
  78. }

在MyHandler类中，我们具有事件处理器的实现。

  1. public class MyHandler extends DefaultHandler {

处理器类必须从具有事件方法的DefaultHandler扩展。

  1. @Override
  2. public void startElement(String uri, String localName,
  3.         String qName, Attributes attributes) throws SAXException {
  5.     if ("user".equals(qName)) {
  7.         user = new User();
  9.         int id = Integer.valueOf(attributes.getValue("id"));
  10.         user.setId(id);
  11.     }
  13.     switch (qName) {
  15.         case "firstname":
  16.             bfn = true;
  17.             break;
  19.         case "lastname":
  20.             bln = true;
  21.             break;
  23.         case "occupation":
  24.             boc = true;
  25.             break;
  26.     }
  27. }

当解析器开始解析新元素时，将调用startElement()方法。 如果元素为<user>，我们将创建一个新用户。 对于其他类型的元素，我们设置布尔值。

  1. @Override
  2. public void characters(char[] ch, int start, int length) throws SAXException {
  4.     if (bfn) {
  5.         user.setFirstName(new String(ch, start, length));
  6.         bfn = false;
  7.     }
  9.     if (bln) {
  10.         user.setLastName(new String(ch, start, length));
  11.         bln = false;
  12.     }
  14.     if (boc) {
  15.         user.setOccupation(new String(ch, start, length));
  16.         boc = false;
  17.     }
  18. }

当解析器在元素内部遇到文本时，将调用characters()方法。 根据布尔变量，我们设置用户属性。

  1. @Override
  2. public void endElement(String uri, String localName,
  3.         String qName) throws SAXException {
  5.     if ("user".equals(qName)) {
  6.         users.add(user);
  7.     }
  8. }

在<user>元素的末尾，我们将用户对象添加到用户列表中。

JavaReadXmlSaxEx.java

  1. package com.zetcode;
  3. import java.util.List;
  5. public class JavaReadXmlSaxEx  {
  7.     public static void main(String[] args) {
  9.         MyRunner runner = new MyRunner();
  10.         List<User> lines = runner.parseUsers();
  12.         lines.forEach(System.out::println);
  13.     }
  14. }

JavaReadXmlSaxEx启动应用。 它将解析任务委托给MyRunner。 最后，检索到的数据将打印到控制台。

  1. $ mvn exec:java -q
  2. User{id=1, firstName=Peter, lastName=Brown, occupation=programmer}
  3. User{id=2, firstName=Martin, lastName=Smith, occupation=accountant}
  4. User{id=3, firstName=Lucy, lastName=Gordon, occupation=teacher}

这是示例的输出。

Java SAX 验证示例

以下示例使用 XSD 语言来验证 XML 文件。 XSD（XML 架构定义）是所有 XML 文档和数据的当前标准架构语言。 （还有其他替代的模式语言，例如 DTD 和 RELAX NG。）XSD 是 XML 文档必须遵循的一组规则，以便根据该模式被视为有效。

users.xsd

  1. <?xml version="1.0"?>
  3. <xs:schema version="1.0"
  4.            xmlns:xs="http://www.w3.org/2001/XMLSchema"
  5.            elementFormDefault="qualified">
  7.     <xs:element name="users">
  8.         <xs:complexType>
  9.             <xs:sequence>
  10.                 <xs:element name="user" maxOccurs="unbounded" minOccurs="0">
  11.                     <xs:complexType>
  12.                         <xs:sequence>
  13.                             <xs:element type="xs:string" name="firstname"/>
  14.                             <xs:element type="xs:string" name="lastname"/>
  15.                             <xs:element type="xs:string" name="occupation"/>
  16.                         </xs:sequence>
  17.                         <xs:attribute name="id" type="xs:int" use="required"/>
  18.                     </xs:complexType>
  19.                 </xs:element>
  20.             </xs:sequence>
  21.         </xs:complexType>
  22.     </xs:element>    
  24. </xs:schema>

这是用于验证用户的 XSD 文件。 例如，它声明<user>元素必须在<users>元素之内，或者<user>的id属性必须是且是整数，并且是强制性的。

JavaXmlSchemaValidationEx.java

  1. package com.zetcode;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.io.Reader;
  6. import java.nio.file.Files;
  7. import java.nio.file.Path;
  8. import java.nio.file.Paths;
  9. import java.util.logging.Level;
  10. import java.util.logging.Logger;
  11. import javax.xml.XMLConstants;
  12. import javax.xml.transform.sax.SAXSource;
  13. import javax.xml.validation.Schema;
  14. import javax.xml.validation.SchemaFactory;
  15. import javax.xml.validation.Validator;
  16. import org.xml.sax.InputSource;
  17. import org.xml.sax.SAXException;
  19. public class JavaXmlSchemaValidationEx {
  21.     public static void main(String[] args) {
  23.         File xsdFile = new File("src/main/resources/users.xsd");
  25.         try {
  27.             Path xmlPath = Paths.get("src/main/resources/users.xml");
  28.             Reader reader = Files.newBufferedReader(xmlPath);
  30.             String schemaLang = XMLConstants.W3C_XML_SCHEMA_NS_URI;
  31.             SchemaFactory factory = SchemaFactory.newInstance(schemaLang);
  32.             Schema schema = factory.newSchema(xsdFile);
  34.             Validator validator = schema.newValidator();
  36.             SAXSource source = new SAXSource(new InputSource(reader));
  37.             validator.validate(source);
  39.             System.out.println("The document was validated OK");
  41.         } catch (SAXException ex) {
  43.             Logger lgr = Logger.getLogger(JavaXmlSchemaValidationEx.class.getName());
  44.             lgr.log(Level.SEVERE, "The document failed to validate");
  45.             lgr.log(Level.SEVERE, ex.getMessage(), ex);
  46.         } catch (IOException ex) {
  48.             Logger lgr = Logger.getLogger(JavaXmlSchemaValidationEx.class.getName());
  49.             lgr.log(Level.SEVERE, ex.getMessage(), ex);
  50.         }
  51.     }
  52. }

该示例使用users.xsd模式来验证users.xml文件。

  1. String schemaLang = XMLConstants.W3C_XML_SCHEMA_NS_URI;
  2. SchemaFactory factory = SchemaFactory.newInstance(schemaLang);
  3. Schema schema = factory.newSchema(xsdFile);

使用SchemaFactory，我们为我们的模式定义选择 W3C XML 模式。 换句话说，我们的自定义架构定义还必须遵守某些规则。

  1. Validator validator = schema.newValidator();

从架构生成一个新的验证器。

  1. SAXSource source = new SAXSource(new InputSource(reader));
  2. validator.validate(source);

我们根据提供的模式验证 XML 文档。

  1. } catch (SAXException ex) {
  3.     Logger lgr = Logger.getLogger(JavaXmlSchemaValidationEx.class.getName());
  4.     lgr.log(Level.SEVERE, "The document failed to validate");
  5.     lgr.log(Level.SEVERE, ex.getMessage(), ex);
  6. }

默认情况下，如果文档无效，则抛出SAXException。

在本教程中，我们已使用 Java SAX 阅读并验证了 XML 文档。 您可能也对相关教程感兴趣： Java DOM 教程， Java JAXB 教程， Java JSON 处理教程，提供 XML 的 Java Servlet 和 Java 教程。