XML之Sax(simple api for xml )解析：
主实现类：
package com.xml;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.junit.Test;
import org.xml.sax.SAXException;
/*
* Sex解析的特点:
* 1.基于事件的读取
* 2.基于顺序的读取,速度快
* 3.不能任意读取节点(灵活性差一些)
* 4.sex更适用于在要求跟高的设备上使用(Android开发中);
* 5.解析时占用内存小
*/
public class ImplementsXML {
@Test
public static void saxparsemxl() {
//1.创建一个sax解析工厂对象
SAXParserFactory spf=SAXParserFactory.newInstance();
//2.通过工厂对象创建sax解析器
try {
SAXParser sp= spf.newSAXParser();
//3.创建一个数据处理器(需要我们自己来编写)
dataParser dp=new dataParser();
//4.开启解析
InputStream is= Thread.currentThread().getContextClassLoader().getResourceAsStream("com/xml/NewFile.xml");
try {
//参数一输入文件字节流 /参数二 自己编写的数据处理器
sp.parse(is,dp);
ArrayList<person> p=dp.getPersons();
//通过for循环输出对象
for(person p1:p) {
System.out.println(p1);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
//调用解析xml的方法
saxparsemxl();
}
}
数据处理器类：
package com.xml;
import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class dataParser extends DefaultHandler {
private ArrayList<person> persons=new ArrayList<person>();
private person p;//当前正在解析的person对象
private String tag;//用于记录正在解析的标签名
public ArrayList<person> getPersons() {
return persons;
}
@Override
public void startDocument() throws SAXException {
// TODO Auto-generated method stub
super.startDocument();
;
System.out.println("开启解析文档>>>>>>>>>");
}
@Override
public void endDocument() throws SAXException {
// TODO Auto-generated method stub
super.endDocument();
System.out.println("文档解析结束.");
}
//解析开始元素时调用
/*
* String 命名空间, String 不带前缀的标签名字, String 不带前缀的标签名字, Attributes 当前标签的属性集合
*/
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
// TODO Auto-generated method stub
super.startElement(uri, localName, qName, attributes);
//表示解析到了person标签
if("person".equals(qName)) {
p=new person();
String id=attributes.getValue("person");
//设置id
p.setId(id);
}
tag=qName;
System.out.println("startElement"+qName);
}
//解析结束元素时调用
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
// TODO Auto-generated method stub
super.endElement(uri, localName, qName);
if("person".equals(qName)) {
persons.add(p);
tag=null;
}
System.out.println("endElement"+qName);
}
//解析文本时调用
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
// TODO Auto-generated method stub
super.characters(ch, start, length);
if(tag !=null) {
if("name".equals(tag)){
p.setName(new String(ch,start,length));
}else if("address".equals(tag)) {
p.setAddress(new String (ch,start,length));
}else if("tel".equals(tag)) {
p.setTel(new String (ch,start,length));
}else if("fax".equals(tag)) {
p.setFax(new String (ch,start,length));
}else if("email".equals("tag")) {
p.setEmail(new String (ch,start,length));
}
}
System.out.println(ch);
}
}
解析的对象person类
package com.xml;
public class person {
private String name;
private String address;
private String email;
private String tel;
private String fax;
private String id;
public person() {
super();
// TODO Auto-generated constructor stub
}
public person(String name, String address, String email, String tel, String fax, String id) {
super();
this.name = name;
this.address = address;
this.email = email;
this.tel = tel;
this.fax = fax;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
public String getFax() {
return fax;
}
public void setFax(String fax) {
this.fax = fax;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Override
public String toString() {
return "person [name=" + name + ", address=" + address + ", email=" + email + ", tel=" + tel + ", fax=" + fax
+ ", id=" + id + "]";
}
}xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<persion>
<person id="p1">
<name>小红</name>
<address>上海</address>
<tel>100886</tel>
<fax>001100</fax>
<email>[email protected]</email>
</person>
<person id="p2">
<name>小明</name>
<address>上海</address>
<tel>189886</tel>
<fax>011110</fax>
<email>[email protected]</email>
</person>
</persion>
XML之Dom(document Object Modo)解析：
package com.xml;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/*
* DOM解析mxl
* 1.基于树形结构,通过解析器一次性把文档加载到内存中,
* 会比较占用内存,可以随机访问,跟适用于web开发中使用
*/
public class domeParserXml {
public static void parset() {
//1.创建一个dom解析器工厂
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
//2.通过工厂对象创建解析器对象
//4.从内存中读取数据
try {
DocumentBuilder db=factory.newDocumentBuilder();
//3.解析文档
InputStream is=Thread.currentThread().getContextClassLoader().getResourceAsStream("com/xml/NewFile.xml");
try {
//此代码执行后整个xml已经加载到内存当中,以树状形式存储
Document doc=db.parse(is);//通过解析器进行解析
//返回一个NodeList节点
person p=null;
NodeList nl=doc.getElementsByTagName("person");
ArrayList<person> persons=new ArrayList<>();
//遍历NodeList节点
//获取属性值
for(int i=0;i<nl.getLength();i++) {
Node personNode=nl.item(i);
p=new person();
String s=personNode.getAttributes().getNamedItem("id").getNodeValue();
p.setId(s);
//获取当前节点的所有子节点
NodeList childNodel=doc.getChildNodes();
for(int j=0;j<childNodel.getLength();j++) {
Node item=childNodel.item(j);
String nodename=item.getNodeName();
if("name".equals(nodename)) {
p.setName(item.getFirstChild().getNodeValue());
}else if("address".equals(nodename)) {
p.setAddress(item.getFirstChild().getNodeValue());
}else if("email".equals(nodename)) {
p.setEmail(item.getFirstChild().getNodeValue());
}else if("fax".equals(nodename)) {
p.setFax(item.getFirstChild().getNodeValue());
}else if("tel".equals(nodename)) {
p.setTel(item.getFirstChild().getNodeValue());
}
persons.add(p);
}
for(person person:persons) {
System.out.println(person);
}
}
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
parset();
}
}
XML之JDom(java document Object Modo)解析：
package com.xml;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
/*
* JDOM解析 xml
* 1.于dom类似,都是基于树形结构
* 2.于dom的区别
* (1)第三方开源的组件
* (2)实现使用java的collection接口
* (3)效率比DOM更快
*
*/
public class JDomParserXml {
public static void parser() {
//创建JDOM解析器
//注意他不是SAX,只是名字叫SAX
SAXBuilder sb=new SAXBuilder();
InputStream is=Thread.currentThread().getContextClassLoader().getResourceAsStream("com/xml/NewFile.xml");
try {
//开始解析
Document build=sb.build(is);
//获取根节点
Element rootelemnt =build.getRootElement();
List<person> list=new ArrayList<>();
person person=null;
//根节点根节点获取子元素：返回list person对象集合
List<Element> childList=rootelemnt.getChildren();
for(Element element:childList ) {
person=new person();
String id=element.getAttributeValue("id");
person.setId(id);
List<Element> ChildrenList= element.getChildren();
for(Element e:ChildrenList ) {
//取到标签名字
String tag=e.getName();
if("name".equals(tag)) {
person.setName(e.getText());
}else if("address".equals(tag)) {
person.setAddress(e.getText());
}else if("email".equals(tag)) {
person.setEmail(e.getText());
}else if("fax".equals(tag)) {
person.setFax(e.getText());
}else if("tel".equals(tag)) {
person.setTel(e.getText());
}
}
list.add(person);
}
for(person p:list) {
System.out.println(p);
}
} catch (JDOMException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
parser();
}
}
XML之Dom4J(document Object Modo for java)解析：
注意4j不念4,而是读for
package com.xml;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/*
* JDOM解析 xml
* 1.于DOM,都是基于树形结构
* 2.于第三方开源的组件,效率比DOM更快
* 3.JDOM和DOM在性能测试时性能表示不加,在测试10m文档时内存溢出
* SAX表现较好,这事依赖与它的解析特性
* DOM4J是这场测试的获胜者
*/
public class dom4jparser {
public static void parser() throws IOException {
//创建DOM4j解析器
SAXReader reader=new SAXReader();
InputStream is=Thread.currentThread().getContextClassLoader().getResourceAsStream("com/xml/NewFile.xml");
try {
//返回 DOM4j包中的的 document对象
Document dc=reader.read(is);
Element rootelement=dc.getRootElement();
//获取迭代器
Iterator<Element> iterator=rootelement.elementIterator();
ArrayList<person> personList=new ArrayList<>();
person p=null;
//循环素如
while(iterator.hasNext()) {
p=new person();
Element e=iterator.next();
p.setId(e.attributeValue("id"));
//Iterator<Element> iterator1 = null;
while(iterator.hasNext()) {
Element name=iterator.next();
String tag=name.getName();
if("name".equals(tag)) {
p.setName(name.getText());
}else if("address".equals(tag)) {
p.setAddress(name.getText());
}else if("email".equals(tag)) {
p.setEmail(name.getText());
}else if("fax".equals(tag)) {
p.setFax(name.getText());
}else if("tel".equals(tag)) {
p.setTel(name.getText());
}
}
personList.add(p);
}
for(person pp:personList) {
System.out.println(pp);
}
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
parser();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
XmlDecoder和XmlEncoder解析xml文件
package com.xml;
import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class xmlDome {
//**************************XML编码方法***************************
public static void xmlEnCoder() {
OutputStream out = null;
try {
out = new FileOutputStream("C:\\Users\\龙布天下\\Desktop\\long.xml");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
BufferedOutputStream bos=new BufferedOutputStream(out);
//创建编码器
XMLEncoder xmlEncoder=new XMLEncoder(out);
person p=new person();
p.setName("小亮");
p.setAddress("上海");
p.setEmail("[email protected]");
p.setFax("05112");
p.setTel("100990");
p.setId("01");
xmlEncoder.writeObject(p);
xmlEncoder.close();
}
//**************************XML解码方法***************************
public static void xmlDeCoder() {
InputStream in = null;
try {
in = new FileInputStream("C:\\Users\\龙布天下\\Desktop\\long.xml");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
XMLDecoder xmlDecoder=new XMLDecoder(in);
person p=(person) xmlDecoder.readObject();
System.out.println(p);
}
public static void main(String[] args) {
//调用编码方法
xmlEnCoder();
//调用解码方法
xmlDeCoder();
}
}
XStream工具解析xml文件
package com.xml;
import com.thoughtworks.xstream.io.xml.Xpp3DomDriver;
/*
* 使用xStream工具实现XML的解析与生成
*/
public class XStream {
public static void XStream() {
person p=new person();
p.setName("小亮");
p.setAddress("上海");
p.setEmail("[email protected]");
p.setFax("05112");
p.setTel("100990");
p.setId("01");
//创建XPP驱动
//Xpp3DomDriver xpp=new Xpp3DomDriver();
com.thoughtworks.xstream.XStream x=new com.thoughtworks.xstream.XStream(new Xpp3DomDriver());
//根节点取别名
x.alias("person",person.class);
//属性值取别名
x.useAttributeFor(person.class,"id");
String s=x.toXML(p);
System.out.println(s);
//注意！！！！！！！！！！！！！！！！开始解析;
//返回person对象
person person=(com.xml.person) x.fromXML(s);
System.out.println(person);
}
public static void main(String[] args) {
//调用方法
XStream();
}
}
**
xml常用四种解析方式优缺点的分析
**
xml
最近用得到xml的解析方式，于是就翻了翻自己的笔记同时从网上查找了资料，自己在前人的基础上总结了下，贴出来大家分享下。
首先介绍一下xml语言：
可扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。
xml的语法：
XML 分为两部分：头信息，主体信息
头信息是用来描述 XML 的一些属性，例如：版本，编码等，还可以提供 XML 显示的样式，和 dtd 编写格式。
主体信息中包含的是 XML 的具体数据。
头信息的语法：
<?xml version =”1.0” encoding =”GBK” ?>
其中 version 是必须加的，而 encoding 可以不写，则默认编码是 ISO8859-1 ，不支持中文。
除了这个功能外，头信息还可以进行编写格式的规定，通过 dtd 或 xsd 文件。
头信息还支持样式表的导入，允许通过样式表控制 XML 的显示。
这样可以使用 XML+ CSS 完成页面的显示，通过这种形式完成 MVC 中的 View 层：
优点：代码的安全性很高，可以很容易的替换模板。
缺点：开发成本太高
主体信息 就是由三种节点组成的，节点之间存在父与子的关系，注意的点：
一个节点只能有一个父节点，如果没有父节点，该节点称为根节点。
一个节点可以有多个子节点。只有元素节点可以拥有子节点。
元素节点的标记必须成对出现，或直接结束。
特殊字符必须转义。依据字符所处的位置是否对 XML 格式造成影响来决定是否进行转义
根节点只能有一个
xml常用的四种解析方式：
1）DOM（Document Object Model）
文档对象模型分析方式。以层次结构（类似于树型）来组织节点和信息片段，映射XML文档的结构，允许获取和操作文档的任意部分。是W3C的官方标准。
优点：
1、允许应用程序对数据和结构做出更改。
2、访问是双向的，可以在任何时候在树中上下导航，获取和操作任意部分的数据。
缺点：
1、通常需要加载整个XML文档来构造层次结构，消耗资源大
2）SAX（Simple API for XML）
流模型中的推模型分析方式。通过事件驱动，每发现一个节点就引发一个事件，通过回调方法完成解析工作，解析XML文档的逻辑需要应用程序完成。
优点：
1、不需要等待所有数据都被处理，分析就能立即开始。
2、只在读取数据时检查数据，不需要保存在内存中。
3、可以在某个条件得到满足时停止解析，不必解析整个文档。
4、效率和性能较高，能解析大于系统内存的文档。
缺点：
1、需要应用程序自己负责TAG的处理逻辑（例如维护父/子关系等），使用麻烦。
2、单向导航，很难同时访问同一文档的不同部分数据，不支持XPath。
3）JDOM（Java-based Document Object Model）
Java特定的文档对象模型。自身不包含解析器，使用SAX。
优点：
1、使用具体类而不是接口，简化了DOM的API。
2、大量使用了Java集合类，方便了Java开发人员。
缺点：
1、没有较好的灵活性。
2、性能较差。
4）DOM4J（Document Object Model for Java）
简单易用，采用Java集合框架，并完全支持DOM、SAX和JAXP。
优点：
1、大量使用了Java集合类，方便Java开发人员，同时提供一些提高性能的替代方法。
2、支持XPath。
3、有很好的性能。
缺点：
1、大量使用了接口，API较为复杂。
