XML是一种通用的数据交换格式,它的平台无关性、语言无关性、系统无关性、给数据集成与交互带来了极大的方便。XML在不同的语言环境中解析方式都是一样的,只不过实现的语法不同而已。
XML解析——Java中XML的四种解析方式
XML的解析方式分为四种:1、DOM解析;2、SAX解析;3、JDOM解析;4、DOM4J解析。其中前两种属于基础方法,是官方提供的平台无关的解析方式;后两种属于扩展方法,它们是在基础的方法上扩展出来的,只适用于java平台。
- DOM方式解析XML
Dom解析是将xml文件全部载入到内存,组装成一颗dom树,然后通过节点以及节点之间的关系来解析xml文件,与平台无关,java提供的一种基础的解析XML文件的API,理解较简单,但是由于整个文档都需要载入内存,不适用于文档较大时。
- SAX方式解析XML
基于事件驱动,逐条解析,适用于只处理xml数据,不易编码,而且很难同时访问同一个文档中的多处不同数据
- JDOM方式解析XML
简化与XML的交互并且比使用DOM实现更快,仅使用具体类而不使用接口因此简化了API,并且易于使用
- DOM4j方式解析XML
JDOM的一种智能分支,功能较强大,建议熟练使用
针对以下XML文件,会对四种方式进行详细描述:
books.xml:
<?xml version=“1.0” encoding=“UTF-8”?>
<bookstore>
<book id=“1”>
<name>冰与火之歌</name>
<author>乔治马丁</author>
<year>2014</year>
<price>89</price>
</book>
<book id=“2”>
<name>安徒生童话</name>
<author>安徒生</author>
<year>2004</year>
<price>77</price>
</book>
<book id=“3”>
<name>think think think</name>
<author>aaa</author>
<year>1997</year>
<price>100</price>
</book>
</bookstore>
bean类:Book.java:
public class Book {
/**
*/
private int id;
private String name;
private String author;
private int year;
private double price;
/**
* @return the id
*/
public int getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(int id) {
this.id = id;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the author
*/
public String getAuthor() {
return author;
}
/**
* @param author the author to set
*/
public void setAuthor(String author) {
this.author = author;
}
/**
* @return the year
*/
public int getYear() {
return year;
}
/**
* @param year the year to set
*/
public void setYear(int year) {
this.year = year;
}
/**
* @return the price
*/
public double getPrice() {
return price;
}
/**
* @param price the price to set
*/
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return “Book [id=” + id + “, name=” + name + “, author=” + author + “, year=” + year + “, price=” + price + “]”;
}
}
一、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分析器还是有很广泛的使用价值的。
优点:
1、形成了树结构,有助于更好的理解、掌握,且代码容易编写。
2、解析过程中,树结构保存在内存中,方便修改。
缺点:
1、由于文件是一次性读取,所以对内存的耗费比较大。
2、如果XML文件比较大,容易影响解析性能且可能会造成内存溢出。
以下是解析代码:
/**
* 用DOM方式读取xml文件
*/
public class ReadxmlByDom {
private static DocumentBuilderFactory dbFactory = null;
private static DocumentBuilder db = null;
private static Document document = null;
private static List<Book> books = null;
static{
try {
dbFactory = DocumentBuilderFactory.newInstance();
db = dbFactory.newDocumentBuilder();
} catch (ParserConfigurationException e) {
e.printStackTrace();
}
}
public static List<Book> getBooks(String fileName) throws Exception{
//将给定 URI 的内容解析为一个 XML 文档,并返回Document对象
document = db.parse(fileName);
//按文档顺序返回包含在文档中且具有给定标记名称的所有 Element 的 NodeList
NodeList bookList = document.getElementsByTagName(”book”);
books = new ArrayList<Book>();
//遍历books
for(int i=0;i<bookList.getLength();i++){
Book book = new Book();
//获取第i个book结点
org.w3c.dom.Node node = bookList.item(i);
//获取第i个book的所有属性
NamedNodeMap namedNodeMap = node.getAttributes();
//获取已知名为id的属性值
String id = namedNodeMap.getNamedItem(”id”).getTextContent();//System.out.println(id);
book.setId(Integer.parseInt(id));
//获取book结点的子节点,包含了Test类型的换行
NodeList cList = node.getChildNodes();//System.out.println(cList.getLength());9
//将一个book里面的属性加入数组
ArrayList<String> contents = new ArrayList<>();
for(int j=1;j<cList.getLength();j+=2){
org.w3c.dom.Node cNode = cList.item(j);
String content = cNode.getFirstChild().getTextContent();
contents.add(content);
//System.out.println(contents);
}
book.setName(contents.get(0));
book.setAuthor(contents.get(1));
book.setYear(Integer.parseInt(contents.get(2)));
book.setPrice(Double.parseDouble(contents.get(3)));
books.add(book);
}
return books;
}
public static void main(String args[]){
String fileName = ”src/res/books.xml”;
try {
List<Book> list = ReadxmlByDom.getBooks(fileName);
for(Book book :list){
System.out.println(book);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
二、SAX解析
SAX的全称是Simple APIs for XML,也即XML简单应用程序接口。与DOM不同,SAX提供的访问模式是一种顺序模式,这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时,会触发一系列事件,并激活相应的事件处理函数,应用程序通过这些事件处理函数实现对XML文档的访问,因而SAX接口也被称作事件驱动接口。
优点:
1、采用事件驱动模式,对内存耗费比较小。
2、适用于只处理XML文件中的数据时。
缺点:
1、编码比较麻烦。
2、很难同时访问XML文件中的多处不同数据。
以下是解析代码:
/**
* 用SAX解析xml文件时需要的handler
*/
public class SAXParseHandler extends DefaultHandler {
private List<Book> list; //存放解析到的book数组
private Book book; //存放当前解析的book
private String content = null; //存放当前节点值
/**
* 开始解析xml文档时调用此方法
*/
@Override
public void startDocument() throws SAXException {
super.startDocument();
System.out.println(”开始解析xml文件”);
list = new ArrayList<Book>();
}
/**
* 文档解析完成后调用此方法
*/
@Override
public void endDocument() throws SAXException {
super.endDocument();
System.out.println(”xml文件解析完毕”);
}
/**
* 开始解析节点时调用此方法
*/
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
super.startElement(uri, localName, qName, attributes);
//当节点名为book时,获取book的属性id
if(qName.equals(“book”)){
book = new Book();
String id = attributes.getValue(”id”);//System.out.println(“id值为”+id);
book.setId(Integer.parseInt(id));
}
}
/**
*节点解析完毕时调用此方法
*
*@param qName 节点名
*/
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
super.endElement(uri, localName, qName);
if(qName.equals(“name”)){
book.setName(content);
//System.out.println(“书名”+content);
}else if(qName.equals(“author”)){
book.setAuthor(content);
// System.out.println(“作者”+content);
}else if(qName.equals(“year”)){
book.setYear(Integer.parseInt(content));
// System.out.println(“年份”+content);
}else if(qName.equals(“price”)){
book.setPrice(Double.parseDouble(content));
// System.out.println(“价格”+content);
}else if(qName.equals(“book”)){ //当结束当前book解析时,将该book添加到数组后置为空,方便下一次book赋值
list.add(book);
book = null;
}
}
/**
* 此方法用来获取节点的值
*/
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
super.characters(ch, start, length);
content = new String(ch, start, length);
//收集不为空白的节点值
// if(!content.trim().equals(“”)){
// System.out.println(“节点值为:”+content);
// }
}
public List<Book> getBooks(){
return list;
}
}
/**
* 用SAX方式读取xml文件
*/
public class ReadXmlBySAX {
private static List<Book> books = null;
private SAXParserFactory sParserFactory = null;
private SAXParser parser = null;
public List<Book> getBooks(String fileName) throws Exception{
SAXParserFactory sParserFactory = SAXParserFactory.newInstance();
SAXParser parser = sParserFactory.newSAXParser();
SAXParseHandler handler = new SAXParseHandler();
parser.parse(fileName, handler);
return handler.getBooks();
}
/**
* @param args
*/
public static void main(String[] args) {
try {
books = new ReadXmlBySAX().getBooks(“src/res/books.xml”);
for(Book book:books){
System.out.println(book);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
三、JDOM解析
特征:
1、仅使用具体类,而不使用接口。
2、API大量使用了Collections类。
以下是解析代码:
/**
* 用JDOM方式读取xml文件
*/
public class ReadXMLByJDom {
private List<Book> books = null;
private Book book = null;
public List<Book> getBooks(String fileName){
SAXBuilder saxBuilder = new SAXBuilder();
try {
Document document = saxBuilder.build(new FileInputStream(fileName));
//获取根节点bookstore
Element rootElement = document.getRootElement();
//获取根节点的子节点,返回子节点的数组
List<Element> bookList = rootElement.getChildren();
books = new ArrayList<Book>();
for(Element bookElement : bookList){
book = new Book();
//获取bookElement的属性
List<Attribute> bookAttributes = bookElement.getAttributes();
for(Attribute attribute : bookAttributes){
if(attribute.getName().equals(“id”)){
String id = attribute.getValue(); //System.out.println(id);
book.setId(Integer.parseInt(id));
}
}
//获取bookElement的子节点
List<Element> children = bookElement.getChildren();
for(Element child : children){
if(child.getName().equals(“name”)){
String name = child.getValue();//System.out.println(name);
book.setName(name);
}else if(child.getName().equals(“author”)){
String author = child.getValue();
book.setAuthor(author);//System.out.println(author);
}else if(child.getName().equals(“year”)){
String year = child.getValue();
book.setYear(Integer.parseInt(year));
}else if(child.getName().equals(“price”)){
String price = child.getValue();
book.setPrice(Double.parseDouble(price));
}
}
books.add(book);
book = null;
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return books;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
String fileName = ”src/res/books.xml”;
List<Book> books= new ReadXMLByJDom().getBooks(fileName);
for(Book book : books){
System.out.println(book);
}
}
}
4、DOM4J解析
特征:
1、JDOM的一种智能分支,它合并了许多超出基本XML文档表示的功能。
2、它使用接口和抽象基本类方法。
3、具有性能优异、灵活性好、功能强大和极端易用的特点。
4、是一个开放源码的文件
以下是解析代码:
/**
* 用DOM4J方法读取xml文件
*/
public class ReadXMLByDom4j {
private List<Book> bookList = null;
private Book book = null;
public List<Book> getBooks(File file){
SAXReader reader = new SAXReader();
try {
Document document = reader.read(file);
Element bookstore = document.getRootElement();
Iterator storeit = bookstore.elementIterator();
bookList = new ArrayList<Book>();
while(storeit.hasNext()){
book = new Book();
Element bookElement = (Element) storeit.next();
//遍历bookElement的属性
List<Attribute> attributes = bookElement.attributes();
for(Attribute attribute : attributes){
if(attribute.getName().equals(“id”)){
String id = attribute.getValue();//System.out.println(id);
book.setId(Integer.parseInt(id));
}
}
Iterator bookit = bookElement.elementIterator();
while(bookit.hasNext()){
Element child = (Element) bookit.next();
String nodeName = child.getName();
if(nodeName.equals(“name”)){
//System.out.println(child.getStringValue());
String name = child.getStringValue();
book.setName(name);
}else if(nodeName.equals(“author”)){
String author = child.getStringValue();
book.setAuthor(author);
}else if(nodeName.equals(“year”)){
String year = child.getStringValue();
book.setYear(Integer.parseInt(year));
}else if(nodeName.equals(“price”)){
String price = child.getStringValue();
book.setPrice(Double.parseDouble(price));
}
}
bookList.add(book);
book = null;
}
} catch (DocumentException e) {
e.printStackTrace();
}
return bookList;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
File file = new File(“src/res/books.xml”);
List<Book> bookList = new ReadXMLByDom4j().getBooks(file);
for(Book book : bookList){
System.out.println(book);
}
}
}
Final:比较总结
DOM4J性能最好,连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J,例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性,那就采用DOM4J。
JDOM和DOM在性能测试时表现不佳,在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM。虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题,但是从性能观点来看,它确实没有值得推荐之处。另外,DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础,因为它正式获得W3C推荐(与基于非标准的Java模型相对),所以在某些类型的项目中可能也需要它(如在JavaScript中使用DOM)。
SAX表现较好,这要依赖于它特定的解析方式-事件驱动。一个SAX检测即将到来的XML流,但并没有载入到内存(当然当XML流被读入时,会有部分文档暂时隐藏在内存中)。