四种解析和创建方式（DOM，SAX，DOM4J，JDOM）
一、先导入jar包
DOM基于树形，SAX基于事件，DOM4J和JDOM基于底层ＡＰＩ
二、代码如下
1 package com.sxt.test; import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; import javax.naming.spi.DirStateFactory.Result;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult; import org.dom4j.DocumentException;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.jdom2.Attribute;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl; import com.sxt.bean.Book;
import com.sxt.bean.SAXParserHandler; public class Demo1 { private ArrayList<Book> booksList = new ArrayList<Book>(); /*
* DOM解析
*/
@Test
public void testfun1() throws ParserConfigurationException, SAXException,
IOException {
// 创建DocumentBuilderFactory对象
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
// 创建DocumentBuilder对象
DocumentBuilder db = dbf.newDocumentBuilder();
// 通过DocumentBuilder对象的parser方法加载books.xml文件到当前的目录下
Document document = db.parse("src/com/sxt/test/bookes.xml");
// 获取所有的book节点集合
NodeList bookList = document.getElementsByTagName("book");
// 通过nodelist的getLength()方法可以获取bookList的长度
System.out.println("一共有" + bookList.getLength() + "本书");
// 遍历每一个book节点
for (int i = ; i < bookList.getLength(); i++) {
System.out.println("============开始遍历==================");
/*
* //通过item(i)方法获取一个book节点，nodelist的索引值从0开始 Node book =
* bookList.item(i); //获取book节点的所有属性集合 NamedNodeMap attr =
* book.getAttributes();
* System.out.println("第"+(i+1)+"本书共有"+attr.getLength()+"个属性");
* //遍历book属性 for(int j=0;j<attr.getLength();j++){
* //通过item(index)方法获取book节点的某一个属性 Node at = attr.item(j); //获取属性名
* System.out.println("属性名："+at.getNodeName()); //获取属性值
* System.out.println("属性值："+at.getNodeValue()); }
*/
Element book = (Element) bookList.item(i);
/*
* String attrValue = book.getAttribute("id");
* System.out.println("属性值为:"+attrValue);
*/
// 解析book节点的子节点
NodeList childnNode = book.getChildNodes();
System.out.println("第" + (i + ) + "本书共有" + childnNode.getLength()
+ "个子节点");
for (int k = ; k < childnNode.getLength(); k++) {
// 区分出text类型的node以及element类型的node
if (childnNode.item(k).getNodeType() == Node.ELEMENT_NODE) {
// 获取element类型节点的节点名
System.out.println(childnNode.item(k).getNodeName());
// System.out.println(childnNode.item(k).getFirstChild().getNodeValue());
System.out.println(childnNode.item(k).getTextContent());
}
}
System.out.println("============结束遍历==================");
}
} /*
* DOM创建XML文件
*/
@Test
public void testfun6() throws ParserConfigurationException,
TransformerException {
// 创建DocumentBuilderFactory对象
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
// 创建DocumentBuilder对象
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.newDocument();
document.setXmlStandalone(true);
Element bookstore = document.createElement("bookStore");
// 向bookstore根节点中添加子节点
Element book = document.createElement("book");
Element name = document.createElement("name");
// name.setNodeValue("小王子");
name.setTextContent("小王子");
book.appendChild(name);
book.setAttribute("id", "");
bookstore.appendChild(book);
document.appendChild(bookstore); // 创建TransformerFactory对象
TransformerFactory tff = TransformerFactory.newInstance();
// 创建Transformer对象
Transformer tf = tff.newTransformer();
tf.setOutputProperty(OutputKeys.INDENT, "yes");
tf.transform(new DOMSource(document), new StreamResult(new File(
"src/com/sxt/test/book.xml"))); } /*
* SAX解析
*/
@Test
public void testfun2() throws ParserConfigurationException, SAXException,
IOException {
// 获取一个SAXParserFactory的实例
SAXParserFactory factory = SAXParserFactory.newInstance();
// 通过factory获取SAXParser实例
SAXParser parser = factory.newSAXParser();
// 创建SAXParserHandler对象
SAXParserHandler handler = new SAXParserHandler();
parser.parse("src/com/sxt/test/bookes.xml", handler);
System.out.println("~~~~~~共有" + handler.getBookList().size());
for (Book book : handler.getBookList()) {
System.out.println(book.getId());
System.out.println(book.getAuthor());
System.out.println(book.getName());
System.out.println(book.getLanguage());
System.out.println(book.getPrice());
System.out.println(book.getYear());
} } public ArrayList<Book> parseXML() throws Exception {
// 获取一个SAXParserFactory的实例
SAXParserFactory factory = SAXParserFactory.newInstance();
// 通过factory获取SAXParser实例
SAXParser parser = factory.newSAXParser();
// 创建SAXParserHandler对象
SAXParserHandler handler = new SAXParserHandler();
parser.parse("src/com/sxt/test/bookes.xml", handler); return handler.getBookList(); } /*
* SAX创建ＸＭＬ文件
*/
@Test
public void testfun7() throws Exception {
ArrayList<Book> bookList = parseXML();
//创建一个TransformerFactory类的对象
SAXTransformerFactory tff = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
//通过SAXTransformerFactory对象创建一个TransformerHandler对象
TransformerHandler handler = tff.newTransformerHandler();
//通过handler对象创建一个Transformer对象
Transformer tr = handler.getTransformer();
//通过Transformer对象对生成的XML文件进行设置（编码）
tr.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
//通过Transformer对象进行换行
tr.setOutputProperty(OutputKeys.INDENT,"yes");
//创建一个Result对象
File f = new File("src/com/sxt/test/booke.xml");
if(!f.exists()){
f.createNewFile();
}
//创建一个Result对象，并且使其与handler关联
StreamResult result = new StreamResult(new FileOutputStream(f));
handler.setResult(result);
//打开document
handler.startDocument();
AttributesImpl attr = new AttributesImpl();
handler.startElement("", "", "bookstore", attr);
for(Book book:bookList){
attr.clear();
attr.addAttribute("", "", "id", "", book.getId());
handler.startElement("", "", "book", attr); if(book.getName()!=null&& !book.getName().trim().equals("")){
attr.clear();
//创建name节点
handler.startElement("", "", "name", attr);
handler.characters(book.getName().toCharArray(), , book.getName().length());
handler.endElement("", "", "name");
}
if(book.getAuthor()!=null&& !book.getAuthor().trim().equals("")){
attr.clear();
//创建name节点
handler.startElement("", "", "author", attr);
handler.characters(book.getAuthor().toCharArray(), , book.getAuthor().length());
handler.endElement("", "", "author");
}
if(book.getLanguage()!=null&& !book.getLanguage().trim().equals("")){
attr.clear();
//创建name节点
handler.startElement("", "", "language", attr);
handler.characters(book.getLanguage().toCharArray(), , book.getLanguage().length());
handler.endElement("", "", "language");
}
if(book.getPrice()!=null&& !book.getPrice().trim().equals("")){
attr.clear();
//创建name节点
handler.startElement("", "", "price", attr);
handler.characters(book.getPrice().toCharArray(), , book.getPrice().length());
handler.endElement("", "", "price");
}
if(book.getYear()!=null&& !book.getYear().trim().equals("")){
attr.clear();
//创建name节点
handler.startElement("", "", "year", attr);
handler.characters(book.getYear().toCharArray(), , book.getYear().length());
handler.endElement("", "", "year");
} }
handler.endElement("", "", "bookstore");
//关闭document
handler.endDocument();
} /*
* 创建JDOM
*/
@Test
public void createXML() throws Exception{
//生成一个根节点
org.jdom2.Element rss = new org.jdom2.Element("rss");
//为节点添加属性
rss.setAttribute("version", "2.0");
//生成一个document对象
org.jdom2.Document document = new org.jdom2.Document(rss);
org.jdom2.Element channel = new org.jdom2.Element("channel");
rss.addContent(channel);
org.jdom2.Element title = new org.jdom2.Element("title");
title.setText("国内国际新闻");
channel.addContent(title); Format format = Format.getPrettyFormat();
format.setIndent("");
format.setEncoding("GBK"); //创建XMLOutputter的对象
XMLOutputter outputter = new XMLOutputter(format);
//利用outputer将document对象转换为xml文档
outputter.output(document, new FileOutputStream(new File("src/com/sxt/test/res.xml")));
} /*
* JDOM解析
*/
@Test
public void testfun3() throws JDOMException, IOException {
// 创建一个SAXBuilder的对象
SAXBuilder saxBuilder = new SAXBuilder();
// 创建一个输入流，将XML文件加载到输入流中
InputStream in = new FileInputStream("src/com/sxt/test/bookes.xml");
InputStreamReader isr = new InputStreamReader(in);
// 通过saxBuilder的build方法，将输入流加载到saxBuilder中
org.jdom2.Document document = saxBuilder.build(isr);
// 通过docment对象获取xml文件的根节点
org.jdom2.Element rootElement = document.getRootElement();
// 获取根节点下面的字节点
List<org.jdom2.Element> bookList = rootElement.getChildren();
// 继续进行解析
for (org.jdom2.Element book : bookList) {
Book bookEntity = new Book();
System.out.println("=====开始解析第" + (bookList.indexOf(book) + )
+ "书=====");
// 解析book的属性
List<Attribute> attrList = book.getAttributes();
// 遍历attribute(针对不清楚book节点下属性名字及数量)
for (Attribute attr : attrList) {
// 获取属性名
String attrName = attr.getName();
// 获取属性值
String attrvValue = attr.getValue();
System.out.println("属性名：" + attrName + "----属性值：" + attrvValue);
if (attrName.equals("id")) {
bookEntity.setId(attrvValue);
}
}
List<org.jdom2.Element> bookchilds = book.getChildren();
for (org.jdom2.Element child : bookchilds) {
System.out.println("节点名：" + child.getName() + "----节点值："
+ child.getValue());
if (child.getName().equals("name")) {
bookEntity.setName(child.getValue());
} else if (child.getName().equals("author")) {
bookEntity.setAuthor(child.getValue());
} else if (child.getName().equals("year")) {
bookEntity.setYear(child.getValue());
} else if (child.getName().equals("price")) {
bookEntity.setPrice(child.getValue());
} else if (child.getName().equals("language")) {
bookEntity.setLanguage(child.getValue());
}
}
System.out.println("=====结束解析第" + (bookList.indexOf(book) + )
+ "书=====");
booksList.add(bookEntity);
bookEntity = null;
System.out.println(bookList.size());
System.out.println("=======" + booksList.get().getId());
System.out.println("=======" + booksList.get().getAuthor());
}
} /*
* 创建DOM4J
*/
@Test
public void parseXML4J() throws DocumentException {
// 创建SAXReader的对象reader
SAXReader reader = new SAXReader();
// 通过reader对象的read方法加载book.xml文件
org.dom4j.Document document = reader.read(new File(
"src/com/sxt/test/bookes.xml"));
// 通过document对象获取根节点bookstore
org.dom4j.Element bookStore = document.getRootElement();
// 通过element对象的elementIterator方法获取迭代器
Iterator<org.dom4j.Element> it = bookStore.elementIterator();
// 遍历迭代器，获取根节点中的信息（书籍）
while (it.hasNext()) {
System.out.println("=========开始遍历某一本书===========");
org.dom4j.Element book = (org.dom4j.Element) it.next();
// 获取book的属性值和属性名
List<org.dom4j.Attribute> bookattrs = book.attributes();
for (org.dom4j.Attribute attr : bookattrs) {
System.out.println("--节点名：" + attr.getName() + "--节点值："
+ attr.getValue());
}
Iterator itt = book.elementIterator();
while (itt.hasNext()) {
org.dom4j.Element bookChild = (org.dom4j.Element) itt.next();
System.out.println("节点名" + bookChild.getName() + "---节点值"
+ bookChild.getStringValue());
}
System.out.println("=========结束遍历某一本书===========");
}
} /*
* 创建DOM4J
*/
@Test
public void testfun8() throws Exception {
//创建document对象，代表整个xml文档
org.dom4j.Document document = org.dom4j.DocumentHelper.createDocument();
//创建根节点rss
org.dom4j.Element rss = document.addElement("rss");
//向rss节点中添加version属性
rss.addAttribute("version", "2.0");
//生成子节点及节点内容
org.dom4j.Element channel = rss.addElement("channel");
org.dom4j.Element title = channel.addElement("title");
title.setText("国内最新新闻");
//设置生成xml格式
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("GBK");
//生成xml文件
File file = new File("src/com/sxt/test/rssnews.xml");
XMLWriter writer = new XMLWriter(new FileOutputStream(file),format);
writer.write(document);
writer.close();
} /*
* DOM4J解析
*/
@Test
public void testfun4() throws DocumentException {
// 创建SAXReader的对象reader
SAXReader reader = new SAXReader();
// 通过reader对象的read方法加载book.xml文件
org.dom4j.Document document = reader.read(new File(
"src/com/sxt/test/bookes.xml"));
// 通过document对象获取根节点bookstore
org.dom4j.Element bookStore = document.getRootElement();
// 通过element对象的elementIterator方法获取迭代器
Iterator<org.dom4j.Element> it = bookStore.elementIterator();
// 遍历迭代器，获取根节点中的信息（书籍）
while (it.hasNext()) {
System.out.println("=========开始遍历某一本书===========");
org.dom4j.Element book = (org.dom4j.Element) it.next();
// 获取book的属性值和属性名
List<org.dom4j.Attribute> bookattrs = book.attributes();
for (org.dom4j.Attribute attr : bookattrs) {
System.out.println("--节点名：" + attr.getName() + "--节点值："
+ attr.getValue());
}
Iterator itt = book.elementIterator();
while (itt.hasNext()) {
org.dom4j.Element bookChild = (org.dom4j.Element) itt.next();
System.out.println("节点名" + bookChild.getName() + "---节点值"
+ bookChild.getStringValue());
}
System.out.println("=========结束遍历某一本书===========");
}
} @Test
public void testDemo() throws Exception {
System.out.println("性能测试");
// 测试DOM的性能
long start1 = System.currentTimeMillis();
testfun1();
System.out.println("DOM: " + (System.currentTimeMillis() - start1));
// 测试DOM的性能
long start2 = System.currentTimeMillis();
testfun2();
System.out.println("SAX: " + (System.currentTimeMillis() - start2));
// 测试DOM的性能
long start3 = System.currentTimeMillis();
testfun3();
System.out.println("JDOM: " + (System.currentTimeMillis() - start3));
// 测试DOM的性能
long start4 = System.currentTimeMillis();
testfun4();
System.out.println("DOM4J: " + (System.currentTimeMillis() - start4));
}
}
package com.sxt.test; import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler; public class MyContentHandler extends DefaultHandler{
@Override
public void startDocument() throws SAXException {
// TODO Auto-generated method stub
System.out.println("开始解析");
}
@Override
public void endDocument() throws SAXException {
// TODO Auto-generated method stub
System.out.println("结束解析");
}
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
// TODO Auto-generated method stub
System.out.println("元素解析开始");
}
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
// TODO Auto-generated method stub
System.out.println("元素解析结束");
}
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
// TODO Auto-generated method stub
String s = new String(ch,start,length);
if(s.trim().isEmpty()){
return;
}
System.out.println("文本内容为"+s);
}
@Override
public void ignorableWhitespace(char[] ch, int start, int length)
throws SAXException {
// TODO Auto-generated method stub
System.out.println("文本内容为空");
}
@Override
public void processingInstruction(String target, String data)
throws SAXException {
// TODO Auto-generated method stub
System.out.println("处理指令");
}
}
四种解析和创建方式（DOM，SAX，DOM4J，JDOM）的更多相关文章
- java解析xml的方式DOM,SAX,DOM4J,JDOM,StAX
1)DOM(JAXP Crimson解析器)DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准.DOM是以层次结构组织的节点或信息片断的集合.这个层次结构允许开发人员在树中寻找 特定信息. ...
- xml常用四种解析方式优缺点的分析×××××
xml常用四种解析方式优缺点的分析 博客分类: xml 最近用得到xml的解析方式,于是就翻了翻自己的笔记同时从网上查找了资料,自己在前人的基础上总结了下,贴出来大家分享下. 首先介绍一下xml语 ...
- 解析XML文件的几种常见操作方法—DOM/SAX/DOM4j
解析XML文件的几种常见操作方法—DOM/SAX/DOM4j 一直想学点什么东西,有些浮躁,努力使自己静下心来看点东西,哪怕是回顾一下知识.看到了xml解析,目前我还没用到过.但多了解一下,加深点记忆 ...
- Spring中四种实例化bean的方式
本文主要介绍四种实例化bean的方式(注入方式) 或者叫依赖对象实例化的四种方式.上面的程序,创建bean 对象,用的是什么方法 ,用的是构造函数的方式 (Spring 可以在构造函数私有化的情况下把 ...
- java正则表达式四种常用的处理方式是怎么样呢《匹配、分割、代替、获取》
java 正则表达式高级篇,介绍四种常用的处理方式:匹配.分割.替代.获取,具体内容如下package test; import java.util.regex.Matcher; import jav ...
- java内部类及四种内部类的实现方式
java内部类及四种内部类的实现方式 一.内部类定义:内部类分为: 成员内部类.静态嵌套类.方法内部类.匿名内部类. 二.为何要内部类?a.内部类提供了某种进入外围类的窗户.b.也是最吸引人的原因, ...
- XML解析——Java中XML的四种解析方式
XML是一种通用的数据交换格式,它的平台无关性.语言无关性.系统无关性.给数据集成与交互带来了极大的方便.XML在不同的语言环境中解析方式都是一样的,只不过实现的语法不同而已. XML的解析方式分为四 ...
- XML解析——Java中XML的四种解析方式（转载 by 龍清扬）
XML是一种通用的数据交换格式,它的平台无关性.语言无关性.系统无关性.给数据集成与交互带来了极大的方便.XML在不同的语言环境中解析方式都是一样的,只不过实现的语法不同而已. XML的解析方式分为四 ...
- Java中XML的四种解析方式（一）
XML是一种通用的数据交换格式,它的平台无关性.语言无关性.系统无关性给数据集成与交互带来了极大的方便.XML在不同的语言环境中解析的方式都是一样的,只不过实现的语法不同而已. XML文档以层级标签的 ...
随机推荐
- ajax请求和aspx返回数据
ajax请求: $(function () { $.ajax({ url: "index.aspx?method=send", ...
- (转) 将ASP.NET Core应用程序部署至生产环境中（CentOS7）
原文链接: http://www.cnblogs.com/ants/p/5732337.html 阅读目录 环境说明 准备你的ASP.NET Core应用程序 安装CentOS7 安装.NET Cor ...
- python select网络编程详细介绍
刚看了反应堆模式的原理,特意复习了socket编程,本文主要介绍python的基本socket使用和select使用,主要用于了解socket通信过程 一.socket模块 socket - Low- ...
- BZOJ 3083: 遥远的国度 [树链剖分 DFS序 LCA]
3083: 遥远的国度 Time Limit: 10 Sec Memory Limit: 1280 MBSubmit: 3127 Solved: 795[Submit][Status][Discu ...
- [PHP源码阅读]explode和implode函数
explode和implode函数主要用作字符串和数组间转换的操作,比如获取一段参数后根据某个字符分割字符串,或者将一个数组的结果使用一个字符合并成一个字符串输出.在PHP中经常会用到这两个函数,因此 ...
- 用lucene替代mysql读库的尝试
采用lucene对mysql中的表建索引,并替代全文检索操作. 备注:代码临时梳理很粗糙,后续修改. import java.io.File; import java.io.IOException; ...
- ValueInjecter----最好用的OOM(以微信消息转对象举例)
使用数据实体的好处我这里就不多说了,但大家享受这些好处的时候,难免也对那些琐碎的赋值代码感到厌烦,基于此,我认为掌握一个oom的使用,还是很有必要的. 这种类型的工具有很多,比如automapper, ...
- C++虚函数和函数指针一起使用
C++虚函数和函数指针一起使用,写起来有点麻烦. 下面贴出一份示例代码,可作参考.(需要支持C++11编译) #include <stdio.h> #include <list> ...
- python实现一个控制台下的进度条
今天写练习爬虫感觉很需要个进度条,就随手用函数实现了一个,到了晚上突然感觉到这个东西应该单独写出来以后肯定用用得着. 代码也很简单,我就不细讲了,直接上代码了. 测试代码: instance.py i ...
- CATransition自定义转场动画
我们可以通过CATransiton来自定义一些漂亮的转场动画, CATransition继承自CAAnimation, 所以用法跟CAAnimation差不多 先直接上一个代码: #import &q ...