什么是xml解析？xml解析的有几种常用的解析方式？

xml解析概述

XML解析主要为两种：DOM和SAX解析
DOM:文档对象模型，这种方式是W3C推荐的处理XML的一种方式
SAX解析不是官方标准，属于开源社区XML-DEV,几乎所有的XML解析器都支持它

XML解析开发包：
JAXP:是sun公司推出的解析标准实现
DOM4J:是开源组织推出的解析开发包（牛，大家都在用，包括SUN公司的一些技术的实现都在用）

JAXP:

JAXP:(Java API for XML Processing)开发包是JavaSE的一部分，它由以下几个包及其子包组成：
org.w3c.dom:提供DOM方式解析XML的标准接口
org.xml.sax:提供SAX方式解析XML的标准接口
javax.xml:提供了解析XML文档的类
javax.xml.parsers包中，定义了几个工厂类。我们可以通过调用这些工厂类，得到对XML文档进行解析的DOM和SAX解析器对象。
DocumentBuilderFactory
SAXParserFactory

javax.xml.parsers 包中的DocumentBuilderFactory用于创建DOM模式的解析器对象 ， DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法 ，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回

JAXP解析流程
调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。

调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象。

调用 DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进行可以利用DOM特性对整个XML文档进行操作了。

重写更新XML文档
javax.xml.transform包中的Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出，例如把xml文件应用样式表后转成一个html文档。利用这个对象，当然也可以把Document对象又重新写入到一个XML文件中。
Transformer类通过transform方法完成转换操作，该方法接收一个源和一个目的地。我们可以通过：
javax.xml.transform.dom.DOMSource类来关联要转换的document对象，
用javax.xml.transform.stream.StreamResult 对象来表示数据的目的地。
Transformer对象通过TransformerFactory获得
代码的具体实现：

package cn.itcast.jaxp;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import cn.itcast.utils.JaxpDomUtil;

/**
 * JAXP的Dom解析xml
 * @author Administrator
 *
 */
public class JaxpDomTest {
    public static void main(String[] args) {
		try {
			run3();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
    //获取作者的文本内容
    public static void run1() throws Exception{
    	//获取解析器工厂类
    	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    	//获取解析器对象
    	DocumentBuilder builder = factory.newDocumentBuilder();
    	//解析xml的文档，返回document对象
    	Document document = builder.parse("src/book2.xml");
    	//获取作者元素对象的集合,返回NodeList
    	NodeList nodeList = document.getElementsByTagName("作者");
    	//循环遍历，拿到每一个作者，打印文本内容，getTextContent()
    	for (int i = 0; i < nodeList.getLength(); i++) {
			Node node = nodeList.item(i);
			System.out.println(node.getTextContent());
		}
    }
    //在末尾添加一个新的节点
    public static void run2() throws Exception{
    	//获取解析器工厂类
    	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    	//获取文件解析器对象
    	DocumentBuilder documentBuilder = factory.newDocumentBuilder();
    	//解析xml文件，获取document对象
    	Document document = documentBuilder.parse("src/book2.xml");
    	//获取第二个对象
    	Node book = document.getElementsByTagName("书").item(1);
    	//创建元素对象
    	Element cat = document.createElement("猫");
    	//设置文本内容
    	cat.setTextContent("我是猫");
    	//将文本添加到元素对象下面
        book.appendChild(cat);
    	//回写
        //创建回写类的工厂
        TransformerFactory transformer = TransformerFactory.newInstance();
        //获取回写类
        Transformer newTransformer = transformer.newTransformer();
        //调用回写的方法
        newTransformer.transform(new DOMSource(document), new StreamResult("src/book2.xml"));
    }
}

由于获得解析器工厂类，获取文件解析器对象，解析XML 获得文件对象，还有其重新方法每次使用都需要调用，故向上封装成了一个工具类，便于开发的时候直接来调用。

DOM4J解析XML文档
Dom4j是一个简单、灵活的开放源代码的库。Dom4j是由早期开发JDOM的人分离出来而后独立开发的。与JDOM不同的是，dom4j使用接口和抽象基类，虽然Dom4j的API相对要复杂一些，但它提供了比JDOM更好的灵活性。
Dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极易使用的特点。现在很多软件采用的Dom4j，例如Hibernate，包括sun公司自己的JAXM也用了Dom4j。
使用Dom4j开发，需下载dom4j相应的jar文件。

DOM4J解析流程：
1.读取XML文件,获得document对象
SAXReader reader = new SAXReader();
Document document = reader.read(new File(“input.xml”));
2.解析XML形式的文本,得到document对象.
String text = “”;
Document document = DocumentHelper.parseText(text);
3.主动创建document对象.
Document document = DocumentHelper.createDocument(); //创建根节点
Element root = document.addElement(“members”);
4.获取文档的根节点.
Element root = document.getRootElement();
5.取得某个节点的子节点.
Element element=node.element(“书名");
6.取得节点的文字
String text=node.getText();
DOM4J的运行代码如下所示：

package cn.itcast.dom4j;

import java.io.FileOutputStream;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
 * dom4j实现对数据的增加节点的操作
 * @author liugang
 *
 */
public class Dom4jTest {
     public static void main(String[] args) {
		   try {
			run5();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	 }
     //修改指定的元素
     public static void run5() throws Exception{
    	 //获取解析器对象
    	 SAXReader reader = new SAXReader();
    	 //解析xml文件,返回document对象
    	 Document document = reader.read("src/book.xml");
    	 //获取跟节点
    	 Element root = document.getRootElement();
    	 //获取第二本书对象
    	 Element book2 = (Element) root.elements("书").get(1);
    	 Element money = book2.element("团购价");
    	 money.setText("1000");
    	 //回写方法
    	 //创建一个好看的对象
    	 OutputFormat format = OutputFormat.createPrettyPrint();
    	 XMLWriter writer =  new XMLWriter(new FileOutputStream("src/book.xml"),format);
    	 writer.write(document);
    	 writer.close();
     }
     //删除指定的元素
     public static void run4() throws Exception{
    	 //获取解析器对象
    	 SAXReader reader = new SAXReader();
    	 //解析xml文件,返回document对象
    	 Document document = reader.read("src/book.xml");
    	 //获取跟节点
    	 Element root = document.getRootElement();
    	 //获取第二本书对象
    	 Element book2 = (Element) root.elements("书").get(1);
    	 Element cat = book2.element("猫");
    	 //删除猫
    	 book2.remove(cat);
    	 //回写方法
    	 //创建一个好看的对象
    	 OutputFormat format = OutputFormat.createPrettyPrint();
    	 XMLWriter writer =  new XMLWriter(new FileOutputStream("src/book.xml"),format);
    	 writer.write(document);
    	 writer.close();
     }
     
     //在指定的位置下添加元素
     public static void run3() throws Exception{
    	 //获取解析器对象
    	 SAXReader reader = new SAXReader();
    	 //解析xml文件,返回document对象
    	 Document document = reader.read("src/book.xml");
    	 //获取跟节点
    	 Element root = document.getRootElement();
    	 //获取第二本书对象
    	 Element book2 = (Element) root.elements("书").get(1);
    	 //获得第二本书下的所有集合
    	 @SuppressWarnings("unchecked")
		 List list = book2.elements();
    	 //创建元素对象，并添加进指定的位置
    	 Element money = DocumentHelper.createElement("团购价");
    	 money.setText("989");
    	 list.add(2,money);
    	 //重写
    	 //创建一个好看的对象
    	 OutputFormat format = OutputFormat.createPrettyPrint();
    	 XMLWriter writer =  new XMLWriter(new FileOutputStream("src/book.xml"),format);
    	 writer.write(document);
    	 writer.close();
     }
     
     //在第二本书下添加子节点
     public static void run2() throws Exception{
    	 //获取解析器对象
    	 SAXReader reader = new SAXReader();
    	 //解析xml文件，返回documet对象
    	 Document document = reader.read("src/book.xml");
    	 //获取根节点
    	 Element root = document.getRootElement();
    	 //获取第二本书对象
    	 @SuppressWarnings("unchecked")
		 List books = root.elements("书");
    	 Element book2 = books.get(1);
    	 //在第二本书对象中添加内容
    	 book2.addElement("猫").setText("我是猫");
    	 //回写
    	 //创建一个漂亮的格式
    	 OutputFormat format = OutputFormat.createPrettyPrint();
    	 
    	 //回下类
    	 XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),format);
    	 //回写文档
    	 writer.write(document);
    	 //关闭流
    	 writer.close();
     }
     //获取第二本书的作者的文本内容
     public static void run1() throws Exception{
    	 //获取解析器对象
    	 SAXReader reader = new SAXReader();
    	 //解析xml标签，返回document对象
    	 Document document = reader.read("src/book.xml");
    	 //获取跟节点
    	 Element root = document.getRootElement();
    	 //获取书的节点，获取第二本书
    	 @SuppressWarnings("unchecked")
		 List books= root.elements("书");
    	 Element book2 = books.get(1);
    	 //获取作者的标签
    	 Element author = book2.element("作者");
    	 //获取文本内容
    	 System.out.println(author.getText());
     }
}