SAX（Simple API for XML）是一种基于事件驱动的XML解析技术，解析过程中会逐行读取XML内容，遇到元素开始、元素结束、文本内容等节点时触发对应的回调方法，不需要将整个XML文档加载到内存中，因此非常适合处理体积较大的XML文件。
SAX解析的核心组件
使用SAX解析XML主要需要用到以下几个核心类：
- XMLReader：SAX解析的核心驱动类，负责读取XML文件并触发对应的事件
- DefaultHandler：SAX提供的默认事件处理适配器类，我们可以继承它并重写需要的方法来实现自定义的解析逻辑
- SAXParserFactory：用于创建SAX解析器的工厂类
需要重写的DefaultHandler方法
继承DefaultHandler之后，通常需要重写以下几个方法：
startDocument()：文档开始解析时触发endDocument()：文档解析结束时触发startElement(String uri, String localName, String qName, Attributes attributes)：遇到元素开始标签时触发，qName是元素名称，attributes是元素的属性集合endElement(String uri, String localName, String qName)：遇到元素结束标签时触发characters(char[] ch, int start, int length)：遇到元素文本内容时触发
完整示例代码
1. 待解析的XML文件示例
假设我们有一个名为users.xml的文件，内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<users>
<user id="1">
<name>张三</name>
<age>25</age>
<email>zhangsan@ipipp.com</email>
</user>
<user id="2">
<name>李四</name>
<age>28</age>
<email>lisi@ipipp.com</email>
</user>
</users>
2. 自定义SAX解析处理器
我们创建一个继承DefaultHandler的类，实现自定义的解析逻辑：
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import java.util.ArrayList;
import java.util.List;
public class UserHandler extends DefaultHandler {
// 存储解析出的用户列表
private List<User> userList = new ArrayList<>();
// 当前解析的用户对象
private User currentUser;
// 当前解析的元素名称
private String currentElement;
// 文档开始解析时调用
@Override
public void startDocument() throws SAXException {
System.out.println("开始解析XML文档");
}
// 文档解析结束时调用
@Override
public void endDocument() throws SAXException {
System.out.println("XML文档解析结束");
}
// 遇到元素开始标签时调用
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
currentElement = qName;
// 如果是user元素开始，创建新的User对象
if ("user".equals(qName)) {
currentUser = new User();
// 获取id属性
String id = attributes.getValue("id");
currentUser.setId(Integer.parseInt(id));
}
}
// 遇到元素结束标签时调用
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
// 如果是user元素结束，将当前用户添加到列表
if ("user".equals(qName)) {
userList.add(currentUser);
currentUser = null;
}
currentElement = null;
}
// 遇到元素文本内容时调用
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
if (currentElement == null || currentUser == null) {
return;
}
String content = new String(ch, start, length).trim();
if (content.length() == 0) {
return;
}
// 根据当前元素名称赋值
switch (currentElement) {
case "name":
currentUser.setName(content);
break;
case "age":
currentUser.setAge(Integer.parseInt(content));
break;
case "email":
currentUser.setEmail(content);
break;
}
}
// 获取解析后的用户列表
public List<User> getUserList() {
return userList;
}
// 内部用户实体类
static class User {
private int id;
private String name;
private int age;
private String email;
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User{id=" + id + ", name='" + name + "', age=" + age + ", email='" + email + "'}";
}
}
}
3. 主程序调用解析逻辑
编写主程序来触发SAX解析流程：
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.File;
import java.util.List;
public class SAXReadXMLDemo {
public static void main(String[] args) {
try {
// 创建SAX解析器工厂
SAXParserFactory factory = SAXParserFactory.newInstance();
// 获取SAX解析器
SAXParser saxParser = factory.newSAXParser();
// 创建自定义处理器
UserHandler handler = new UserHandler();
// 解析XML文件，传入文件和处理器
saxParser.parse(new File("users.xml"), handler);
// 获取解析结果并输出
List<UserHandler.User> userList = handler.getUserList();
for (UserHandler.User user : userList) {
System.out.println(user);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
代码运行结果
执行上述主程序后，控制台会输出以下内容：
开始解析XML文档
XML文档解析结束
User{id=1, name='张三', age=25, email='zhangsan@ipipp.com'}
User{id=2, name='李四', age=28, email='lisi@ipipp.com'}
SAX解析的优缺点
SAX解析的主要优点：
- 内存占用低，不需要加载整个XML文档到内存，适合大文件解析
- 解析速度快，逐行读取处理，没有额外的内存开销
主要缺点：
- 只能顺序读取XML内容，无法随机访问某个节点
- 没有将XML结构转化为树形对象，如果需要多次使用解析后的数据，需要自己存储
- 编写回调逻辑相对复杂，不如DOM解析直观