解析XML文件

解析XML文件

在java程序中读取XML文件的过程称为解析XML

解析XML文件的方式

1）DOM解析

操作步骤：

①创建一个DocumentBuilderFactory对象
②创建一个DocumentBuilder对象
③通过DocumentBuilder的parse(...)方法得到Document对象
④通过getElementsByTagName(...)方法获取到节点列表
⑤通过for循环遍历每一个节点
⑥得到每一个节点的属性和属性值
⑦得到每一个节点的节点名和节点值

public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
		//1.创建一个DocumentBuilderFactory对象
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		//2.创建一个DocumentBuilder对象
		DocumentBuilder db =dbf.newDocumentBuilder();
		//3.调用DocumentBuilder的parse(...)方法得到Document对象
		Document doc = db.parse("book.xml");
		//4.通过getElementsByTagName(...)方法获取到节点的列表
		NodeList bookList = doc.getElementsByTagName("book");//得到book节点
		//5.for循环遍历每一个节点
		for(int i =0;i<bookList.getLength();i++) {
			//6.得到每个节点的属性和属性值
			Node book = bookList.item(i);
			NamedNodeMap attrs = book.getAttributes();//得到了属性的集合
			//循环比例属性
			for(int j = 0;j<attrs.getLength();j++) {
				//得到每一个属性
				Node id = attrs.item(j);
				System.out.println("属性的名称："+id.getNodeName()+"\t"+id.getNodeValue());
			}
		}
		System.out.println("\n每个节点的名称和节点的值");
		//7.得到每个节点的节点名和节点值
		for(int i=0;i<bookList.getLength();i++) {
			
			//得到每一个book节点
			Node book = bookList.item(i);
			NodeList subNode = book.getChildNodes();
//			System.out.println("子节点个数为:"+subNode.getLength());
			//for循环遍历每个book的子节点
			for(int j=0;j<subNode.getLength();j++) {
				Node childNode = subNode.item(j);
				short type = childNode.getNodeType();//获取节点的类型
				if(type==Node.ELEMENT_NODE) {
					System.out.println("属性为："+childNode.getNodeName()+"\t"+childNode.getTextContent());
				}
				//System.out.println(childNode.getNodeName());
			}
		}

	}

运行结果：

代码中两次循环得到book节点，一次是为了输出book特有的id属性；另一次是为了找到book下的子节点，以便于输出子节点的属性及其属性值。

2）SAX解析

SAX，全称Simple API for XML，是一种以事件驱动的XMLAPI，SAX与DOM不同的是它边扫描边解析，自顶向下依次解析，由于边扫描边解析，所以解析XML具有速度快，占用内存小的优点。

操作步骤：

①创建SAXParserFactory的对象
②创建SAXParser对象（解析器）
③创建一个DefaultHandler的子类
④调用parse方法

public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
		//1.创建SAXParserFactory对象
		SAXParserFactory spf = SAXParserFactory.newInstance();
		//2.创建SAXParser对象（解析器）
		SAXParser parser = spf.newSAXParser();
		//3.创建一个DefaultHandler的子类
		BookDefaultHandler bdh = new BookDefaultHandler();
	
		//4.调用parse方法
		parser.parse("book.xml", bdh);
	}

public class BookDefaultHandler extends DefaultHandler{
	/**
	 * 解析开始时调用
	 */
	@Override
	public void startDocument() throws SAXException {
		super.startDocument();
	}
	/**
	 * 解析XML文档结束时调用
	 */
	@Override
	public void endDocument() throws SAXException {
		super.endDocument();

	}
	/**
	 * 解析xml文档中的节点时调用
	 */
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		super.startElement(uri, localName, qName, attributes);
//		System.out.println("解析xml文档中的节点时调用");
		/*判断  如果是book节点 获取节点的属性和值*/
		if("book".equals(qName)) {//qName  标签的name
			//获取所有的属性
			int count = attributes.getLength();//属性的个数
			for(int i=0;i<count;i++) {
				String attName = attributes.getQName(i);//属性名称
				String attValue = attributes.getValue(i);//属性值
				System.out.println(attName+"-"+attValue);
			}
		}else if(!"books".equals(qName)&&!"book".equals(qName)) {
			System.out.print(qName+"-");
		}
	}
	/**
	 * 解析xml文档中的节点结束时调用
	 */
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		super.endElement(uri, localName, qName);
	}
	
	//输出value值
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		super.characters(ch, start, length);
		String value = new String(ch,start,length);
		if(!"".equals(value.trim())){
			System.out.println(value);
		}
	}
}

运行结果：

3）JDOM解析

操作步骤：

①创建一个SAXBuilder对象
②调用build方法，得到Document对象（通过IO流）
③获取根节点
④获取根节点的直接子节点集合
⑤遍历集合

package com.lmd.jdom;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;

import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

public class TestJDOM {
	public static void main(String[] args) throws FileNotFoundException, JDOMException, IOException {
		//1.创建SAXBuilder对象
		SAXBuilder sb = new SAXBuilder();
		//2.调用build方法，得到Document对象（通过IO流）
		Document doc = sb.build(new FileInputStream("book.xml"));
		//3.获取根节点
		Element root = doc.getRootElement();//books节点
		//4.获取根节点的直接子节点集合
		List<Element> bookEle = root.getChildren();
		//5.遍历集合
		for(int i =0;i<bookEle.size();i++) {
			Element book = bookEle.get(i);
			//得到属性集合
			List<Attribute> attList = book.getAttributes();
			//遍历属性的集合得到每一个属性
			for (Attribute attribute : attList) {
				System.out.println(attribute.getName()+"-"+attribute.getValue());
			}
		}
		
		//得到每一个子节点
		System.out.println("--------------------");
		for(int i=0;i<bookEle.size();i++) {
			Element book = bookEle.get(i);
			List<Element> subBook = book.getChildren();
			for (Element element : subBook) {
				System.out.println(element.getName()+"-"+element.getValue());
			}
			System.out.println();
		}
	}
}

运行结果

本方法需要导入jdom.jar包，导入方法自行搜索。

4）DOM4J解析

操作步骤：

①创建SAXReader对象
②调用read方法
③获取根元素
④通过迭代器遍历直接节点

public static void main(String[] args) throws FileNotFoundException, DocumentException {
		//1.创建SAXReader对象
		SAXReader sr = new SAXReader();
		//2.调用read方法
		Document doc = sr.read(new FileInputStream("book.xml"));
		//3.获取根元素
		Element root = doc.getRootElement();//books
		//4.通过迭代器遍历直接节点
		
		for (Iterator<Element> iteBook = root.elementIterator();iteBook.hasNext();) {
			Element bookEle = iteBook.next();
//			System.out.println(bookEle.getName());
			//得到book的属性
			for (Iterator<Attribute> IteAtt = bookEle.attributeIterator();IteAtt.hasNext();) {
				Attribute att = IteAtt.next();
				System.out.println(att.getName()+"\t"+att.getValue());
			}
		}
		//得到每一个子节点的名称和属性值
		System.out.println("-----------");
		List<Book> bookList = new ArrayList<>();
		for(Iterator<Element> iteBook=root.elementIterator();iteBook.hasNext();) {
			//创建Book对象
			Book book = new Book();
			Element bookEle = iteBook.next();//得到每一个book
			//使用for循环继续遍历
			for(Iterator<Element> subBookEle=bookEle.elementIterator();subBookEle.hasNext();) {
				Element ele = subBookEle.next();
				System.out.println(ele.getName()+"\t"+ele.getText());
				/**
				 * 封装成Book对象
				 * */
				String nodeName = ele.getName();
				//switch判断
				switch (nodeName) {
				case "name":
					book.setName(ele.getText());
					break;
				case "author":
					book.setAuthor(ele.getText());
					break;
				case "price":
					book.setPrice(Double.parseDouble(ele.getText()));
					break;
				}
			}
			//添加到集合中
			bookList.add(book);
		}
		System.out.println("遍历book集合");
		for (Book book : bookList) {
			System.out.println(book);
		}
	}

public class Book {
	private String name;
	private String author;
	private Double price;
	
	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 Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	
	public Book(String name, String author, Double price) {
		super();
		this.name = name;
		this.author = author;
		this.price = price;
	}
	
	public Book() {
		super();
	}
	@Override
	public String toString() {
		return "Book [name=" + name + ", author=" + author + ", price=" + price + "]";
	}
}

运行结果：

本方法除了将XML文件解析外，还将XML信息封装到Book实体中，以便于后续的操作使用。