XML 和 json 解析比较

1. 定义

XML，即 extensible Markup Language ，是一种数据标记语言 & 传输格式

---

2. 作用

对数据进行标记（结构化数据）、存储 & 传输

区别于 html ：html用于显示信息；而 XML用于存储&传输信息

---

3. 特点

示意图

---

4. 语法

• 元素要关闭标签
  < p >this is a bitch <p>
• 对大小写敏感

< P >这是错误的<p>
< p >这是正确的 <p>

• 必须要有根元素(父元素）

<root>
   <kid>
   </kid>
</root>

• 属性值必须加引号

<note date="16/08/08">
</note>

• 实体引用

实体引用	符号	含义
&lt；	<	小于
&gt ；	>	大于
&amp；	&	和浩
&apos；	‘	单引号
&quot；	"	双引号

元素不能使用&(实体的开始）和<（新元素的开始）

• 注释
  ``

• XML的元素、属性和属性值

文档实例

<bookstore>
  <book category="CHILDREN">
     <title lang="en"> Harry Potter </title>
     <author> JK.Rowling</author>
  </book>
<book category="WEB">
     <title lang="en"> woshiPM </title>
     <author>Carson_Ho</author>
  </book>
</bookstore>

其中，<bookstore>是根元素；<book>是子元素，也是元素类型之一；而<book>中含有属性，即category，属性值是CHILDREN；而元素<author>则拥有文本内容（ JK.Rowling）

• 元素与属性的差别
  属性即提供元素额外的信息，但不属于数据组成部分的信息。

范例一

<bookstore>
  <book category="CHILDREN">
     <title lang="en"> Harry Potter </title>
     <author> JK.Rowling</author>
  </book>

范例二

<bookstore>
  <book >
     <category>CHILDREN<category>
     <title lang="en"> Harry Potter </title>
     <author> JK.Rowling</author>
  </book>

范例一和二提供的信息是完全相同的。

一般情况下，请使用元素，因为

1. 属性无法描述树结构（元素可以）
2. 属性不容易拓展（元素可以）

使用属性的情况：用于分配ID索引，用于标识XML元素。

实例

<bookstore>
  <book id = "501">
     <category>CHILDREN<category>
     <title lang="en"> Harry Potter </title>
     <author> JK.Rowling</author>
  </book>
  <book  id = "502">
     <category>CHILDREN<category>
     <title lang="en"> Harry Potter </title>
     <author> JK.Rowling</author>
  </book>
<bookstore>

上述属性（id）仅用于标识不同的便签，并不是数据的组成部分

• XML元素命名规则

1. 不能以数字或标点符号开头
2. 不能包含空格
3. 不能以xml开头

• CDATA
  不被解析器解析的文本数据，所有xml文档都会被解析器解析（cdata区段除外）
  <![CDATA["传输的文本 "]]>

• PCDATA
  被解析的字符数据

---

5. XML树结构

XML文档中的元素会形成一种树结构，从根部开始，然后拓展到每个树叶（节点）,下面将以实例说明XML的树结构。

• 假设一个XML文件如下

<？xml version ="1.0" encoding="UTF-8"?>
<简历>
     <基本资料>
     <求职意向>
     <自我评价>
     <其他信息>
     <联系方式>
     <我的作品>
 </简历>

• 其树结构如下

   

  

  树结构 .png

• XML节点解释
  XML文件是由节点构成的。它的第一个节点为“根节点”。一个XML文件必须有且只能有一个根节点，其他节点都必须是它的子节点。

   

  

   

  this 代表整个XML文件，它的根节点就是 this.firstChild 。 this.firstChild.childNodes 则返回由根节点的所有子节点组成的节点数组。

   

  

每个子节点又可以有自己的子节点。节点编号由0开始，根节点的第一个子节点为 this.firstChild.childNodes[0]，它的子节点数组就是this.firstChild.childNodes[0].childNodes 。

根节点第一个子节点的第二个子节点 this.firstChild.childNodes[0].childNodes[1]，它返回的是一个XML对象（Object） 。这里需要特别注意，节点标签之间的数据本身也视为一个节点 this.firstChild.childNodes[0].childNodes[1].firstChild ，而不是一个值。

我们解析XML的最终目的当然就是获得数据的值：this.firstChild.childNodes[0].childNodes[1].firstChild.nodeValue 。

请注意区分：节点名称（<性别></性别>）和之间的文本内容（男）可以当作是节点，也可以当作是一个值

节点：
名称：this.firstChild.childNodes[0].childNodes[1]
文本内容：this.firstChild.childNodes[0].childNodes[1].firstChild

值：
名称：this.firstChild.childNodes[0].childNodes[1].nodeValue
（节点名称有时也是我们需要的数据）
文本内容：this.firstChild.childNodes[0].childNodes[1].nodeName

在了解完XML之后，是时候来学下如何进行XML的解析了

---

6. 解析方式

• 解析XML，即从XML中提取有用的信息
• XML的解析方式主要分为2大类：

  

  示意图

6.1 DOM方式

• 简介
  Document Object Model，即 文件对象模型，是 一种 基于树形结构节点 & 文档驱动 的XML解析方法

定义了访问 & 操作xml文档元素的方法和接口

• 解析原理

示意图

• 具体解析实例

// 假设需要解析的XML文档如下（subject.xml）

<？xml version ="1.0" encoding="UTF-8"?>`
<code>
<language id="1">
    <name>Java</name>
    <usage>Android</usage>
 </language>
<language id="2">
    <name>Swift#</name>
    <usage>iOS</usage>
 </language>
<language id="3">
    <name>Html5</name>
   <usage>Web</usage>
 </language>
 </code>

// 解析的核心代码

public static List<subject> getSubjectList(InputStream stream)
   { tv = (TextView)findViewById(R.id.tv);
        try {
            //打开xml文件到输入流
            InputStream stream = getAssets().open("subject.xml");
            //得到 DocumentBuilderFactory 对象
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            //得到DocumentBuilder对象
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
            //建立Document存放整个xml的Document对象数据
            Document document = builder.parse(stream);
            //得到 XML数据的"根节点" 
            Element element = document.getDocumentElement();
            //获取根节点的所有language的节点
            NodeList list = element.getElementsByTagName("language");
             //遍历所有节点
            for (int i= 0;i<=list.getLength();i++){
            //获取lan的所有子元素
                Element language = (Element) list.item(i);
            //获取language的属性（这里即为id）并显示
                tv.append(lan.getAttribute("id")+"\n");
          //获取language的子元素 name 并显示                       tv.append(sub.getElementsByTagName("name").item(0).getTextContent()+"\n");
         //获取language的子元素usage 并显示                    tv.append(sub.getElementsByTagName("usage").item(0).getTextContent()+"\n");
            }

• 特点 & 应用场景

示意图

6.2 SAX 方式

• 简介
  即 Simple API for XML，一种 基于事件流驱动、通过接口方法解析 的XML解析方法

• 解析原理

   

  

  示意图

• 解析实例
  在使用SAX解析XML文档时，关键在于 自定义自己的Handler处理类 & 复写对应方法

public class MyHandler extends DefaultHandler{ 
    @Override 
    public void startDocument() throws SAXException{ 
    } 
 
    @Override 
    public void startElement(String uri,String localName,String qName, 
                     Attributes attributes) throws SAXException{ 
    } 
 
    @Override 
    public void characters(char[] ch,int start,int length) throws SAXException{ 
    } 
 
    @Override 
    public void endElement(String uri,String localName,String qName) 
              throws SAXException{ 
    } 
 
    @Override 
    public void endDocument() throws SAXException{ 
    } 
}

• 特点 & 应用场景

示意图

6.3 PULL解析

• 简介
  一种 基于事件流驱动 的XML解析方法

• 解析原理

示意图

• 解析模板代码

注：Android中自带了Pull解析的jar包，故不需额外导入第三方jar包

// Pull使用循环解析
XmlPullParserFactory factory = XmlPullParserFactory.newInstance(); 
XmlPullParser xmlPullParser = factory.newPullParser(); 
xml.setInput(new StringReader(xmlData)); 
 
int eventType = xmlPullParser.getEventType(); 
 
while(eventType!=XmlPullParser.END_DOCUMENT){ 
    String nodeName = xmlPullParser.getName(); 
    switch(eventType){ 
        case XmlPullParser.START_DOCUMENT:{} 
        case XmlPullParser.START_TAG:{} 
        case XmlPullParser.END_TAG:{}  
    }  
    eventType = parser.next(); 
}

• 解析实例

public class MainActivity extends Activity {
    private EditText et;
    private Button myButton;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
         myButton = (Button) this.findViewById(R.id.btn01);
        et = (EditText) this.findViewById(R.id.edittext01);
        myButton.setOnClickListener(new OnClickListener() {
        //可变字符序列，比StringBuffer块
            StringBuilder sb = new StringBuilder("");
            Resources res = getResources();
            XmlResourceParser xrp = res.getXml(R.xml.subject);
            @Override
            public void onClick(View v) {
                int counter = 0;
                try {

                    // 判断是否到了文件的结尾
                    while (xrp.getEventType() != XmlPullParser.END_DOCUMENT) {
                        //文件的内容的起始标签开始，这里的起始标签是subject.xml文件里面<subjects>标签下面的第一个标签
                        int eventType=xrp.getEventType();
                        switch (eventType) {
                            case XmlPullParser.START_DOCUMENT:
                                break;
                            case  XmlPullParser.START_TAG:
                                String tagname = xrp.getName();
                                if (tagname.endsWith("language")) {
                                    counter++;
                                    sb.append("这是第" + counter + "种语言"+"\n");
                                    //可以调用XmlPullParser的getAttributte()方法来获取属性的值
                                    sb.append("语言id是："+xrp.getAttributeValue(0)+"\n");
                                }
                                else if(tagname.equals("name")){
                                    //可以调用XmlPullParser的nextText()方法来获取节点的值
                                    sb.append("语言名称是："+xrp.nextText()+"\n");
                                }
                                else if(tagname.equals("teacher")){
                                    sb.append("用途是："+xrp.nextText()+"\n");
                                }
                                break;
                            case XmlPullParser.END_TAG:
                                break;
                            case XmlPullParser.TEXT:
                                break;
                        }
                        //解析下一个事件
                        xrp.next();
                    }
                    //StringBuilder要调用toString()方法并显示
                    et.setText(sb.toString());
                } catch (XmlPullParserException e) {

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

• 特点 & 应用场景

示意图

6.4 解析方式对比

示意图

---

7. 总结

• 本文全面介绍了现今主流的数据传输格式 XML，下面用一张图总结XML的主流解析方法

  

  示意图

1. 简介

示意图

---

2. 语法

• 1个JSON文件里含多个数据，这些数据 以 JSON值 的形式 存在

// JSON实例
｛"skill":{
          "web":[
                 {
                  "name":"html",
                  "year":"5"
                 },
                 {
                  "name":"ht",
                  "year":"4"
                 }],
           "database":[
                  {
                  "name":"h",
                  "year":"2"
                 }]
`}}

• 1个JSON值的内容形式可以是：”名称 - 值“对、数组 或 对象，下面将详细说明

示意图

---

3. 解析方式

• Android 解析 JSON数据的方式 类似 XML解析，主要分为2大类：

  

  示意图

• 下面，我将详细介绍每种方式

3.1 Android Studio自带org.json解析

• 解析原理：基于文档驱动

类似于XML的DOM解析方式

• 解析流程：把全部文件读入到内存中 ->> 遍历所有数据 ->> 根据需要检索想要的数据
• 具体使用

// 创建需解析的JSON数据：student.json
// 将该文件放入到本地assets文件夹里
{
"student":[
            {"id":1,"name":"小明","sex":"男","age":18,"height":175},
            {"id":2,"name":"小红","sex":"女","age":19,"height":165},
            {"id":3,"name":"小强","sex":"男","age":20,"height":185}
          ],
"cat":"it"
}

// 具体解析
import android.os.Bundle;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        EntityStudent student = new EntityStudent();


        try {
            //从assets获取json文件
            InputStreamReader isr = new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("assets/" + "student.json"));
            //字节流转字符流
           BufferedReader bfr = new BufferedReader(isr);
            String line ;
            StringBuilder stringBuilder = new StringBuilder();
            while ((line = bfr.readLine())!=null){
                stringBuilder.append(line);
            }//将JSON数据转化为字符串
            JSONObject root = new JSONObject(stringBuilder.toString());
            //根据键名获取键值信息
            System.out.println("root:"+root.getString("cat"));
            JSONArray array = root.getJSONArray("student");
            for (int i = 0;i < array.length();i++)
            {
                JSONObject stud = array.getJSONObject(i);
                System.out.println("------------------");
                System.out.print("id="+stud.getInt("id")+ ","));
                System.out.print("name="+stud.getString("name")+ ","));
                System.out.print("sex="+stud.getString("sex")+ ","));
                System.out.print("age="+stud.getInt("age")+ ","));
                System.out.println("height="+stud.getInt("height")+ ","));
                bfr.close();
                isr.close();
                is.close();//依次关闭流
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (JSONException e) {
            e.printStackTrace();
        }

    }
}

3.2 Gson解析

Google的开源库

• 解析原理：基于事件驱动
• 解析流程：根据所需取的数据 建立1个对应于JSON数据的JavaBean类，即可通过简单操作解析出所需数据
• 具体使用

步骤1：创建一个与JSON数据对应的JavaBean类（用作存储需要解析的数据）
Gson解析的关键 = 根据JSON数据 写出一个对应的JavaBean，规则是：

示意图

下面用2个例子说明 如何通过JSON文档创建JavaBean类

/** 
  * 简单转换
  */ 
        // JSON数据1
        String json = "{\"id\":1,\"name\":\"小明\",\"sex\":\"男\",\"age\":18,\"height\":175}";

        // 对应的JavaBean类
        public class EntityStudent {
        private int id;
        private String name;
        private String sex;
        private int age;
        private int height;

        public void setId(int id){
            this.id = id;
        }
        public void setName(String name){
            this.name = name;
        }
        public void setSex(String sex){
            this.sex = sex;
        }
        public void setAge(int age){
            this.age = age;
        }
        public void setHeight(int height){
            this.height = height;
        }
        public int getId(){
            return id;
        }
        public String getName(){
            return name;
        }
        public String getSex(){
            return sex;
        }
        public int getAge(){
            return age;
        }
        public int getHeight(){
            return  height;
        }
        public void show(){
                    System.out.print("id=" + id + ",");
                    System.out.print("name=" + name+",");
                    System.out.print("sex=" + sex+",");
                    System.out.print("age=" + age+",");
                    System.out.println("height=" + height + ",");

        }
        }

/** 
  * 复杂转换
  */ 
        // JSON数据2（具备嵌套）
        {"translation":["车"],
          "basic":
            {
              "phonetic":"kɑː",
              "explains":["n. 汽车；车厢","n. (Car)人名；(土)贾尔；(法、西)卡尔；(塞)察尔"]},
          "query":"car",
          "errorCode":0,
          "web":[{"value":["汽车","车子","小汽车"],"key":"Car"},
                 {"value":["概念车","概念车","概念汽车"],"key":"concept car"},
                 {"value":["碰碰车","碰撞用汽车","碰碰汽车"],"key":"bumper car"}]
        }

        // 对应的复杂的JSON数据对应的JavaBean类
        public class student {
            public String[] translation;    //["车"]数组
            public basic basic;             //basic对象里面嵌套着对象，创建一个basic内部类对象
            public  static class basic{     //建立内部类
                public String phonetic;
                public String[] explains;
            }
            public String query;
            public int errorCode;
            public List<wb> web;            //web是一个对象数组，创建一个web内部类对象
            public static class wb{         
                    public String[] value;
                    public String key;
                }

            public void show(){
                //输出数组
                for (int i = 0;i<translation.length;i++)
                {
                System.out.println(translation[i]);
                }
                //输出内部类对象
                System.out.println(basic.phonetic);
                //输出内部类数组
                for (int i = 0;i<basic.explains.length;i++){
                    System.out.println(basic.explains[i]);
                }
                System.out.println(query);
                System.out.println(errorCode);
                for (int i = 0;i<web.size();i++){
                    for(int j = 0; j<web.get(i).value.length;j++)
                    {
                        System.out.println(web.get(i).value[j]);
                    }
                    System.out.println(web.get(i).key);
                }
            }
            }

若觉得转换过于复杂，请直接使用工具：JSON字符串 转 Java实体类

步骤2：导入GSON库
在Android Gradle导入依赖

dependencies {
  compile 'com.google.code.gson:gson:2.3.1'
}

步骤3：使用Gson进行解析

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 1. 创建Gson对象
        Gson gson = new Gson();

        // 2. 创建JavaBean类的对象
        Student student = new EntityStudent();

        // 3. 使用Gson解析：将JSON数据转为单个类实体
        String json = "{\"id\":1,\"name\":\"小明\",\"sex\":\"男\",\"age\":18,\"height\":175}";
        student = gson.fromJson(json,Student.class);
        // 解析：JavaBean对象 = gson.fromJson(son,javaBean类类名.class);

        // 4. 调用student方法展示解析的数据
        student.show();
        
        // 5. 将Java集合转换为json
        String json2 = gson.toJson(List);        
        System.out.println(json2);
    }
}

3.3 Jackson解析

• 解析原理：基于事件驱动
• 解析过程：
  1. 类似 GSON，先创建1个对应于JSON数据的JavaBean类，再通过简单操作即可解析
  2. 与 Gson解析不同的是：GSON可按需解析，即创建的JavaBean类不一定完全涵盖所要解析的JSON数据，按需创建属性；但Jackson解析对应的JavaBean必须把Json数据里面的所有key都有所对应，即必须把JSON内的数据所有解析出来，无法按需解析

但Jackson的解析速度、效率都 高于 GSON

• 具体使用

步骤1：建立Json数据对应的javaBean（规则同GSON）

// 创建需解析的JSON数据：student.json
// 将该文件放入到本地assets文件夹里
{"student":
          [
           {"id":1,"name":"小明","sex":"男","age":18,"height":175,"date":[2013,8,11]},
           {"id":2,"name":"小红","sex":"女","age":19,"height":165,"date":[2013,8,23]},
           {"id":3,"name":"小强","sex":"男","age":20,"height":185,"date":[2013,9,1]}
          ],
  "grade":"2"
}

// JavaBean类
class test {
    private  List<stu> student = new ArrayList<stu>();

    private  int grade;

    public void setStudent(List<stu> student){
        this.student = student;
    }
    public List<stu> getStudent(){
        return student;
    }
    public void setGrade(int grade){
        this.grade = grade;
    }
    public int getGrade(){
        return grade;
    }
    private static class stu {
        private  int id;
        private  String name;
        private  String sex;
        private  int age;
        private  int height;
        private  int[] date;

        public void setId(int id){
            this.id = id;
        }
        public int getId(){
            return id;
        }
        public void setName(String name){
            this.name = name;
        }
        public String getName(){
            return  name;
        }
        public void setSex(String sex){
            this.sex = sex;
        }
        public String getSex(){
            return sex;
        }
        public void  setAge(int age){
            this.age = age;
        }
        public int getAge(){
            return age;
        }
        public void setHeight(int height){
            this.height = height;
        }
        public int getHeight(){
            return height;
        }
        public void setDate(int[] date){
            this.date = date;
        }
        public int[] getDate(){
            return date;
        }
    }

    public String tostring(){
        String str = "";
        for (int i = 0;i<student.size();i++){
            str += student.get(i).getId() + " " + student.get(i).getName() + " " + student.get(i).getSex() + " " + student.get(i).getAge() + " " + student.get(i).getHeight() ;
            for (int j = 0;j<student.get(i).getDate().length;j++) {
                str += student.get(i).getDate()[j]+ " " ;
            }
            str += "\n";
        }
        str += "\n"+getGrade();
        return str;
    }
}

步骤2：利用Jackson方法进行解析

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 1. //从assets获取json文件
            InputStreamReader isr = new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("assets/" + "student.json"),"utf-8");
            BufferedReader bfr = new BufferedReader(isr);
            String line;
            StringBuilder stringBuilder = new StringBuilder();
            while ((line = bfr.readLine())!=null){
                stringBuilder.append(line);
            }
            // 2. 将JSON数据转化为字符串
            System.out.println(stringBuilder.toString());
            System.out.println(tes.tostring());

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

---

4. 解析方式对比

示意图

---

5. 与XML解析对比

• 对于 同样作为主流的数据交换格式XML来说，二者对比如下：

  

  示意图

• 总的来说，相比于 XML，JSON大小更小、解析方法更简单、解析速度更快。所以，JSON一定是你在数据交换格式选型中的首选

作者：Carson_Ho
链接：https://www.jianshu.com/p/b87fee2f7a23
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。