JSON介绍及Android最全面解析方法(Gson、AS自带org.son、Jackson解析)

前言

今天，我们来介绍一下现今主流的数据交换格式-JSON！

同样作为主流为数据交换格式-XML，如果有兴趣可以阅读我写的XML及其DOM、SAX、PULL解析方法和对比

目录

定义

JavaScript Object Notation，JavaScript的对象表示法，是一种轻量级的文本数据交换格式。

作用

用于数据的标记、存储和传输。

特点

• 轻量级的文本数据交换格式
• 独立于语言和平台
• 具有自我描述性
• 读写速度快，解析简单

语法

JSON值 
- 名称/值 
- 数组 
- 对象

JSON实例

｛"skill":{          "web":[                 {                  "name":"html",                  "year":"5"                 },                 {                  "name":"ht",                  "year":"4"                 }],           "database":[                  {                  "name":"h",                  "year":"2"                 }]`}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• “名称／值”对 
  无序、一个对象用“｛｝”包括，名称和值间用“：”相隔，对象间用“，”隔开； 
  “` 
  “name”:”html”

- 对象一个JSON对象包括多个名称/值对，在花括号里书写
1
2
1
2

{ “name”:”html”,”year”:”5”}

- 数组数组以“［］”包括，数据的对象用逗号隔开``` "web":[                 {                  "name":"html",                  "year":"5"                 },                 {                  "name":"ht",                  "year":"4"                 }]<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

web和database都是一个数组

语法总结

数组 [ 对象 { 值/对”” } ]

数组包含对象，对象包含值/对

JSON解析

在了解了JSON后，是时候来看下如何在Android解析JSON数据

解析方法

Android解析JSON数据的方法和XML解析类似，主要有两种： 
基于事件驱动和基于文档驱动解析方式

基于事件驱动

• 主流方式：Gson解析和Jackson解析

Gson介绍 
- 简介：使用谷歌的开源库进行解析 
- 解析方式：基于事件驱动，根据所需要取的数据通过建立一个对应于JSON数据的JavaBean类就可以通过简单的操作解析出所需JSON数据

Gson解析

步骤1：创建一个与JSON数据对应的JavaBean类（用作存储需要解析的数据） 
GSON解析的关键是重点是要根据json数据里面的结构写出一个对应的javaBean，规则是： 
1. JSON的大括号对应一个对象，对象里面有key和value(值)。在JavaBean里面的类属性要和key同名。 
2. JSON的方括号对应一个数组，所以在JavaBeanBean里面对应的也是数组，数据里面可以有值或者对象。 
3. 如果数组里面只有值没有key，就说明它只是一个纯数组，如果里面有值有key，则说明是对象数组。纯数组对应JavaBean里面的数组类型，对象数组要在Bean里面建立一个内部类，类属性就是对应的对象里面的key，建立了之后要创建一个这个内部类的对象，名字对应数组名。 
4. 对象里面嵌套对象时候，也要建立一个内部类，和对象数组一样，这个内部类对象的名字就是父对象的key

注：JavaBean类里的属性不一定要全部和JSON数据里的所有key相同，可以按需取数据，也就是你想要哪种数据，就把对应的key属性写出来，注意名字一定要对应

以下有两个JSON文档来说明创建JavaBean类的创建方法

简单的JSON数据1（对象）

String json = "{\"id\":1,\"name\":\"小明\",\"sex\":\"男\",\"age\":18,\"height\":175}";<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
1
2
3
4
5
6
7

步骤1：创建简单的JSON数据对应的JavaBean类

package scut.learngson;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 + ",");    }}<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

复杂的JSON数据（具备嵌套）

{"translation":["车"],  "basic":    {      "phonetic":"kɑː",      "explains":["n. 汽车；车厢","n. (Car)人名；(土)贾尔；(法、西)卡尔；(塞)察尔"]},  "query":"car",  "errorCode":0,  "web":[{"value":["汽车","车子","小汽车"],"key":"Car"},         {"value":["概念车","概念车","概念汽车"],"key":"concept car"},         {"value":["碰碰车","碰撞用汽车","碰碰汽车"],"key":"bumper car"}]}<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

步骤1：复杂的JSON数据对应的JavaBean类

package scut.httpgson;import java.util.List;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);        }    }    }<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

好了，是不是觉得根据JSON文本数据去转换成JavaBean实体类很复杂呢？其实还有个简单的方法，请使用在线JSON字符串转Java实体类，哈哈请不要打我，继续往下看吧！

步骤2：下载并导入GSON需要的库

别翻墙去谷歌官网下了，点这吧

步骤3：用Gson进行转换

package scut.learngson;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import com.google.gson.Gson;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);        Gson gson = new Gson();        //创建JavaBean类的对象      Student student = new EntityStudent();        String json = "{\"id\":1,\"name\":\"小明\",\"sex\":\"男\",\"age\":18,\"height\":175}";       //用GSON方法将JSON数据转为单个类实体        student = gson.fromJson(json,Student.class);       //调用student方法展示解析的数据        student.show();      //将Java集合转换为json        String json2 = gson.toJson(List);        System.out.println(json2);    }}<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

总结

可以看到，利用GSON方法进行解析，关键在于根据json数据里面的结构写出一个对应的javaBean，而解析过程非常简单：

JavaBean对象 = gson.fromJson(son,javaBean类类名.class);<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
1
2
3
4
5
6
7

Jackson解析 
- 解析原理：基于事件驱动，与GSON相同，先创建一个对应于JSON数据的JavaBean类就可以通过简单的操作解析出所需JSON数据。但和Gson解析不同的是，GSON可按需解析，即创建的JavaBean类不一定完全涵盖所要解析的JSON数据，按需创建属性，但Jackson解析对应的JavaBean必须把Json数据里面的所有key都有所对应，即必须把JSON内的数据所有解析出来，无法按需解析。但Jackson的解析速度和效率都要比GSON高

• 核心代码

JSON数据

{"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"}<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

步骤1：建立对应的javaBean：

建立javaBean的对应规则和GSON一样

package scut.learnjackson;import java.util.ArrayList;import java.util.List;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;    }}<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

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

package scut.learnjackson;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import org.codehaus.jackson.map.ObjectMapper;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class MainActivity extends AppCompatActivity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        ObjectMapper objectMapper = new ObjectMapper();        try {            InputStreamReader isr = new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("assets/" + "student.json"),"utf-8");            //从assets获取json文件            BufferedReader bfr = new BufferedReader(isr);            String line;            StringBuilder stringBuilder = new StringBuilder();            while ((line = bfr.readLine())!=null){                stringBuilder.append(line);            }//将JSON数据转化为字符串            System.out.println(stringBuilder.toString());            System.out.println(tes.tostring());        } catch (IOException e) {            e.printStackTrace();        }    }}<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

基于文档驱动解析方式

• 主流方式：Android Studio自带org.json解析
• 解析方式：基于文档驱动，类似于XML的DOM解析方法，先把全部文件读入到内存中，然后遍历所有数据，然后根据需要检索想要的数据。

需要解析的JSON数据：

{"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"}<div class="se-preview-section-delimiter"></div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

读入本地assets文件夹里面的student.son并解析

package scut.learngson;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();        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

GSON、Jackson、Android Studio自带org.json解析三类方式对比

Android Studio自带org.json 
- 原理：基于文档驱动 
- 特点： 
优点：无 
缺点：解析 XML 文件时会将整个 XML 文件的内容解析成树型结构存放在内存中并创建新对象，比较消耗时间和内存,解析速度和效率慢，解析方式和性能完败GSON

GSON方式 
- 原理：基于事件驱动 
- 特点： 
优点：解析方法简单、解析效率高、占存少、灵活性高 
- 使用情境 
适用于需要处理大型 JSON文档、JSON文档结构复杂的场合

Jackson方式 
- 原理：基于事件驱动 
- 特点： 
优点：解析效率最高、在数据量大的情况优势尤为明显、占存少 
缺点：必须完全解析文档，如果要按需解析的话可以拆分Json来读取，操作和解析方法复杂； 
- 使用情境 
适用于需要处理超大型JSON文档、不需要对JSON文档进行按需解析、、性能要求较高的场合

---

与XML解析对比

对于同样作为主流的数据交换格式来说，JSON相比于XML，JSON文档大小更加小，解析方法更加简单、读写速度更快，所以JSON一定是你在数据交换格式的选型中的首选。