json

一、JSON基本认识

JSON是一种轻量级的数据交换格式，它的全称为“JavaScript Object Notation”，当下的服务器与客户端数据交换几乎都是用JSON了，必会JSON解析。

二、JSON的特点

1、JSON比XML的数据传递的有效性高,轻量级的文本数据交换格式

2、JSON完全独立于编程语言和平台

3、JSON的本质是具有特定格式的字符串,具有自我描述性

4、易于人阅读和编写，同时也易于机器解析和生成

三、JSON数据格式（JSON对象、JSON数组）

【详细语法参考】http://www.json.org/json-zh.html

3.1、JSON对象：{ }

结构：{key1:value1,key2:value2,key3:value3}

“key/value”键值对：无序、一个对象用“｛｝”包括，名称和值间用“：”相隔，对象间用“，”隔开； 

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

key的数据类型：字符串

value的数据类型：字符串、数值、null、JSON对象、JSON数组

例子：

{
    " name ": "xiaoming ",
    " blogUrl ": " www.xiaoming.org "
}

以key/value键值对形式构建的，正确

{  " name " : " "xiaoming ", "www.xiaoming.org "  }没有以key/value键值对形式构建的，错误

3.2、JSON数组：[ ]

结构：[value1,value2,value3]

数组以“［］”包括，数据的对象用逗号隔开

value的数据类型：字符串、数值、null、JSON对象、JSON数组

例子：

[  " 1 ", 
   " cnblogs ", 
     {
    " name ": " xiaoming ",
    " blogUrl ": " www.xiaoming.org "
    }
]

3.3 总结

数组 [ 对象 { 值/对} ]

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

3.4 json实例

{
    "skill": {
        "web": [{
                "name": "html",
                "year": "5"
            },
            {
                "name": "ht",
                "year": "4"
            }
        ],
        "database": [{
            "name": "h",
            "year": "2"
        }]
    }
}

【说明】

【1】最外层的对象：遵循键值对：键key---“skill”；值value是"："之后的大括号中的内容{"web".....}

【2】包含两个数组：”web","database"；

四、JSON解析方向

1、将Java对象（包括集合）转换成JSON格式字符串；（服务端）

2、将JSON格式字符串转换成Java对象（包括集合）。（客户端）

3、JSON和Java之间的转换关系：

      JSON中的对象对应着Java中的对象；

      JSON中的数组对应这Java中的集合。

6. JavaBean的书写

6.1 json 对应的javabean的书写规则

步骤1：创建一个与JSON数据对应的JavaBean类（用作存储需要解析的数据） 
JSON解析的关键是重点是要根据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类的创建方法

6.2 简单的javaBean的书写

简单的JSON数据1（对象）

{
    "id": 1,
    "name": "小明",
    "sex": "男",
    "age": 18,
    "height": 175
}

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

 1 package scut.learngson;
 2 
 3 public class EntityStudent {
 4     private int id;
 5     private String name;
 6     private String sex;
 7     private int age;
 8     private int height;
 9 
10     public void setId(int id){
11         this.id = id;
12     }
13     public void setName(String name){
14         this.name = name;
15     }
16     public void setSex(String sex){
17         this.sex = sex;
18     }
19     public void setAge(int age){
20         this.age = age;
21     }
22     public void setHeight(int height){
23         this.height = height;
24     }
25     public int getId(){
26         return id;
27     }
28     public String getName(){
29         return name;
30     }
31     public String getSex(){
32         return sex;
33     }
34     public int getAge(){
35         return age;
36     }
37     public int getHeight(){
38         return  height;
39     }
40     public void show(){
41                 System.out.print("id=" + id + ",");
42                 System.out.print("name=" + name+",");
43                 System.out.print("sex=" + sex+",");
44                 System.out.print("age=" + age+",");
45                 System.out.println("height=" + height + ",");
46 
47     }
48 }

6.3. 复杂的javaBean的书写

复杂的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"
        }
    ]
}

 

复杂的JSON数据对应的JavaBean类

 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);
         }
     }
   }

7.JSON解析技术

7.1 FastJson框架技术

特点：Fastjson是用Java语言编写的高性能功能完善的JSON库。它采用了一种“假定有序、快速匹配”的算法，

把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库。

1.FastJson数度快,无论序列化和反序列化,都是当之无愧的fast 
2.功能强大(支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum) 
3.零依赖(没有依赖其它任何类库)

Github地址：https://github.com/alibaba/fastjson

fastjson的API十分简洁

String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化

Fastjson API入口类是com.alibaba.fastjson.JSON，常用的序列化操作都可以在JSON类上的静态方法直接完成。

 public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray 
*public static final JSONObject parseObject(String text)； // 把JSON文本parse成JSONObject    
*public static final  T parseObject(String text, Class clazz); // 把JSON文本parse为JavaBean 
*public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray 
*public static final  List parseArray(String text, Class clazz); //把JSON文本parse成JavaBean集合 
*public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本 
 public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本 
10  public static final Object toJSON(Object javaObject); //将JavaBean转换为JSONObject或者JSONArray。
 
以上加*的是一些项目中的常用方法。

 

FastJson的简单说明:
FastJson对于json格式字符串的解析主要用到了下面三个类： 
1.JSON：fastJson的解析器，用于JSON格式字符串与JSON对象及javaBean之间的转换 
2.JSONObject：fastJson提供的json对象 
3.JSONArray：fastJson提供json数组对象

【步骤1】添加依赖

compile 'com.alibaba:fastjson:1.2.47'
compile 'com.alibaba:fastjson:1.1.68.android'

 

【解析StringJson】

{
    "studentName": "lily",
    "studentAge": 12
}

 

 

 

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类的创建方法

 

步骤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);
        }
    }
    }

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

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

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

步骤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);
    }
}

总结

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

JavaBean对象 = gson.fromJson(son,javaBean类类名.class);

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

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

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

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