你所不知道的XML与JSON
一、XML：
XML（Extensible Markup Language 可扩展标记语言），XML是一个以文本来描述数据的文档。
1. 示例：
Tony
10 Downing Street, London, UK
(061) 98765
(061) 98765
[email protected]
Bill
White House, USA
(001) 6400 98765
(001) 6400 98765
[email protected]
2. 用途：
（1）充当显示数据（以XML充当显示层）
（2）存储数据（存储层）的功能
（3）以XML描述数据，并在联系服务器与系统的其余部分之间传递。(传输数据的一样格式)
从某种角度讲，XML是数据封装和消息传递技术。
3.解析XML：
3.1 :使用SAX解析XML
3.1.1 什么是SAX:
SAX是Simple API for XML的缩写
SAX 是读取和操作 XML 数据更快速、更轻量的方法。SAX 允许您在读取文档时处理它，从而不必等待整个文档被存储之后才采取操作。它不涉及 DOM 所必需的开销和概念跳跃。 SAX API是一个基于事件的API ，适用于处理数据流，即随着数据的流动而依次处理数据。SAX API 在其解析您的文档时发生一定事件的时候会通知您。在您对其响应时，您不作保存的数据将会被抛弃。
3.1.2 SAX解析XML方式：
SAX API中主要有四种处理事件的接口，它们分别是ContentHandler，DTDHandler， EntityResolver 和 ErrorHandler 。实际上只要继承DefaultHandler 类就可以，DefaultHandler实现了这四个事件处理器接口，然后提供了每个抽象方法的默认实现。
// 创建SAX解析器工厂对象
SAXParserFactory spf = SAXParserFactory.newInstance();
// 使用解析器工厂创建解析器实例
SAXParser saxParser = spf.newSAXParser();
// 创建SAX解析器要使用的事件侦听器对象
PersonHandler handler =
new PersonHandler();
// 开始解析文件
saxParser.parse(
new File(fileName), handler);3.2. DOM解析XML:
DOM：Document Object Model（文档对象模型）
DOM的特性：
定义一组 Java 接口，基于对象，与语言和平台无关将 XML 文档表示为树，在内存中解析和存储 XML 文档，允许随机访问文档的不同部分。
DOM解析XML
DOM的优点，由于树在内存中是持久的，因此可以修改后更新。它还可以在任何时候在树中上下导航，API使用起来也较简单。
DocumentBuilderFactory builder = DocumentBuilderFactory.newInstance();
DocumentBuilder db = builder.newDocumentBuilder();
db.parse("person.xml");
NodeList node_person = doc.getElementsByTagName("person");
3.3. JDOM解析XML:
JDOM是两位著名的 Java 开发人员兼作者，Brett Mclaughlin 和 Jason Hunter 的创作成果， 2000 年初在类似于Apache协议的许可下，JDOM作为一个开放源代码项目正式开始研发了。
JDOM 简化了与 XML 的交互并且比使用 DOM 实现更快，JDOM 与 DOM 主要有两方面不同。首先，JDOM 仅使用具体类而不使用接口。这在某些方面简化了 API，但是也限制了灵活性。第二，API 大量使用了 Collections 类，简化了那些已经熟悉这些类的 Java 开发者的使用。
解析步骤：
（1）SAXBuilder sax = new SAXBuilder();
（2）Document doc = sax.build(….);
（3）Element el = doc.getRootElement();（4）List list = el.getChildren();
（5）遍历内容
3.4. DOM4J解析XML:
dom4j是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在对主流的Java XML API进行的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的是连Sun的JAXM也在用dom4j。这是必须使用的jar包， Hibernate用它来读写配置文件。
解析步骤：
（1）SAXReader sax = new SAXReader();
（2）Document doc = sax.read(Thread.currentThread().getContextClassLoader()
.getResourceAsStream("person.xml"));
（3）Element root = doc.getRootElement();
（4）Iterator iterator = root.elementIterator();
（5）遍历迭代器
4.各种解析方法比较:
JDOM 和 DOM 在性能测试时表现不佳，在测试 10M 文档时内存溢出。
SAX表现较好，这要依赖于它特定的解析方式。一个 SAX 检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中。DOM4J是这场测试的获胜者，目前许多开源项目中大量采用 DOM4J，例如大名鼎鼎的 Hibernate 也用 DOM4J 来读取 XML 配置文件。
xstream 实现XML的转换
5.案例：
public class Person {
private String personid;
private String name;
private String address;
private String tel;
private String fax;
private String email;
@Override
public String toString() {
return "Person{" +
"personid='" + personid + '\'' +
", name='" + name + '\'' +
", address='" + address + '\'' +
", tel='" + tel + '\'' +
", fax='" + fax + '\'' +
", email='" + email + '\'' +
'}';
}
public String getPersonid() {
return personid;
}
public void setPersonid(String personid) {
this.personid = personid;
}
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 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 getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
Tony Blair
10 Downing Street, London, UK
(061) 98765
(061) 98765
[email protected]
Bill Clinton
White House, USA
(001) 6400 98765
(001) 6400 98765
[email protected]
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import java.util.ArrayList;
import java.util.List;
/**
* Created by Hu Guanzhong
* SAX解析的特点：
* 1、基于事件驱动
* 2、顺序读取，速度快
* 3、不能任意读取节点（灵活性差）
* 4、解析时占用的内存小
* 5、SAX更适用于在性能要求更高的设备上使用（Android开发中）
*
*/
public class PersonHandler extends DefaultHandler{
private List persons = null;
private Person p;//当前正在解析的person
private String tag;//用于记录当前正在解析的标签名
public List getPersons() {
return persons;
}
//开始解析文档时调用
@Override
public void startDocument() throws SAXException {
super.startDocument();
persons = new ArrayList<>();
System.out.println("开始解析文档...");
}
//在XML文档解析结束时调用
@Override
public void endDocument() throws SAXException {
super.endDocument();
System.out.println("解析文档结束.");
}
/**
* 解析开始元素时调用
* @param uri 命名空间
* @param localName 不带前缀的标签名
* @param qName 带前缀的标签名
* @param attributes 当前标签的属性集合
* @throws SAXException
*/
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
super.startElement(uri, localName, qName, attributes);
if ("person".equals(qName)){
p = new Person();
String personid = attributes.getValue("personid");
p.setPersonid(personid);
}
tag = qName;
System.out.println("startElement--"+qName);
}
//解析结束元素时调用
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
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 {
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);
}
}
}
public class XMLDemo {
/**
* 使用第三方xstream组件实现XML的解析与生成
*/
@Test
public void xStream(){
Person p = new Person();
p.setPersonid("1212");
p.setAddress("北京");
p.setEmail("[email protected]");
p.setFax("6768789798");
p.setTel("13838389438");
p.setName("38");
XStream xStream = new XStream(new Xpp3Driver());
xStream.alias("person",Person.class);
xStream.useAttributeFor(Person.class,"personid");
String xml = xStream.toXML(p);
System.out.println(xml);
//解析XML
Person person = (Person)xStream.fromXML(xml);
System.out.println(person);
}
/**
* 从XML文件中读取对象
*/
@Test
public void xmlDecoder() throws FileNotFoundException {
BufferedInputStream in = new BufferedInputStream(new FileInputStream("test.xml"));
XMLDecoder decoder = new XMLDecoder(in);
Person p = (Person)decoder.readObject();
System.out.println(p);
}
/**
* 把对象转成XML文件写入
*/
@Test
public void xmlEncoder() throws FileNotFoundException {
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.xml"));
XMLEncoder xmlEncoder = new XMLEncoder(bos);
Person p = new Person();
p.setPersonid("1212");
p.setAddress("北京");
p.setEmail("[email protected]");
p.setFax("6768789798");
p.setTel("13838389438");
p.setName("38");
xmlEncoder.writeObject(p);
xmlEncoder.close();
}
/**
* DOM4J解析XML
* 基于树型结构，第三方组件
* 解析速度快，效率更高，使用的JAVA中的迭代器实现数据读取，在WEB框架中使用较多（Hibernate)
*
*/
@Test
public void dom4jParseXML() throws DocumentException {
//1 创建DOM4J的解析器对象
SAXReader reader = new SAXReader();
InputStream is = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("com/vince/xml/person.xml");
org.dom4j.Document doc = reader.read(is);
org.dom4j.Element rootElement = doc.getRootElement();
Iterator iterator = rootElement.elementIterator();
ArrayList persons = new ArrayList<>();
Person p = null;
while(iterator.hasNext()){
p = new Person();
org.dom4j.Element e = iterator.next();
p.setPersonid(e.attributeValue("personid"));
Iterator iterator1 = e.elementIterator();
while(iterator1.hasNext()){
org.dom4j.Element next = iterator1.next();
String tag = next.getName();
if("name".equals(tag)){
p.setName(next.getText());
}else if("address".equals(tag)){
p.setAddress(next.getText());
}else if("tel".equals(tag)){
p.setTel(next.getText());
}else if("fax".equals(tag)){
p.setFax(next.getText());
}else if("email".equals(tag)){
p.setEmail(next.getText());
}
}
persons.add(p);
}
System.out.println("结果：");
System.out.println(Arrays.toString(persons.toArray()));
}
/**
* JDOM解析 XML
* 1、与DOM类似基于树型结构，
* 2、与DOM的区别：
* （1）第三方开源的组件
* （2）实现使用JAVA的Collection接口
* （3）效率比DOM更快
*/
@Test
public void jdomParseXML() throws JDOMException, IOException {
//创建JDOM解析器
SAXBuilder builder = new SAXBuilder();
InputStream is = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("com/vince/xml/person.xml");
org.jdom2.Document build = builder.build(is);
Element rootElement = build.getRootElement();
List list = new ArrayList<>();
Person person = null;
List children = rootElement.getChildren();
for(Element element: children){
person = new Person();
String personid = element.getAttributeValue("personid");
person.setPersonid(personid);
List children1 = element.getChildren();
for (Element e: children1){
String tag = e.getName();
if("name".equals(tag)){
person.setName(e.getText());
}else if("address".equals(tag)){
person.setAddress(e.getText());
}else if("tel".equals(tag)){
person.setTel(e.getText());
}else if("fax".equals(tag)){
person.setFax(e.getText());
}else if("email".equals(tag)){
person.setEmail(e.getText());
}
}
list.add(person);
}
System.out.println("结果：");
System.out.println(Arrays.toString(list.toArray()));
}
/**
* DOM解析XML
* 1、基于树型结构，通过解析器一次性把文档加载到内存中，所以会比较占用内存，可以随机访问
* 更加灵活，更适合在WEB开发中使用
*/
@Test
public void domParseXML() throws ParserConfigurationException, IOException, SAXException {
//1、创建一个DOM解析器工厂对象
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
//2、通过工厂对象创建解析器对象
DocumentBuilder documentBuilder = factory.newDocumentBuilder();
//3、解析文档
InputStream is = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("com/vince/xml/person.xml");
//此代码完成后，整个XML文档已经被加载到内存中，以树状形式存储
Document doc = documentBuilder.parse(is);
//4、从内存中读取数据
//获取节点名称为person的所有节点，返回节点集合
NodeList personNodeList = doc.getElementsByTagName("person");
ArrayList persons = new ArrayList<>();
Person p = null;
//此循环会迭代两次
for (int i=0;i persons = personHandler.getPersons();
for (Person p:persons){
System.out.println(p);
}
}
}
二、JSON：
1. 示例：
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 JSON 官方:http://www.json.org
JSON 数据格式的特点
JSON 建构于两种结构：
1、 “名称/值”对的集合
2.、 值的有序列表（数组）
JSON 表示名称 / 值对的方式 ：
{ "firstName": "vince", "lastName":"ma", "email": "[email protected]" }
表示数组
{ "user": { "firstName": "vince", "lastName":"ma", "email": "[email protected]" },
{ "firstName": "lin", "lastName":"jacks", "email": “[email protected]”}]
}
2. 使用GSON解析JSON：
//GSON是Google开发的Java API，用于转换Java对象和Json对象。
//下载地址：http://www.mvnrepository.com/artifact/com.google.code.gson/gson
//解析JSON：
JsonReader reader = new JsonReader(new StringReader(jsonData));
//生成JSON：
private String createJSON(ArrayList users) {
JSONObject jsonObject = new JSONObject();JSONArray array = new JSONArray();
int size = users.size();
try {for (int i = 0; i < size; i++) {
User user = users.get(i); JSONObject object = new JSONObject();
object.put("name", user.name);object.put("age", user.age);array.put(object);}
jsonObject.put("users",array);
return jsonObject.toString();
} catch (JSONException e) {e.printStackTrace();}
return null;
}
static class User {String name; int age;//…}
//使用 Gson 直接把 JSON 数据转换成 Java 对象
public Student parserJSON2(String data){
Gson gson = new Gson();
Student s = gson.fromJson(data, Student.class);
return s;
}
//使用 Gson 直接把 JSON 数组转换成 Java 对象
public List parserJSON3(String data){
Type type = new TypeToken>(){}.getType();
Gson gson = new Gson();
List list = gson.fromJson(data, type);
return list;
}
3. 案例：
public class JsonDemo{
/**
* 使用JsonReader解析复杂的JSON数据
*/
@Test
public void parseJSONMessages(){
InputStream is = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("message.json");
InputStreamReader in = new InputStreamReader(is);
JsonReader jsonReader = new JsonReader(in);
ArrayList list = readMessageArray(jsonReader);
for (Message m: list){
System.out.println(m);
}
}
//读取Message数组
private ArrayList readMessageArray(JsonReader jsonReader) {
ArrayList list = new ArrayList<>();
try {
jsonReader.beginArray();
while(jsonReader.hasNext()){
list.add(readMessage(jsonReader));
}
jsonReader.endArray();
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
//解析一个Message对象
private Message readMessage(JsonReader jsonReader) {
Message m = new Message();
try {
jsonReader.beginObject();
while (jsonReader.hasNext()){
String name = jsonReader.nextName();
if("id".equals(name)){
m.setId(jsonReader.nextLong());
}else if("text".equals(name)){
m.setText(jsonReader.nextString());
}else if("geo".equals(name) && jsonReader.peek()!= JsonToken.NULL){
m.setGeo(readGeo(jsonReader));
}else if("user".equals(name)){
m.setUser(readUser(jsonReader));
}else{
jsonReader.skipValue();
}
}
jsonReader.endObject();
} catch (IOException e) {
e.printStackTrace();
}
return m;
}
/**
* 解析User对象
* @param jsonReader
* @return
*/
private User readUser(JsonReader jsonReader) {
User user = new User();
try {
jsonReader.beginObject();
while (jsonReader.hasNext()){
String name = jsonReader.nextName();
if("name".equals(name)){
user.setName(jsonReader.nextString());
}else if("followers_count".equals(name)){
user.setFollowers_count(jsonReader.nextInt());
}else{
jsonReader.skipValue();
}
}
jsonReader.endObject();
} catch (IOException e) {
e.printStackTrace();
}
return user;
}
/**
* 解析GEO
* @param jsonReader
* @return
*/
private ArrayList readGeo(JsonReader jsonReader) {
ArrayList list = new ArrayList<>();
try {
jsonReader.beginArray();
while (jsonReader.hasNext()){
list.add(jsonReader.nextDouble());
}
jsonReader.endArray();
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
}
[
{
"id": 912345678901,
"text": "How do I read a JSON stream in Java?",
"geo": null,
"user": {
"name": "json_newb",
"followers_count": 41
}
},
{
"id": 912345678902,
"text": "@json_newb just use JsonReader!",
"geo": [50.454722, -104.606667],
"user": {
"name": "jesse",
"followers_count": 2
}
}
]public class User {
private String name;
private int followers_count;
public User() {
}
public User(String name, int followers_count) {
this.name = name;
this.followers_count = followers_count;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getFollowers_count() {
return followers_count;
}
public void setFollowers_count(int followers_count) {
this.followers_count = followers_count;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", followers_count=" + followers_count +
'}';
}
}
三、 XML与JSON的比较：
从以下6点比较JSON与XML：
1、JSON和XML的数据可读性基本相同
2、JSON和XML同样拥有丰富的解析手段
3、JSON相对于XML来讲，数据的体积小
4、JSON与JavaScript的交互更加方便
5、JSON对数据的描述性比XML较差
6、JSON的速度要远远快于XML
适合的场景：
（1）数据传输：JSON要比XML更有优势
（2）存储数据：XML描述性更强
（3）XML通常用做配置文件