XML文档解析

最新推荐文章于 2024-06-29 12:06:41 发布

带翅膀的猫

最新推荐文章于 2024-06-29 12:06:41 发布

阅读量3.8k

点赞数 9

文章标签： xml xml解析

本文链接：https://blog.csdn.net/qq_25343557/article/details/76358538

版权

java 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

XML

[1] XML简介

可扩展的标记语言。
XML和HTML很像，html用来显示一个网页，XML用来传输和存储数据。
XML中全都是自定义标签。
XML实际上就是一种保存数据的格式。

XML是一种跨平台传输数据的格式，因为XML是一个纯文本文件。

 XML文件的例子:
	<?xml version="1.0" encoding="utf-8" ?>
	<root>
		<!--文档的内容-->
	</root>
	
	CDATA数据区中的内容不会被解析器当成XML标签所解析。
	<![CDATA[内容]]>

[2] XML语法规范
1.XML文件的第一行是XML声明，声明用来声明文件的版本以及编码。
2.XML有且只有一个根标签。
3.XML中的标签必须正确结束（成对出现或自结束标签）
4.XML的属性必须有值且值必须加引号。
5.XML标签不能交叉嵌套。
6.XML中严格区分大小写。
7.标签名不能以数字开头。

[3] 技术体系
对于XML来说最重要的就是XML解析。
XML解析指的就是将XML文档读入程序中，并转化为程序的对象。
解析XML一共有两个体系DOM 和 SAX 这两种方式都是JDK原生支持的。
DOM:

Document Object Model(文档对象模型)，他会一次性将xml文档全部加载进内存中，
生成一个DOM树，然后我们通过DOM树，来读取文档的内容。
优点：
它是完全面向对象的方式来解析文档，所以使用起来比较简单，并且它还支持文档的增删改查。
它是一次性将文档全都加载进内存的，文档会常驻内存中，所以我们可以反复操作文档。
缺点：
它是一次性将文档全都加载进内存的，所以如果文档过大会大量的耗费内存，并且解析性能较差。

SAX:

Simple API for XML
- 基于事件的回调的方式来解析xml文档，一次只读取一个节点，并通过方法将读取到内容返回。
- 优点：
- 一次只读取一个节点，不会将整个文档都加载进内存中，所以占用内存较小，解析性能较好
- 缺点：
-　只能做查询操作，不能修改，使用起来比较复杂。
- 一旦解析过一个节点以后，将不能再重复解析，如果希望重复解析，只能重新开始解析。

[4] 原生DOM解析

JDK原生支持，可以直接使用
核心类：DocumentBuilderFactory DocumentBuilder Document
解析的步骤： //获取工厂类实例 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
//获取解析器类实例 DocumentBuilder
//解析xml文档获取Document对象
Document document = builder.parse(“stu.xml”);

public class TestDom extends TestCase {
	@Test
	public void testDom() throws ParserConfigurationException, SAXException, IOException{
		//DOM解析
		//获取工厂类实例
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		//获取解析器类实例
		DocumentBuilder builder = factory.newDocumentBuilder();
		//解析xml文档获取Document对象
		Document document = builder.parse("stu.xml");
		//System.out.println(document);
	}
	
	@Test
	public void testDom2() throws ParserConfigurationException, SAXException, IOException{
		//DOM解析
		//获取工厂类实例
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		//获取解析器类实例
		DocumentBuilder builder = factory.newDocumentBuilder();
		//解析xml文档获取Document对象
		Document document = builder.parse("stu.xml");
		//System.out.println(document);
		//通过document对象来解析文档
//		org.w3c.dom.Element element = document.getElementById("1");
//		System.out.println(element);//null
		//getElememtById()无法使用，XML中均为自定义标签，id在XML目前没有意义
		NodeList list = document.getElementsByTagName("student");
		//System.out.println(list.getLength());//2
		//遍历list,读取学生信息
		for(int i=0;i<list.getLength();i++){
			//获取学生标签
			//将node强转为Element
			Element item = (Element)list.item(i);
			//获取id属性zhi
			String idString = item.getAttribute("id");
			int id = Integer.parseInt(idString);
			//System.out.println(id);
			//System.out.println(idString);
			//获取name值
			Node nameNode = item.getElementsByTagName("name").item(0);
			String nameString = nameNode.getTextContent();
			//System.out.println(nameString);
			//获取age值
			Node ageNode = item.getElementsByTagName("age").item(0);
			String ageString = ageNode.getTextContent();
			//System.out.println(ageString);
			//获取gender值
			Node genderNode = item.getElementsByTagName("gender").item(0);
			String genderString = genderNode.getTextContent();
			//System.out.println(genderString);
			//获取address值
			Node addressNode = item.getElementsByTagName("address").item(0);
			String addressString = addressNode.getTextContent();
			//System.out.println(addressString);
			//封装对象
			//System.out.println(nameString);
			Student student = new Student(Integer.parseInt(idString), nameString, Integer.parseInt(ageString), genderString, addressString);
			System.out.println(student);
		}
	}
}

[5] dom4j解析

它是开源的免费的第三方工具，它是我们JavaEE开发首选xml的解析工具。
核心类: SAXReader
步骤：
//获取解析器类实例 SAXReader reader = new SAXReader();
//解析xml文档获取Document对象 Document document =
reader.read(“stu.xml”);
//dom4j的操作是从根节点开始，所以先要通过Document对象获取根节点，然后通过根节点来做解析 Element
rootEle = document.getRootElement();

public class TestDom4j {
	@Test
	public void testDom4j() throws Exception{
		//获取解析器类实例
		SAXReader reader = new SAXReader();
		//获取document对象
		Document document = reader.read("stu.xml");
		//DOM4j的操作是从根节点开始的，所以我们先要通过document对象获取根节点
		//然后通过根节点来做解析
		Element rootEle = document.getRootElement();
		//获取所有的student元素
		List<Element> stuList = rootEle.elements("student");
		//遍历
		//System.out.println(stuList.size());
		for(Element ele:stuList){
			//获取id
			int id = Integer.parseInt(ele.attributeValue("id"));
			//获取name
			String name = ele.elementText("name");
			//获取age
			int age = Integer.parseInt(ele.elementText("age"));
			//获取gender
			String gender = ele.elementText("gender");
			//获取address
			String address = ele.elementText("address");
			Student student = new Student(id, name, age, gender, address);
			System.out.println(student);
		}
	}

[6] dom4j修改

添加元素
Element addElement(标签名)
- 添加属性
Element addAttribute(属性名,属性值)
- 添加文本内容
Element addText(文本) //创建一个漂亮的格式 OutputFormat format = OutputFormat.createPrettyPrint(); //创建一个XMLWriter对象 XMLWriter
writer = new XMLWriter(new FileWriter(“stu2.xml”),format);
//将Document对象写入到文件中 writer.write(document); //关闭流
writer.close();
- 创建空的Document对象 Document document = DocumentHelper.createDocument();

@Test
	public void testDom4jWrite() throws Exception{
		//获取解析器类实例
		SAXReader reader = new SAXReader();
		//获取document对象
		Document document = reader.read("stu.xml");
		//向students标签中添加一个新的学生信息
		Element rootEle = document.getRootElement();
		//向根节点中添加一个student标签
		Element stuEle = rootEle.addElement("student");
		//向stuEle中添加id属性
		stuEle.addAttribute("id", "4");
		//添加name
		stuEle.addElement("name").addText("汪家成");
		//添加age
		stuEle.addElement("age").addText("21");
		//添加gender
		stuEle.addElement("gender").addText("男");
		//添加address
		stuEle.addElement("address").addText("荆州市");
		//将修改的内容输出到文件中
		//创建一个漂亮的格式
		 OutputFormat fomat = OutputFormat.createPrettyPrint();
		 XMLWriter writer = new XMLWriter(new FileWriter( "stu2.xml"),fomat);
		 writer.write(document);
		 writer.close();
	}
	
	@Test
	public void testDom4jCreateDocument() throws Exception{
		//创建一个Document对象
		Document document = DocumentHelper.createDocument();
		//添加一个根节点
        Element root = document.addElement( "Teacher" );
        //添加teacher元素
        root.addElement("teacher").addText("TOM");
        root.addElement("teacher").addText("JAKE");
      //将document写入到文件中
        OutputFormat fomat = OutputFormat.createPrettyPrint();
        XMLWriter writer = new XMLWriter(new FileWriter( "teacher.xml"),fomat);
        writer.write(document);
        writer.close();
	}

[7] XPath
xPath主要用来在xml文档中查询节点
语法参考文档
dom4j支持xPath查询，使用时需要导入一个jar包 jaxen-1.1-beta-6.jar
使用：
List selectNodes(xpath表达式)
Node selectSingleNode(xpath表达式)

/**
	 * 通过dom4j使用xpath要导入对应jar包
	 * @throws Exception 
	 */
	@Test
public void testXpath() throws Exception{
		//获取解析器类实例
		SAXReader reader = new SAXReader();
		//获取document对象
		Document document = reader.read("stu.xml");
		Element stuEle = (Element)document.selectSingleNode("/students/student[@id='2']");
		//获取学生信息
		String idString = stuEle.attributeValue("id");
		System.out.println(idString);
	}
}

[8] SAX解析
核心类：SAXParserFactory SAXParser DefaultHandler
步骤：
//创建工厂类实例
SAXParserFactory factory = SAXParserFactory.newInstance();
//获取解析器类实例
SAXParser parser = factory.newSAXParser();
//解析xml文档
//sax的解析的全部操作都是通过处理器类来实现
//使用sax解析我们需要自己创建一个处理器类
parser.parse(“stu.xml”, new MyHandler());

处理器类中的方法：
startDocument() --> 解析开始时调用
endDocument() --> 解析结束时调用

startElement(String uri, String localName, String qName, Attributes
attributes)
- 解析开始标签时调用
- qName 标签名
- attributes 当前标签中所有属性

endElement(String uri, String localName, String qName)
- 解析结束标签是调用
- qName 标签名

characters(char[] ch, int start, int length)
- 解析文本内容时调用
- 会将文本内容以char数组的形式返回，我们可以使用一个String的构造器将数组转换为字符串。

SAX测试代码：

public class testSAX {
	@Test
	public void testSAX() throws Exception, SAXException{
		//创建工厂实例
		SAXParserFactory factory = SAXParserFactory.newInstance();
		//获取解析器类实例
		SAXParser parser = factory.newSAXParser();
		//解析xml文档
		parser.parse("stu.xml", new DefaultHandler());
		//SAX的解析都是通过处理器类实现的
		//使用SAX解析我们需要自己实现处理器类
	}
	
	@Test
	public void testSAX2() throws Exception, SAXException{
		//创建工厂实例
		SAXParserFactory factory = SAXParserFactory.newInstance();
		//获取解析器类实例
		SAXParser parser = factory.newSAXParser();
		//解析xml文档
		parser.parse("stu.xml", new MyHandler());
		
	}
}

MyHandler处理类：

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class MyHandler extends DefaultHandler {
	private Student student;
	private String tagName;//当前解析到的标签名
	/*
	 * 开始解析文档时调用
	 */
	@Override
	public void startDocument() throws SAXException {
		System.out.println("开始解析。。。");
	}
	/*
	 * 解析文档结束时调用
	 */
	@Override
	public void endDocument() throws SAXException {
		System.out.println("结束解析。。。");
	}
	
	/*
	 * 解析开始标签
	 * qName:标签名
	 * attributes:属性对象
	 */
	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException {
		tagName = qName;
		//判断当前标签是否为student
		if("student".equals(qName)){
			//创建学生对象
			student = new Student();
			//获取id属性
			String id = attributes.getValue("id");
			student.setId(Integer.parseInt(id));
		}
		
		
	}
	
	/*
	 * 解析结束标签
	 */
	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {
		//读取到结束标签时要将tagName设置为Null
		this.tagName = null;
		if("student".equals(qName)){
			System.out.println(student);
		}
	}
	
	/*
	 * 解析内容时调用
	 */	
	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		if("name".equals(this.tagName)){
			String name = new String(ch, start, length);
			student.setName(name);
			//System.out.println(name);
		}
		if("age".equals(this.tagName)){
			String age = new String(ch, start, length);
			student.setAge(Integer.parseInt(age));
			//System.out.println(age);
		}
		if("gender".equals(this.tagName)){
			String gender = new String(ch, start, length);
			student.setGender(gender);
			//System.out.println(gender);
		}
		if("address".equals(this.tagName)){
			String address = new String(ch, start, length);
			student.setAddress(address);
			//System.out.println(address);
		}
	}	
}

[9] PULL解析
> 为解决SAX的一些局限（不能手动控制解析结束），出现pull解析
> 使用pull解析需要导入两个jar包：
kxml2-2.3.0.jar
xmlpull_1_0_5.jar
> 核心类：XmlPullParserFactory XmlPullParser
> 步骤：
//获取工厂类实例
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
//获取解析器类实例
XmlPullParser parser = factory.newPullParser();
//读写xml文档
parser.setInput(new FileReader(“stu.xml”));
> Pull解析的一切操作，都是通过XmlPullParser对象进行的。
XmlPullParser方法：
int next() --> 向下解析一个节点
int getEventType() --> 获取当前的事件类型
String getName() --> 获取当前的标签名
String getText() --> 获取当前的文本内容
String nextText() --> 获取下一个节点的文本内容
String getAttribute(命名空间,属性名) --> 获取当前元素的指定属性
int nextTag() --> 直接读下一个标签

			XmlPullParser常量：
				1.START_DOCUMENT = 0
				2.END_DOCUMENT = 1
				3.START_TAG = 2
				4.END_TAG = 3
				5.TEXT = 4
			- 可根据常量来判断当前的事件类型

import java.io.FileReader;
import java.io.Reader;

import org.junit.Test;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;
import java.lang.Integer;
import XML_PULL.Student;


public class TestPull {
	@Test
	public void testPull() throws Exception{
		//获取工厂类实例
		XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
		//获取解析器类实例
		XmlPullParser parser = factory.newPullParser();
		//通过FileReader读取xml
		Reader inReader = new FileReader("stu.xml");
		//将流设置进Parser
		parser.setInput(inReader);
		//pull解析的一切操作都是通过XmlPullParser 对象进行的
		//获取当前的事件类型
		int type = parser.getEventType();
		type = parser.next();
		type = parser.next();
		type = parser.next();
		//获取当前的标签名
		String tagName = parser.getName();
		//System.out.println(tagName);
		//获取student标签的id属性
		//String id = parser.getAttributeValue(0);//传递索引
		String id = parser.getAttributeValue(null,"id");//第一个参数接收一个命名空间，没有可以传NULL
		System.out.println(id);
	}

	@Test
	public void testPull2() throws Exception{
		//获取工厂类实例
		XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
		//获取解析器类实例
		XmlPullParser parser = factory.newPullParser();
		//通过FileReader读取xml
		Reader inReader = new FileReader("stu.xml");
		//将流设置进Parser
		parser.setInput(inReader);
		//pull解析的一切操作都是通过XmlPullParser 对象进行的
		//获取当前的事件类型
		//声明一个空的student对象
		Student student = null;
		while(parser.next()!=XmlPullParser.END_DOCUMENT){
			//获取当前事件类型
			int event = parser.getEventType();
			//获取标签名
			String tagName = parser.getName();
			//判断当前标签是否为开始标签
			if(event == XmlPullParser.START_TAG){
				//判断当前标签名是否为student
				if("student".equals(tagName)){
					student = new Student();
					//获取id属性值
					String id = parser.getAttributeValue(null, "id");
					student.setId(Integer.parseInt(id));
				}else{
					if("name".equals(tagName)){
						//获取name
						String name = safeNextText(parser);//获取下一个文本值
						System.out.println(name);
						student.setName(name);
					}else{
						if("age".equals(tagName)){
							//获取age
							String age =  safeNextText(parser);
							student.setAge(Integer.parseInt(age));
						}else{
							if("gender".equals(tagName)){
								//获取gender
								String gender =  safeNextText(parser);
								student.setGender(gender);
							}else{
								if("address".equals(tagName)){
									//获取address
									String address=  safeNextText(parser);
									student.setAddress(address);
									System.out.println(student);
								}
							}
						}
					}
				}
			}
		}
	}
	private String safeNextText(XmlPullParser parser) throws Exception {
		String result = parser.nextText();
		if (parser.getEventType() != XmlPullParser.END_TAG) {
			parser.nextTag();
		}
		return result;
	}
}

测试XML文档内容：

<?xml version="1.0" encoding="UTF-8"?>
<students>
	<student id="1">
		<name>TOM</name>
		<age>21</age>
		<gender>男</gender>
		<address>赣州市</address>
	</student>
	<student id="2">
		<name>JAKE</name>
		<age>21</age>
		<gender>男</gender>
		<address>长沙市</address>
	</student>
</students>

封装的Student类：

public class Student {
	private int id;
	private String name;
	private int age;
	private String gender;
	private String address;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "[Student:"+id+"\t"+name+"\t"+age+"\t"+gender+"\t"+address+"]";
	}
	public Student(int id, String name, int age, String gender, String address) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.address = address;
	}
	public Student() {
		super();
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
}