dom4j解析器 基于dom4j的xpath技术 简单工厂设计模式 分层结构设计思想 SAX解析器 DOM编程

*1 dom4j解析器
1）CRUD的含义：CreateReadUpdateDelete增删查改
2）XML解析器有二类，分别是DOM和SAX(simple Api for xml)。
a)DOM一次性将整个XML文件读到内存，形成一个倒状的树形结构
b)SAX多次将整个XML文件读到内存
c)Document对象代表XML文件在内存中的映像
3)常用的API如下：
SAXReader saxReader = new SAXReader(); SAXReader是dom4j的核心类
Document document = saxReader.read("*.xml")
Document.getRootElement()
Element.getName()
Element.elements()：取得该元素下的所有直接子元素
Element.elementText()：从一个元素导航到另一个元素且取出该元素的文本
Element.element("车牌") ：从一个元素导航到另一个元素
Element.attributeValue("出产时间")：取得一个元素对应的属性
Element.addElement("单价").setText("40")：添加新元素，同时设置该元素文本的值
OutputFormat format = OutputFormat.createPrettyPrint()：使用缩格形式写XML文件
XMLWriter xmlWriter = new XMLWriter(os,format)：构造XML写入器
xmlWriter.write(document)：将内存中的document对象写入硬盘
firstCarElement.remove(firstCarPriceElement)：从直接父元素删除直接子元素
//firstCarPriceElement.getParent().remove(firstCarPriceElement)：从直接父元素删除直接子元素

package cn.itcast.xml.dom4j;

public class Car implements Comparable<Car>{
private String band;//车牌
private String place;//产地
private String time;//出产时间
private int price;//单价
public Car(){}
public String getBand() {
return band;
}
public void setBand(String band) {
this.band = band;
}
public String getPlace() {
return place;
}
public void setPlace(String place) {
this.place = place;
}
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public int compareTo(Car car) {
if(this.price<car.getPrice()){
return 1;
}else if(this.price>car.getPrice()){
return -1;
}else{
return 0;
}
}
}

package cn.itcast.xml.dom4j;

import java.io.File;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
//基于DOM4J解析XML文件(read)[dom4j-1.6.1.jar]
//使用dom4j解析xml文件
public class Demo1 {
public static void main(String[] args) throws Exception {
//创建dom4j解析器
SAXReader saxReader = new SAXReader();
//加载需要解析的xml文件
Document document = saxReader.read(new File("src/cn/itcast/xml/dom4j/car.xml"));
//取得根元素
Element rootElement = document.getRootElement();
//显示根元素的名称
System.out.println(rootElement.getName());
//取得根元素下的子元素
List<Element> elementList = rootElement.elements();
System.out.println("共有" + elementList.size()+"辆车");
for(Element e : elementList){
System.out.println("车牌：" + e.elementText("车牌"));
System.out.println("产地：" + e.elementText("产地"));
System.out.println("出产时间：" + e.element("车牌").attributeValue("出产时间"));
System.out.println("------------------------------");
}
}
}

package cn.itcast.xml.dom4j;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

//使用dom4j操作xml文件的cud
public class Demo2 {
@Test
public void create() throws Exception{
Document document = getDocument();
Element rootElement = document.getRootElement();
//取得第一辆汽车
Element firstCarElement = (Element) rootElement.elements().get(0);
//添加新元素"单价"，并设置文本为30
firstCarElement.addElement("单价").setText("40");
//将内存中的xml文件写到硬盘中
write2xml(document);
}
private void write2xml(Document document) throws Exception {
OutputFormat format = OutputFormat.createPrettyPrint();
OutputStream os = new FileOutputStream("src/cn/itcast/xml/dom4j/car.xml");
XMLWriter xmlWriter = new XMLWriter(os,format);
xmlWriter.write(document);
xmlWriter.close();
}
private Document getDocument() throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(new File("src/cn/itcast/xml/dom4j/car.xml"));
return document;
}
@Test
public void update() throws Exception{
Document document = getDocument();
Element rootElement = document.getRootElement();
Element firstCarElement = (Element) rootElement.elements().get(0);
firstCarElement.element("单价").setText("60");
write2xml(document);
}
@Test
public void delete() throws Exception{
Document document = getDocument();
Element rootElement = document.getRootElement();
Element firstCarElement = (Element) rootElement.elements().get(0);
Element firstCarPriceElement = firstCarElement.element("单价");
firstCarElement.remove(firstCarPriceElement);
//firstCarPriceElement.getParent().remove(firstCarPriceElement);
write2xml(document);
}
}

package cn.itcast.xml.dom4j;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
//课堂练习(将car.xml文件中的所有car元素解析出存入集合，并按照单价对集合中的元素降序后输出)
public class Demo3 {
public static void main(String[] args) throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(new File("src/cn/itcast/xml/dom4j/car.xml"));
List<Element> elementList = document.getRootElement().elements();
List<Car> carList = new ArrayList<Car>();
for(Element e : elementList){
Car car = new Car();
car.setBand(e.elementText("车牌"));
car.setPlace(e.elementText("产地"));
car.setTime(e.element("车牌").attributeValue("出产时间"));
car.setPrice(Integer.parseInt(e.elementText("单价")));
carList.add(car);
}
//System.out.println("按单价排序前：");
//show(carList);
System.out.println("按单价排序后：");
sortByPriceDesc(carList);
}
public static void sortByPriceDesc(List<Car> carList) {
Collections.sort(carList);
show(carList);
}
public static void show(List<Car> carList){
if(carList!=null && carList.size()>0){
for(Car car : carList){
System.out.print("车牌："+car.getBand()+"\t");
System.out.print("产地："+car.getPlace()+"\t");
System.out.print("单价："+car.getPrice()+"\t");
System.out.println("出产时间："+car.getTime());
}
}
}
}

package cn.itcast.xml.dom4j;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
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其它的API
public class Demo4 {
public static void main(String[] args) throws Exception {

/*String->XML
String text = "<root><res>这是根元素</res></root>";
Document document = DocumentHelper.parseText(text);
OutputFormat format = OutputFormat.createPrettyPrint();
OutputStream os = new FileOutputStream("src/cn/itcast/xml/dom4j/string2xml.xml");
XMLWriter xmlWriter = new XMLWriter(os,format);
xmlWriter.write(document);
xmlWriter.close();
*/

/*创建空XML文件
Document document = DocumentHelper.createDocument();
document.addElement("root").setText("这是根元素");
OutputFormat format = OutputFormat.createPrettyPrint();
OutputStream os = new FileOutputStream("src/cn/itcast/xml/dom4j/empty.xml");
XMLWriter xmlWriter = new XMLWriter(os,format);
xmlWriter.write(document);
xmlWriter.close();
*/

/*指定插入次序，默认插入到最后
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(new File("src/cn/itcast/xml/dom4j/car.xml"));
List<Element> elementList = document.getRootElement().elements();
Element newCarElement = DocumentHelper.createElement("汽车");
newCarElement.setText("这是我的汽车");
elementList.add(1,newCarElement);
OutputFormat format = OutputFormat.createPrettyPrint();
OutputStream os = new FileOutputStream("src/cn/itcast/xml/dom4j/car.xml");
XMLWriter xmlWriter = new XMLWriter(os,format);
xmlWriter.write(document);
xmlWriter.close();
*/

//XML->String
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(new File("src/cn/itcast/xml/dom4j/car.xml"));
Element rootElement = document.getRootElement();
Element firstCarElement = (Element) rootElement.elements().get(0);
String xml = firstCarElement.asXML();
System.out.println(xml);
}
}

<?xml version="1.0" encoding="UTF-8"?>
<车辆清单>
<汽车>
<车牌 出产时间="2010年">奥迪</车牌>
<产地>北京</产地>
<单价>30</单价>
</汽车>
<汽车>
<车牌 出产时间="2011年">本田</车牌>
<产地>广州</产地>
<单价>60</单价>
</汽车>
</车辆清单>

<?xml version="1.0" encoding="UTF-8"?>

<root>这是根元素</root>

<?xml version="1.0" encoding="UTF-8"?>
<root>
<res>这是根元素</res>
</root>

*2 基于dom4j的xpath技术
1)能够在xml文件中，快速定位需要元素，无需从根元素一个一个的导航到需要的子元素

Document.selectNodes()：取得所有符合xpath格式的元素

Document.selectSingleNode()：取得所有符合xpath格式的元素的第一个元素

Node类型是Element/Text/Attribute/Document/...类型的父接口

package cn.itcast.xml.xpath;

import java.io.File;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

//使用Xpath，取得第二辆汽车的产地[dom4j-1.6.1.jar和jaxen-1.1-beta-6.jar]
public class Demo1 {
public static void main(String[] args) throws Exception {
SAXReader reader = new SAXReader();
Document document = reader.read(new File("src/cn/itcast/xml/xpath/car.xml"));
String xpath = "//单价";
Element element = (Element) document.selectSingleNode(xpath);
System.out.println("第一辆汽车的单价是：" + element.getText());

//List<Element> elementList = document.selectNodes(xpath);
//System.out.println("第二辆汽车的单价是：" + elementList.get(1).getText());
}
}

<?xml version="1.0" encoding="UTF-8"?>
<车辆清单>
<汽车>
<车牌 出产时间="2010年">奥迪</车牌>
<产地>北京</产地>
<单价>30</单价>
</汽车>
<汽车>
<车牌 出产时间="2011年">本田</车牌>
<产地>广州</产地>
<单价>60</单价>
</汽车>
</车辆清单>

package cn.itcast.xml.xpath;

import java.io.File;
import java.util.Scanner;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

//使用Xpath，模拟用户登录
public class Demo2 {
public static void main(String[] args) throws Exception {

//读取用户在键盘的输入信息
Scanner scanner = new Scanner(System.in);
System.out.print("用户名：");
String username = scanner.nextLine();
System.out.print("密码：");
String password = scanner.nextLine();

//解析XML文件，并查询指定的元素
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(new File("src/cn/itcast/xml/xpath/users.xml"));
String xpath = "//user[@username='"+username+"' and @password='"+password+"']";
Element element = (Element) document.selectSingleNode(xpath);

//输出结果
if(element!=null){
System.out.println("登录成功");
}else{
System.out.println("登录失败");
}
}
}

<?xml version="1.0" encoding="UTF-8"?>
<root>
<user id="u01" username="jack" password="123456"/>
<user id="u02" username="marry" password="654321"/>
</root>

3 简单工厂设计模式
1)目的就是统一管理访问层的所有Dao，让Service在Dao的处理上相对独立

2)引用DaoFactory来管理所有的具体Dao，并采用单例模式限制DaoFactory的个数

package cn.itcast.xml.model;

//单例的Dao工厂
public class DaoFactory {

//NO1
private DaoFactory(){}

//NO2
public static DaoFactory getDaoFactory(){
if(daoFactory==null){
daoFactory = new DaoFactory();
}
return daoFactory;
}

//NO3
private static DaoFactory daoFactory;

public IDao getDao(){
return new DaoJdbc();
}
}

package cn.itcast.xml.model;

public class DaoHibernate implements IDao {
public void create() {
System.out.println("DaoHibernate::create()");
}
}

package cn.itcast.xml.model;

//访问层
public class DaoJdbc implements IDao{
public void create(){
System.out.println("DaoJdbc::create()");
}
}

package cn.itcast.xml.model;

public interface IDao {
public void create();
}

package cn.itcast.xml.model;

//业务层(不变)
public class Service {
public void create(){
DaoFactory daoFactory = DaoFactory.getDaoFactory();
IDao iDao = daoFactory.getDao();
iDao.create();
}
}

package cn.itcast.xml.model;

//表现层
public class Demo1 {
public static void main(String[] args) {
Service service = new Service();
service.create();
}
}

4 分层结构设计思想
1)将各个不同功能的代码块，分离出来，避免不同功能的代码耦合，为程序扩展和维护提供方便。

package cn.itcast.xml.example1;
//(分层结构)：模拟用户登录
import java.io.File;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class LoginBusiness {
//测试
public static void main(String[] args) throws Exception {

LoginUI loginUI = new LoginUI();
LoginBusiness lognBusiness = new LoginBusiness();

User user = loginUI.input();
boolean flag = lognBusiness.check(user);

loginUI.output(flag);

}
//判段
public boolean check(User user) throws Exception{
boolean flag = false;
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(new File("src/cn/itcast/xml/xpath/users.xml"));
String xpath = "//user[@username='"+user.getUsername()+"' and @password='"+user.getPassword()+"']";
Element element = (Element) document.selectSingleNode(xpath);
if(element!=null){
flag = true;
}
return flag;
}
}

package cn.itcast.xml.example1;

import java.util.Scanner;

//输入输出
public class LoginUI {
public User input(){
User user = new User();
Scanner scanner = new Scanner(System.in);
System.out.print("用户名：");
String username = scanner.nextLine();
System.out.print("密码：");
String password = scanner.nextLine();
user.setUsername(username);
user.setPassword(password);
return user;
}
public void output(boolean flag){
if(flag){
System.out.println("登录成功");
}else{
System.out.println("登录失败");
}
}
}

package cn.itcast.xml.example1;

public class User {
private String id;
private String username;
private String password;
public User(){}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}

<?xml version="1.0" encoding="UTF-8"?>
<root>
<user id="u01" username="jack" password="123456"/>
<user id="u02" username="marry" password="654321"/>
</root>

*5 案例

1)以分层思想，模拟用户登录

2)通过配置文件解析/反射/运行某个类的方法

<?xml version="1.0" encoding="UTF-8"?>
<root>
<class>
<className>cn.itcast.xml.example2.Person</className>
<methodName>jump</methodName>
<argType>java.lang.String</argType>
<argValue>李四</argValue>
</class>
</root>

package cn.itcast.xml.example2;

public class Person {
public void run(String who){
System.out.println("Person::run()：" + who);
}
public void jump(String who){
System.out.println("Person::jump()：" + who);
}
}

package cn.itcast.xml.example2;

import java.io.File;
import java.lang.reflect.Method;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;

//基于XML配置文件，解析，反射，运行程序
public class Demo1 {
public static void main(String[] args) throws Exception {
//解析xml文件
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(new File("src/cn/itcast/xml/example2/config.xml"));
String className = document.selectSingleNode("//className").getText();
String methodName = document.selectSingleNode("//methodName").getText();
String argType = document.selectSingleNode("//argType").getText();
String argValue = document.selectSingleNode("//argValue").getText();

//反射创建对象并执行方法
Class clazz = Class.forName(className);
Method method = clazz.getMethod(methodName,Class.forName(argType));
method.invoke(clazz.newInstance(),argValue);
}
}

3)分层结构的学员信息案例

dao

package cn.itcast.xml.example3.dao;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
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;
import cn.itcast.xml.example3.domain.Student;

public class StudentDao {
//根据编号更新学员信息
public void update(Student student) throws Exception {
Document document = getDocument();
String xpath = "//student[@id='"+student.getId()+"']";
Element element = (Element) document.selectSingleNode(xpath);
if(element!=null){
element.element("name").setText(student.getName());
element.element("age").setText(student.getAge());
write2xml(document);
}else{
System.out.println("查无此学员");
}

}
//根据编号显示学员信息
public void read(String id) throws Exception{
Document document = getDocument();
String xpath = "//student[@id='"+id+"']";
Element element = (Element) document.selectSingleNode(xpath);
if(element!=null){
System.out.println("编号：" + element.attributeValue("id"));
System.out.println("姓名：" + element.elementText("name"));
System.out.println("年龄：" + element.elementText("age"));
}else{
System.out.println("查无此学员");
}
}
//根据编号删除某位学员的信息
public void delete(String id) throws Exception{
Document document = getDocument();
String xpath = "//student[@id='"+id+"']";
Element element = (Element) document.selectSingleNode(xpath);
if(element!=null){
element.getParent().remove(element);
write2xml(document);
}else{
System.out.println("查无此学员");
}
}
//增加学员的信息
public boolean create(Student student) throws Exception{
boolean flag = false;
if(student!=null){
Document document = null;
try {
document = getDocument();
} catch (Exception e) {
//创建空XML文件
document = DocumentHelper.createDocument();
//创建<students>根元素
document.addElement("students");
}
Element rootElement = document.getRootElement();
Element studentElement = rootElement.addElement("student");
studentElement.addAttribute("id",student.getId());
studentElement.addElement("name").setText(student.getName());
studentElement.addElement("age").setText(student.getAge());
write2xml(document);
flag = true;
}
return flag;
}
//将内存中的Document写到硬盘
private void write2xml(Document document) throws Exception {
OutputFormat format = OutputFormat.createPrettyPrint();
OutputStream os = new FileOutputStream("src/cn/itcast/xml/example3/db/students.xml");
XMLWriter xmlWriter = new XMLWriter(os,format);
xmlWriter.write(document);
xmlWriter.close();
}
//取得Document对象
private Document getDocument() throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(new File("src/cn/itcast/xml/example3/db/students.xml"));
return document;
}

}

domain

package cn.itcast.xml.example3.domain;

public class Student {
private String id;
private String name;
private String age;
public Student(){}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) throws Exception {
if(name.matches("[a-zA-Z]+")){
this.name = name;
}else{
throw new Exception();
}
}
public String getAge() {
return age;
}
public void setAge(String age) throws Exception {
if(age.matches("[0-9]+")){
this.age = age;
}else{
throw new Exception();
}
}
}

ui

package cn.itcast.xml.example3.ui;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

//id的自增长
public class IdUtil {
public static String getId() throws Exception{
BufferedReader br = new BufferedReader(new FileReader("src/cn/itcast/xml/example3/ui/id.txt"));
String id = br.readLine();//"2011100801"(字符串)
int temp = Integer.parseInt(id)+1;//2011100802(int型)
BufferedWriter bw = new BufferedWriter(new FileWriter("src/cn/itcast/xml/example3/ui/id.txt"));
bw.write(temp+"");
bw.flush();
bw.close();
return id;
}
}

package cn.itcast.xml.example3.ui;

import java.util.Scanner;
import cn.itcast.xml.example3.dao.StudentDao;
import cn.itcast.xml.example3.domain.Student;

public class StudentUI {
public static void main(String[] args) throws Exception {
input();
}
public static void input() throws Exception{

Scanner scanner = new Scanner(System.in);
System.out.print("学员的编号：");
String id = scanner.nextLine();
System.out.print("更新学员的姓名：");
String name = scanner.nextLine();
System.out.print("更新学员的年龄：");
String age = scanner.nextLine();
Student student = new Student();
student.setId(id);
student.setName(name);
student.setAge(age);
StudentDao studentDao = new StudentDao();
studentDao.update(student);

/*键盘输入学员信息
Scanner scanner = new Scanner(System.in);
System.out.print("查询学员的编号：");
String id = scanner.nextLine();
StudentDao studentDao = new StudentDao();
studentDao.read(id);
Scanner scanner = new Scanner(System.in);
System.out.print("删除学员的编号：");
String id = scanner.nextLine();
StudentDao studentDao = new StudentDao();
studentDao.delete(id);
Scanner scanner = new Scanner(System.in);
System.out.print("用户名：" );
String name = scanner.nextLine();
System.out.print("年龄：" );
String age = scanner.nextLine();
//封装成JavaBean对象
Student student = new Student();
student.setId(IdUtil.getId());
student.setName(name);
student.setAge(age);
//调用Dao对象
StudentDao studentDao = new StudentDao();
boolean flag = studentDao.create(student);
if(flag){
System.out.println("操作成功");
}else{
System.out.println("操作失败");
}
*/
}
}

db

<?xml version="1.0" encoding="UTF-8"?>

<students>
<student id="2011100801">
<name>keke</name>
<age>11</age>
</student>
</students>

6 SAX解析器
1)sun公司提供的一个基于事件的xml解析器

2)SAXParser是SAX解析器的核心类，在使用过程中，需要一个SAX处理器，该处理器必须扩展DefaultHandler

3)SAX解析器在解析XML文件时，会根据XML文件此时的状态，即开始标签，结束标签，调用SAX处理器对应的方法

4)SAX解析器在解析XML文件时，自动导航，无需像dom4j一样，人为导航

5)SAX解析器会将空白字符当作一个有效字符对待

package cn.itcast.xml.sax;

import java.io.File;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;

//使用sax解析器解析xml文件
public class Demo1 {
public static void main(String[] args) throws Exception {
//创建SAX解析器工厂
SAXParserFactory factory = SAXParserFactory.newInstance();
//创建SAX解析器
SAXParser saxParser = factory.newSAXParser();
//加载xml文件
saxParser.parse(
new File("src/cn/itcast/xml/sax/car.xml"),
new MyHandler());
}
}
//自定义SAX处理器
class MyHandler extends DefaultHandler{
private long begin;
public void startDocument(){
System.out.println("解析XML文件开始");
begin = System.currentTimeMillis();
}
public void endDocument() {
System.out.println("解析XML文件结束");
long end = System.currentTimeMillis();
System.out.println("解析XML共用" + (end-begin) + "毫秒");
}
public void startElement(
String uri,
String localName,
String qName,
Attributes attributes){
System.out.println("<"+qName+">");
System.out.println("有"+attributes.getLength()+"个属性");
System.out.println(attributes.getValue("出产时间"));
}
public void endElement(
String uri,
String localName,
String qName){
System.out.println("</"+qName+">");
}
public void characters(
char[] ch,
int start,
int length){
String content = new String(ch,start,length);
if(content.trim().length()>0){
System.out.println(content);
}
}
}

<?xml version="1.0" encoding="UTF-8"?>
<车辆清单>
<汽车>
<车牌 出产时间="2011年">奥迪</车牌>
<产地>北京</产地>
<单价>30</单价>
</汽车>
</车辆清单>

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

•解析器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个XML文档。

•解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的xml文件内容作为方法的参数传递给事件处理器。

•解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的xml文件内容作为方法的参数传递给事件处理器。





阅读DefaultHandler API文档，常用方法：startElement、endElement、characters

使用JAXP进行DOM解析

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

获得JAXP中的DOM解析器

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

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

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

DOM编程
lDOM模型(Document Object Model)

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

•在DOM中，节点之间关系如下：

•位于一个节点之上的节点是该节点的父节点(parent)

•一个节点之下的节点是该节点的子节点（children）

•同一层次，具有相同父节点的节点是兄弟节点（sibling）

•一个节点的下一个层次的节点集合是节点后代(descendant)

•父、祖父节点及所有位于节点上面的，都是节点的祖先(ancestor)

•节点类型（下页ppt）

Node对象

Node对象提供了一系列常量来代表结点的类型，当开发人员获得某个Node类型后，就可以把Node节点转换成相应的节点对象(Node的子类对象)，以便于调用其特有的方法。（查看API文档）

Node对象提供了相应的方法去获得它的父结点或子结点。编程人员通过这些方法就可以读取整个XML文档的内容、或添加、修改、删除XML文档的内容了。

DOM方式解析XML文件（XML文件最好是有效的）

•遍历所有节点

•查找某一个节点

•删除结点

•更新结点

•添加节点

DOM读取XML文件

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder domParser = factory.newDocumentBuilder();
Document document = domParser.parse(new File("src/cn/itcast/xml/parser/dom/car.xml"));
Element rootElement = document.getDocumentElement();
System.out.println(rootElement.getNodeName());
NodeList nodeList = rootElement.getElementsByTagName("汽车");
System.out.println("共有"+nodeList.getLength()+"辆汽车");
System.out.println("--------------------");
for(int i=0;i<nodeList.getLength();i++){
Element element = (Element) nodeList.item(i);
String band = element.getElementsByTagName("车牌").item(0).getTextContent();
String place = element.getElementsByTagName("产地").item(0).getTextContent();
String price = element.getElementsByTagName("单价").item(0).getTextContent();
String time = element.getElementsByTagName("车牌").item(0).getAttributes().getNamedItem("出产时间").getTextContent();
System.out.println("车牌：" + band);
System.out.println("产地：" + place);
System.out.println("单价：" + price);
System.out.println("出产时间：" + time);
System.out.println("--------------------");
}

DOM更新XML文件

@Test
public void testUpdate() throws Exception {
Document document = getDocument();
Element element = (Element) document.getElementsByTagName("汽车").item(1);
element.getElementsByTagName("单价").item(0).setTextContent("30万");
write2xml(document);
}
@Test
public void testDelete() throws Exception {
Document document = getDocument();
Element element = (Element) document.getElementsByTagName("汽车").item(2);
element.getParentNode().removeChild(element);
write2xml(document);
}
@Test
public void testCreate() throws Exception {
Document document = getDocument();
Element rootElement = document.getDocumentElement();
Element element = document.createElement("汽车");
Text text = document.createTextNode("我的汽车");
element.appendChild(text);
rootElement.appendChild(element);
write2xml(document);
}

private void write2xml(Document document) throws Exception {
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
transformer.transform(new DOMSource(document),new StreamResult(new File("src/cn/itcast/xml/parser/dom/car.xml")));
}
private Document getDocument() throws Exception {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder domParser = factory.newDocumentBuilder();
Document document = domParser.parse(new File("src/cn/itcast/xml/parser/dom/car.xml"));
return document;
}

DOM写入XML文档

javax.xml.transform包中的Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出，利用这个对象，可以把Document对象又重新写入到一个XML文件中。

Transformer类通过transform方法完成转换操作，该方法接收一个源和一个目的地。我们可以通过：

•javax.xml.transform.dom.DOMSource类来关联要转换的document对象，

•用javax.xml.transform.stream.StreamResult 对象来表示数据的目的地。

Transformer对象通过TransformerFactory获得。

TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer();
DOMSource source = new DOMSource(document);
StreamResult result = new StreamResult(new File("src/cn/itcast/xml/car.xml"));
transformer.transform(source,result);

DOM类和SAX类的区别

DOM

•很方便对文档进行遍历

•对文档curd也特别方便

•ml文档比较大的时候，dom解析占用的内存也会比较大，浪费系统资源。所以dom解析这种方式不适合解析大的xml文档。

SAX

•解析文件速度快，占用资源（内存）少。

•sax解析只适合读取文档数据，不适合对文档进行增删改。