Java Web基础入门第三讲 XML语言——XML编程(CRUD)

爱被打了一巴掌 2022-03-19 16:45 258阅读 0赞

# XML解析技术概述 #

## XML解析的两种方式：DOM解析和SAX解析 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70]

### DOM解析和SAX解析之间的区别 ###

此处，要非常清楚地知道DOM解析和SAX解析之间的区别，因为面试题常考。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 1]

### DOM解析和SAX解析的原理 ###

先来看DOM解析的原理。有root.xml文档如下：

<?xml version="1.0" encoding="UTF-8" ?>
    <stu id="10086">
    	<name>张三</name>
    	<age>18</age>
    </stu>

对其进行DOM解析，如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 2]  
DOM解析有其优缺点，

*  优点：十分便于进行增删改查的操作，只须解析一次拿到Document对象后，就可以重复使用此对象，减少解析的次数；
 *  缺点：解析过程比较慢，需要将整个文档都解析完成后才能进行操作。需要将整个树的内容都加载进内存中来，比较耗费内存，当文档过大时，这种解析方式对内存的损耗非常的严重。

再来看一下SAX解析的原理。还是对以上文档进行SAX解析，如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 3]  
SAX解析也有其优缺点，

*  优点：不需要等待整个XML加载到内存，当解析到某一部分时，自动触发到对应的方法去做处理，处理的效率比较高；不需要将整个XML文档加载到内存中，对内存的损耗比较少，无论多大的XML，理论上都可以解析；
 *  缺点：每次解析都只能处理一次，下次再想处理还要重新解析，且只能进行查询不能进行增删改的操作。

## XML解析器 ##

XML解析器有如下几类：

*  Crimson(SUN，JDK自带)；
 *  Xerces(IBM最好的解析器)；
 *  Aelfred2(DOM4J)

使用哪种解析器对程序员基本上没有什么影响，我们学习的是解析开发包，解析开发包调用什么样的解析器对程序员没有意义。

## XML解析开发包 ##

XML解析开发包也有如下几类：

1.  JAXP(SUN公司的)；
2.  JDOM(不推荐使用)；
3.  DOM4J(比较不错)；
4.  Pull(Android的SDK自带，它使用的是另外的解析方式streaming api for xml，即STAX)

# 使用JAXP对XML文档进行解析 #

## JAXP概述 ##

JAXP(Java API for xml Processing)，是SUN提供的一套XML解析API，JAXP很好地支持了DOM和SAX解析方式。  
JAXP开发包是J2SE的一部分，它由javax.xml、org.w3c.dom 、org.xml.sax包及其子包组成。在javax.xml.parsers包中，定义了几个工厂类，程序员调用这些工厂类，可以得到对XML文档进行解析的DOM或SAX的解析器对象。

## 获得JAXP中的DOM解析器 ##

首先，查阅API可知，javax.xml.parsers包中的DocumentBuilderFactory用于创建DOM模式的解析器对象，DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回。如此一来，调用DocumentBuilderFactory.newInstance()方法可得到创建DOM解析器的工厂。

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

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

DocumentBuilder builder = factory.newDocumentBuilder();

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

Document document = builder.parse("src/book.xml");

## DOM解析 ##

### DOM模型(document object model) ###

DOM解析器在解析XML文档时，会把文档中的所有元素，按照其出现的层次关系，解析成一个个Node对象(节点)，在DOM中，节点之间关系如下：

*  位于一个节点之上的节点是该节点的父节点（parent）；
 *  一个节点之下的节点是该节点的子节点（children）；
 *  同一层次，具有相同父节点的节点是兄弟节点（sibling）；
 *  一个节点的下一个层次的节点集合是节点后代（descendant）；
 *  父、祖父节点及所有位于节点上面的，都是节点的祖先（ancestor）。

节点类型可参考以下列表。

<table> 
 <thead> 
  <tr> 
   <th align="center">类型名</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Node</td> 
   <td align="center">表示所有类型值的统一接口，此接口中提供了很多增删改查节点的方法，所有的文档树中的对象都实现过此接口</td> 
  </tr> 
  <tr> 
   <td align="center">Document</td> 
   <td align="center">表示文档类型</td> 
  </tr> 
  <tr> 
   <td align="center">Element</td> 
   <td align="center">表示元素节点类型</td> 
  </tr> 
  <tr> 
   <td align="center">Text</td> 
   <td align="center">表示文本节点类型</td> 
  </tr> 
  <tr> 
   <td align="center">CDATASection</td> 
   <td align="center">表示CDATA区域类型</td> 
  </tr> 
  <tr> 
   <td align="center">DocumentType</td> 
   <td align="center">表示文档声明类型</td> 
  </tr> 
  <tr> 
   <td align="center">DocumentFragment</td> 
   <td align="center">表示文档片段类型</td> 
  </tr> 
  <tr> 
   <td align="center">Attr</td> 
   <td align="center">表示属性节点类型</td> 
  </tr> 
 </tbody> 
</table>

### Node对象 ###

Node对象提供了一系列常量来代表节点的类型，当开发人员获得某个Node类型后，就可以把Node节点转换成相应的节点对象(Node的子类对象)，以便于调用其特有的方法。Node对象还提供了相应的方法去获得它的父节点或子节点。编程人员通过这些方法就可以读取整个XML文档的内容，或添加、修改、删除XML文档的内容了。  
**注意：DOM解析下，XML文档的每一个组成部分都会用一个对象表示，例如标签用Element，属性用Attr，但不管什么对象，都是Node的子类，所以在开发中可以把获取到的任意节点都当作Node对待**。

### DOM方式解析XML文件 ###

例如，有book.xml文档如下：

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
    <书架>
        <书>
            <书名 name="xxxxx">Java就业培训教程</书名>
            <作者>张孝祥</作者>
            <售价>39.00元</售价>
        </书>
        <书>
            <书名>JavaScript网页开发</书名>
            <作者>张孝祥</作者>
            <售价>28.00元</售价>
        </书>
    </书架>

下面我会使用DOM解析方式对以上XML文档进行增删改查(CRUD)的操作。

#### 读取 ####

需求：读取book.xml文档中书名元素(标签)`<书名>JavaScript网页开发</书名>`中封装的内容，如图。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 4]

package cn.liayun.xml;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    
    import org.junit.Test;
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    public class Demo { 
    
    	//读取xml文档中：<书名>JavaScript网页开发</书名> 节点中的值
    	@Test
    	public void read() throws Exception { 
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = factory.newDocumentBuilder();
    		Document document = builder.parse("src/book.xml");
    		
    		NodeList list = document.getElementsByTagName("书名"); //获取到书名元素(标签)
    		Node node = list.item(1);
    		String content = node.getTextContent(); //获取到书名元素(标签)中封装的内容
    		System.out.println(content); //输出：JavaScript网页开发
    	}
    
    }

如果要求我们得到book.xml文档中的所有标签，那么又该怎么实现这个需求呢？这里肯定是要用到递归的编程思想的，除此之外，还应知道如下方法。

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">NodeList getChildNodes()</td> 
   <td align="center">包含此节点的所有子节点的NodeList。如果不存在子节点，则这是不包含节点的NodeList</td> 
  </tr> 
 </tbody> 
</table>

public class Demo { 
    	
    	//得到xml文档中的所有标签
    	@Test
    	public void read1() throws Exception { 
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = factory.newDocumentBuilder();
    		Document document = builder.parse("src/book.xml");
    		
    		//得到根节点
    		Node root = document.getElementsByTagName("书架").item(0);
    		
    		list(root);
    	}
    
    	private void list(Node node) { 
    		if (node instanceof Element) {  //判断node是否为标签
    			System.out.println(node.getNodeName());
    		}
    // System.out.println(node.getNodeName());
    		NodeList list = node.getChildNodes();
    		for (int i = 0; i < list.getLength(); i++) { 
    			Node child = list.item(i);
    			list(child);
    		}
    	}
    
    }

如果大家不知道递归是怎么遍历的，那么可以断点调试跟踪，理解其原理。**千万注意：对于XML标签中出现的所有空格和换行，XML解析程序都会当作标签内容进行处理**。  
最后一个需求，得到book.xml文档中标签`<书名 name="xxxx">Java就业培训教程</书名>`中属性的值，如图。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 5]

public class Demo { 
    	
    	//得到xml文档中标签属性的值：<书名 name="xxxx">Java就业培训教程</书名>
    	@Test
    	public void read3() throws Exception { 
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = factory.newDocumentBuilder();
    		Document document = builder.parse("src/book.xml");
    		
    		Element bookname = (Element) document.getElementsByTagName("书名").item(0);
    		String value = bookname.getAttribute("name");
    		System.out.println(value);
    	}
    
    }

#### 创建 ####

需求：向book.xml文档中添加一个节点——`<售价>59.00元</售价>`，如下图。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 6]  
首先，我们要获得JAXP中的DOM解析器，调用DOM解析器对象的parse()方法解析XML文档，得到代表整个文档的Document对象；然后，创建一个节点；最后，把创建的节点挂到第一本书上。

public class Demo { 
    
    	//向xml文档中添加节点：<售价>59.00元</售价>
    	@Test
    	public void add() throws Exception { 
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = factory.newDocumentBuilder();
    		Document document = builder.parse("src/book.xml");
    		
    		//创建节点
    		Element price = document.createElement("售价");//就是创建一个标签
    		price.setTextContent("59.00元");
    		
    		//把创建的节点挂到第一本书上
    		Element book = (Element) document.getElementsByTagName("书").item(0);
    		book.appendChild(price);
    	}
    
    }

运行以上测试方法，发现我们创建的售价节点并没有挂到第一本书上，这是为什么呢？因为还没更新XML文档，即没把更新后的内存树写回到XML文档中。那么如何更新XML文档呢？javax.xml.transform包中的Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出，例如把XML文件应用样式表后转成一个HTML文档。利用这个对象，当然也可以把Document对象又重新写入到一个XML文件中。Transformer对象通过TransformerFactory获得。Transformer类通过transform方法完成转换操作，该方法接收一个源和一个目的地，我们可以通过：

*  javax.xml.transform.dom.DOMSource类来关联要转换的Document对象；
 *  用javax.xml.transform.stream.StreamResult对象来表示数据的目的地。

![在这里插入图片描述][20190219232544536.png]  
这样，将创建的售价节点挂到第一本书上后，book.xml的内容变为如下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 7]  
如果要求我们向book.xml文档中的指定位置上添加节点——`<售价>59.00元</售价>`，那么又该怎么实现这个需求呢？可按以下分析的步骤来编写代码。

> 我是这样分析的：
> 
> 1.  获得JAXP中的DOM解析器，调用DOM解析器对象的parse()方法解析XML文档，得到代表整个文档的Document对象；
> 2.  创建节点；
> 3.  得到参考节点；
> 4.  得到要挂崽的节点；
> 5.  往要挂崽的节点的指定位置插崽；
> 6.  把更新后的内存树写回到xml文档。

public class Demo { 
    
    	//向xml文档中的指定位置上添加节点：<售价>59.00元</售价>
    	@Test
    	public void add2() throws Exception { 
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = factory.newDocumentBuilder();
    		Document document = builder.parse("src/book.xml");
    		
    		//创建节点
    		Element price = document.createElement("售价");//就是创建一个标签
    		price.setTextContent("59.00元");
    		
    		//得到参考节点
    		Element refNode = (Element) document.getElementsByTagName("售价").item(0);
    		//得到要挂崽的节点
    		Element book = (Element) document.getElementsByTagName("书").item(0);
    		//往book节点的指定位置插崽
    		book.insertBefore(price, refNode);
    		
    		//把更新后的内存写回到xml文档
    		TransformerFactory tfFactory = TransformerFactory.newInstance();
    		Transformer tf = tfFactory.newTransformer();
    		tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
    	}
    
    }

这样，添加后book.xml的内容变为如下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 8]  
再看最后一个需求，向book.xml文档节点上添加属性，如向`<书名>Java就业培训教程</书名>`上添加name="xxx"属性。为了不要混淆视听，先把原book.xml文档中`<书名>Java就业培训教程</书名>`元素中的name属性删除掉。

public class Demo { 
    
    	//向xml文档节点上添加属性：<书名>Java就业培训教程</书名> 上添加name="xxx"属性
    	@Test
    	public void addAttr() throws Exception { 
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = factory.newDocumentBuilder();
    		Document document = builder.parse("src/book.xml");
    		
    		Element bookname = (Element) document.getElementsByTagName("书名").item(0);
    		bookname.setAttribute("name", "xxx");
    		
    		//把更新后的内存写回到xml文档
    		TransformerFactory tfFactory = TransformerFactory.newInstance();
    		Transformer tf = tfFactory.newTransformer();
    		tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
    	}
    
    }

添加name="xxx"属性之后的book.xml内容为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 9]  
注意：以上方式添加的元素都没有格式上的缩进。

#### 删除 ####

假设book.xml文档的内容修改为如下：

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
    <书架>
        <书>
            <书名 name="xxxxx">Java就业培训教程</书名>
            <作者>张孝祥</作者>
            <售价>59.00元</售价>
            <售价>39.00元</售价>
        </书>
        <书>
            <书名>JavaScript网页开发</书名>
            <作者>张孝祥</作者>
            <售价>28.00元</售价>
        </书>
    </书架>

需求：删除以上XML文档中的标签——`<售价>59.00元</售价>`。删除该售价标签，共有两种方式，第一种方式如下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 10]  
再来看第二种方式。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 11]  
删除该售价标签之后book.xml内容为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 12]

#### 修改 ####

需求：更新节点`<售价>59.00元</售价>`中的售价。

public class Demo { 
    
    	//更新价格
    	@Test
    	public void update() throws Exception { 
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = factory.newDocumentBuilder();
    		Document document = builder.parse("src/book.xml");
    		
    		//得到要更新的节点
    		Element e = (Element) document.getElementsByTagName("售价").item(0);
    		e.setTextContent("109元");
    		
    		//把更新后的内存写回到xml文档
    		TransformerFactory tfFactory = TransformerFactory.newInstance();
    		Transformer tf = tfFactory.newTransformer();
    		tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
    	}
    
    }

修改售价之后book.xml文档的内容为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 13]

## SAX解析 ##

在使用DOM解析XML文档时，需要读取整个XML文档，在内存中构架代表整个DOM树的Doucment对象，从而再对XML文档进行操作。此种情况下，如果XML文档特别大，就会消耗计算机的大量内存，并且容易导致内存溢出；而SAX解析允许在读取文档的时候，即对文档进行处理，而不必等到整个文档装载完才会对文档进行操作，这样就能够避免内存溢出的情况了。使用SAX解析这种方式的缺点就是它只能实现对XML文档的读取操作。该解析方式也是DOM4J的解析方式。

### SAX方式解析XML文件 ###

SAX采用事件处理的方式解析XML文件，利用SAX解析XML文档，涉及两个部分：解析器和事件处理器。

*  SAX解析器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定它去解析某个XML文档；
 *  解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的XML文件内容作为方法的参数传递给事件处理器；
 *  事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以很轻松地得到SAX解析器解析到的数据，从而可以决定如何对数据进行处理。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 14]  
阅读ContentHandler API文档，常用方法有：startElement、endElement、characters。下面是SAX方式解析XML文档的一般步骤：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 15]  
现在有这样一个book.xml文档，

<?xml version="1.0" encoding="UTF-8"?>
    <书架>
    	<书>
    		<书名>Java就业培训教程</书名>
    		<作者>张孝祥</作者>
    		<售价>109元</售价>
    	</书>
    	<书>
    		<书名 name="xxxx">JavaScript网页开发</书名>
    		<作者>黎明</作者>
    		<售价>28.00元</售价>
    	</书>
    </书架>

给到我们的需求是得到该XML文档的所有内容。解决这个需求之前，还需要对ContentHandler(内容处理器)有一定的认识。它是一个接口，我们可以自己写一个类实现这个接口，其中提供了如下重要的方法：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 16]  
现在来编写一个类ListHandler实现ContentHandler接口，其作用是得到book.xml文档中的所有内容。

//得到xml文档的所有内容
    class ListHandler implements ContentHandler { 
    	
    	/* * 解析器只要解析到开始标签，就会调用startElement()方法 * 会通过方法的参数告诉你解析到的当前标签名称是什么 */
    	@Override
    	public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException { 
    		System.out.println("<" + qName + ">");
    		
    		//获取标签上的属性
    		for (int i = 0; atts != null && i < atts.getLength(); i++) { //有可能标签上没有属性，那么atts有可能为null，所以就有可能会抛空指针异常。
    			String attName = atts.getQName(i);//得到属性名称
    			String attValue = atts.getValue(i);//得到属性的值
    			System.out.println(attName + "=" + attValue);
    		}
    	}
    	
    	@Override
    	public void characters(char[] ch, int start, int length) throws SAXException { 
    		System.out.println(new String(ch, start, length));
    	}
    
    	@Override
    	public void endElement(String uri, String localName, String qName) throws SAXException { 
    		System.out.println("<" + qName + ">");
    	}
    	
    	@Override
    	public void setDocumentLocator(Locator locator) { 
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void startDocument() throws SAXException { 
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void startPrefixMapping(String prefix, String uri) throws SAXException { 
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void endPrefixMapping(String prefix) throws SAXException { 
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException { 
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void processingInstruction(String target, String data) throws SAXException { 
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void skippedEntity(String name) throws SAXException { 
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void endDocument() throws SAXException { 
    		// TODO Auto-generated method stub
    		
    	}
    	
    }

可发现ContentHandler接口中的方法都要一一实现，未免麻烦。幸好还有一个DefaultHandler类，该类实现了某些处理XML文档必须的ContentHandler接口，但是均没有具体的方法，也就是说是空方法，如果想要解析XML文档，需要覆写该方法。  
如果想要获取book.xml文档中指定标签的值，如`<作者>张孝祥</作者>`，那么就可以编写一个类(例如TagValueHandler)实现DefaultHandler类来解决。

package cn.liayun.sax;
    
    import java.io.IOException;
    
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.XMLReader;
    import org.xml.sax.helpers.DefaultHandler;
    
    public class Demo2 { 
    
    	/** * sax解析xml文档 * @param args * @throws SAXException * @throws ParserConfigurationException * @throws IOException */
    	public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException { 
    		//1.创建解析器工厂
    		SAXParserFactory factory = SAXParserFactory.newInstance();
    		//2.得到解析器
    		SAXParser sp = factory.newSAXParser();
    		//3.得到读取器
    		XMLReader reader = sp.getXMLReader();
    		//4.设置内容处理器
    		reader.setContentHandler(new TagValueHandler());
    		//5.读取xml文档内容
    		reader.parse("src/book.xml");//读取器会调用内容处理器中的方法
    	}
    
    }
    
    //只处理某个标签值的处理器，用来获取指定标签的值
    class TagValueHandler extends DefaultHandler { 
    	
    	private String currentTag; //记住当前解析到的是什么标签
    	private int needNumber = 2; //记住想要获取第几个作者标签的值
    	private int currentNumber; //记住当前解析到的是第几个
    
    	@Override
    	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { 
    		currentTag = qName;
    		
    		if (currentTag.equals("作者")) { 
    			currentNumber++;
    		}
    	}
    
    	@Override
    	public void endElement(String uri, String localName, String qName) throws SAXException { 
    		currentTag = null;//解析到结束标签时，将其置为null
    	}
    
    	@Override
    	public void characters(char[] ch, int start, int length) throws SAXException { 
    		if ("作者".equals(currentTag) && currentNumber == needNumber) { 
    			System.out.println(new String(ch, start, length));
    		}
    	}
    	
    }

在实际开发中，我们是要把book.xml文档中的每一本书封装到一个Book对象中，并把多个Book对象放在一个List集合中返回。那怎么来实现这一需求呢？先将封装数据的JavaBean，即Book类设计出来：

package cn.liayun.sax;
    
    public class Book { 
    	private String name;
    	private String author;
    	private String 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 String getPrice() { 
    		return price;
    	}
    	public void setPrice(String price) { 
    		this.price = price;
    	}
    }

再编写一个类(例如BeanListHandler)实现DefaultHandler类，把book.xml文档中的每一本书封装到一个Book对象中，并把多个Book对象放在一个List集合中返回。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 17]  
最后，在main方法中测试：

public class Demo3 { 
    
    	/** * sax解析xml文档 * @param args * @throws SAXException * @throws ParserConfigurationException * @throws IOException */
    	public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException { 
    		//1.创建解析器工厂
    		SAXParserFactory factory = SAXParserFactory.newInstance();
    		//2.得到解析器
    		SAXParser sp = factory.newSAXParser();
    		//3.得到读取器
    		XMLReader reader = sp.getXMLReader();
    		//4.设置内容处理器
    		BeanListHandler handler = new BeanListHandler();
    		reader.setContentHandler(handler);
    		//5.读取xml文档内容
    		reader.parse("src/book.xml");//读取器会调用内容处理器中的方法
    		
    		List<Book> list = handler.getBooks();
    		System.out.println(list);
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70]: /images/20220319/3aae2f37cdd14efe8b9675e680c196e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 1]: /images/20220319/06888b13113a4e37ab59b32b3bc24eff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 2]: /images/20220319/d3088f72a29145b98bb95f3ba74606a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 3]: /images/20220319/ecaf610c7fd94fc4a802c9d6a568ae7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 4]: /images/20220319/90fb6df626904e40b95bbb6d8cf9f366.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 5]: /images/20220319/f6e78aa2c74b4c3abe671239526b5f57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 6]: /images/20220319/572f7642182c4c5d9a21b99ac24bc7bf.png
[20190219232544536.png]: /images/20220319/b396c05e133a459399be008b9080a1c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 7]: /images/20220319/8fa91002e1c148cc8ba3ad61fdd883fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 8]: /images/20220319/73a4e9c4b3fc4de381de841e5c476cf2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 9]: /images/20220319/f47d2c60e24940df97925ac06030635d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 10]: /images/20220319/99f280b97b08478e844747ef4ab1205f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 11]: /images/20220319/55079421c5ab4079a9de1e398e9de648.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 12]: /images/20220319/788ce56cd8dc43c5981e6c533f9cf791.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 13]: /images/20220319/11278b9c91934a918ad839b30a72e617.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 14]: /images/20220319/01fb7891aa924402a1171182ecc7446e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 15]: /images/20220319/cd4e90f672e346c496793e5d7be225ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 16]: /images/20220319/954483bbfaa84db4a7a263d0d0a62af0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 17]: /images/20220319/ae54b434c7e44076baf534c2ca6e15b0.png