Java中对xml文件的四种解析方式

books.xml

<?xml version="1.0" encoding="utf-8"?>
<bookstore>
    <book id="1">
        <name>冰与火之歌</name>
        <author>乔治马丁</author>
        <year>2014</year>
        <price>88</price>
    </book>
    <book id="2">
        <name>安徒生童话</name>
        <year>2004</year>
        <price>83</price>
        <language>English</language>
    </book>
</bookstore>

DOM解析

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class Dom {

	public static void main(String[] args) {
		try {
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			// 创建DocumentBuilder对象
			DocumentBuilder db = dbf.newDocumentBuilder();
			// 通过DocumentBuilder对象的parse方法加载books.xml文件到当前目录下
			Document document = db.parse("books.xml");
			// 获取所有book节点的集合
			NodeList bookList = document.getElementsByTagName("book");
			// 通过nodeList的getLength()可以获取bookList的长度
			System.out.println("一共有" + bookList.getLength() + "本书");
			// 遍历每一个book节点 
			for(int i=0; i<bookList.getLength(); i++) {
				System.out.println("==============开始遍历第" + (i + 1) + "本书的内容================");
				// 通过item(i)方法获取一个book节点，nodeList的索引值从0开始 
				Node book = bookList.item(i);
				// 获取book节点的所有属性集合
				NamedNodeMap attrs = book.getAttributes();
				System.out.println("第" + (i + 1) + "本书一共有" + attrs.getLength() + "个属性");
				// 遍历book的属性
				for(int j=0; j<attrs.getLength(); j++) {
					// 通过item()方法获取book节点的某一个属性
					Node attr = attrs.item(j);
					// 获取属性名
					System.out.print("属性名：" + attr.getNodeName());
					// 获取属性值
					System.out.println("--属性值：" + attr.getNodeValue());
				}
//				// 前提：已经知道book节点有且只能有1个属性
//				// 将book节点进行强制类型转换，转换成Element类型
//				Element book = (Element) bookList.item(i);
//				// 通过getAttribute()方法获取属性值
//				String attrValue = book.getAttribute("id");
//				System.out.println("id属性的属性值为" + attrValue);
				// 解析book节点的子节点
				NodeList childNodes = book.getChildNodes();
				// <>之间的空白也算是一个子节点（是text类型的子节点），所以会输出有9个子节点
				System.out.println("第" + (i + 1) + "本书一共有" + childNodes.getLength() + "个子节点");
				// 遍历childNodes获取每个节点的节点名和节点值
				for(int k=0; k<childNodes.getLength(); k++) {
					// 区分出text类型的node以及element类型的node
					if(childNodes.item(k).getNodeType() == Node.ELEMENT_NODE) {
						// 获取element类型节点的节点名
						System.out.print("第" + (k+ 1) + "个节点的节点名：" + childNodes.item(k).getNodeName());
						// 获取element类型节点的节点值
						// 将会返回null 因为element类型节点的节点值算是该节点的子节点
//						System.out.println(childNodes.item(k).getNodeValue());
						System.out.println("--节点值是：" + childNodes.item(k).getFirstChild().getNodeValue());
						// 得到该子节点中的所有文本信息（该子节点可能包含子节点）
						// 比如<name><a>aa</a>冰与火之歌</name>将会输出“aa冰与火之歌”
//						System.out.println("--节点值是：" + childNodes.item(k).getTextContent());
					}
				}
				System.out.println("==============结束遍历第" + (i + 1) + "本书的内容================");
			}
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

SAX解析

book.java

public class Book {
	private int id;
	private String name;
	private String author;
	private String year;
	private String price;
	private String language;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public String getAuthor() {
		return author;
	}
	public void setAuthor(String author) {
		this.author = author;
	}
	
	public String getYear() {
		return year;
	}
	public void setYear(String year) {
		this.year = year;
	}
	
	public String getPrice() {
		return price;
	}
	public void setPrice(String price) {
		this.price = price;
	}
	
	public String getLanguage() {
		return language;
	}
	public void setLanguage(String language) {
		this.language = language;
	}
}
SAXHandler.java



public class SAXHandler extends DefaultHandler {
	private int index;
	private Book book;
	private List<Book> bookList = new ArrayList<>();
	private String value;
	
	public List<Book> getBookList() {
		return bookList;
	}

	@Override
	public void startDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.startDocument();
		System.out.println("=============开始解析文档==================");
	}
	
	@Override
	public void endDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.endDocument();
		System.out.println("=============结束解析文档==================");
	}
	
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		// TODO Auto-generated method stub
		super.startElement(uri, localName, qName, attributes);
		if(qName.equals("book")) {
		    book = new Book();
			index++;
			System.out.println("=============开始解析第" + (index) + "本书==================");
			int id = Integer.valueOf(attributes.getValue("id"));
			book.setId(id);
		}
	}
	
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		// TODO Auto-generated method stub
		super.endElement(uri, localName, qName);
		if(qName.equals("name")) {
			book.setName(value);
		} else if(qName.equals("author")) {
			book.setAuthor(value);
		} else if(qName.equals("year")) {
			book.setYear(value);
		} else if(qName.equals("price")) {
			book.setPrice(value);
		} else if(qName.equals("language")) {
			book.setLanguage(value);
		}  else if(qName.equals("book")) {
			bookList.add(book);
			book = null;
			System.out.println("=============结束解析第" + (index) + "本书==================");
		}
	}
	
	@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);
	}
}
SAX.java

public class SAX {

	public static void main(String[] args) {
		try {
			SAXParserFactory factory = SAXParserFactory.newInstance();
			SAXParser parser = factory.newSAXParser();
			SAXHandler handler = new SAXHandler();
			parser.parse("books.xml", handler);
			List<Book> bookList = handler.getBookList();
			for(Book book : bookList) {
				System.out.println(book.getId());
				System.out.println(book.getName());
				System.out.println(book.getAuthor());
				System.out.println(book.getYear());
				System.out.println(book.getPrice());
				System.out.println(book.getLanguage());
				System.out.println("===finish=====");
			}
		} catch (ParserConfigurationException | SAXException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
JDOM解析（导jar包）




public class JDOM {
	public static void main(String[] args) {
		List<Book> bookEntityList = new ArrayList<>();
		Book bookEntity = null;
		try {
			// 创建SAXBuilder对象
			SAXBuilder saxBuilder = new SAXBuilder();
		    // 2.创建一个输入流，将xml文件加载到输入流中
			InputStream in = new FileInputStream("books.xml");
			// 3.通过saxBuilder的build方法，将输入流加载到saxBuilder中
			Document document = saxBuilder.build(in);
			// 4.通过document对象获取xml文件的根节点
			Element rootElement = document.getRootElement();
			// 5.获取根节点下的子节点的List集合
			List<Element> bookList = rootElement.getChildren();
			for(Element book : bookList) {
				bookEntity = new Book();
				System.out.println("===========开始解析第" + (bookList.indexOf(book) + 1) + "本书============");
				// 解析book的属性集合
				List<Attribute> attrList = book.getAttributes();
				for(Attribute attr : attrList) {
					String attrName = attr.getName();
					String attrValue = attr.getValue();
					System.out.println("属性名：" + attrName + "----属性值：" + attrValue);
					if(attrName.equals("id")) {
						bookEntity.setId(Integer.valueOf(attrValue));
					}
				}
//				String attrValue = book.getAttributeValue("id");
//				System.out.println("属性名：id" + "----属性值：" + attrValue);
				List<Element> bookChildren = book.getChildren();
				for(Element bookChild : bookChildren) {
					String nodeName = bookChild.getName();
					String nodeValue = bookChild.getValue();
					System.out.println("节点名：" + nodeName + "----节点值：" + nodeValue);
					if(nodeName.equals("name")) {
						bookEntity.setName(nodeValue);
					} else if(nodeName.equals("author")) {
						bookEntity.setAuthor(nodeValue);
					} else if(nodeName.equals("year")) {
						bookEntity.setYear(nodeValue);
					} else if(nodeName.equals("price")) {
						bookEntity.setPrice(nodeValue);
					} else if(nodeName.equals("language")) {
						bookEntity.setLanguage(nodeValue);
					}
				}
				System.out.println("===========结束解析第" + (bookList.indexOf(book) + 1) + "本书============");
				bookEntityList.add(bookEntity);
			}
		} 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();
		}
		System.out.println(bookEntityList);
	}
}
book.java同上



DOM4J解析（导jar包）
public class DOM4J {

	public static void main(String[] args) {
		int index = 0;
		// 创建SAXReader对象
		SAXReader saxReader = new SAXReader();
		try {
			// 通过saxReader的read方法加载books.xml对象
			Document document = saxReader.read(new File("books.xml"));
			// 获取根节点
			Element bookStore =  document.getRootElement();
			// 获取迭代器
			Iterator<Element> it = bookStore.elementIterator();
			while(it.hasNext()) {
				index++;
				System.out.println("===========开始解析第" + index + "本书=================");
				Element book = it.next();
				List<Attribute> attrList = book.attributes();
				for(Attribute attr : attrList) {
					String name = attr.getName();
					String value = attr.getValue();
					System.out.println("属性名：" + name + "--属性值：" + value);
				}
				Iterator<Element> it2 = book.elementIterator();
				while(it2.hasNext()) {
					Element node = it2.next();
					String name = node.getName();
					String value = node.getStringValue();
					System.out.println("节点名：" + name + "--节点值：" + value);
				}
				System.out.println("===========结束解析第" + index + "本书=================");
			}
		} catch (DocumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}
4种解析方法的分析

DOM：
平台无关的官方解析方式，不只在java中适用
优点：  1.形成了树结构，直观好理解，代码更易编写
	2.解析过程中树结构保留在内存中，方便修改
缺点：  当xml文件较大时，对内存耗费比较大，容易影响解析性能并造成内存溢出
SAX：

基于事件驱动的解析方法，平台无关的官方解析方式，不只在java中适用
优点：  1.采用事件驱动模式，对内存耗费比较小
	2.适用于只需要处理xml中数据时
缺点：  1.不易编码
	2.很难同时访问同一个xml中的多处不同数据


JDOM：
在SAX上扩展出来的解析方法，只有java中能够使用
优点：  1.仅使用具体类而不使用接口
	2.API大量使用了Collections类
DOM4J：



在SAX上扩展出来的解析方法，只有java中能够使用
优点：  1.JDOM的一种智能分支，它合并了许多超出基本xml文档表示的内容
	2.DOM4J使用接口和抽象基本类方法，是一个优秀的Java XML API
关于解析速度：
对于上述的books.xml
解析速度SAX>DOM>DOM4J>JDOM
book.xml文件小，所以解析速度DOM>DOM4J
DOM4J比起DOM优势在于能更快解析较复杂的xml文件，不妨增加books.xml的内容试试看




以上内容总结自慕课网Java基础路径之《Java眼中的XML-文件读取》

https://github.com/LuJN/DOMTest

https://github.com/LuJN/SAXTest