JSON的学习与使用

adonislu

2020-01-18

公众号：小李不秃，Java 原创博主
阅读本文大概需要 7.8 分钟

前言

我们在进行软件开发的过程中，服务与服务之间会进行相互的调用。在数据进行传输前，我们通常会将数据转化成 JSON 的格式进行传输，比如 ajax 调用请求，接收传过来的 JSON 数据，javascript 就可以对传过来的数据进行直接的调用。

本篇文章会讲解以下的内容：

什么是 JSON---what
为什么有 JSON---why
如何使用 JSON---How
- JSON 的数据结构
- Json 在 javascript 中的使用
- Json 在 Java 中的使用

什么是 JSON

JSON 全拼 Java Script Object Notation，JavaScript 对象表示法。是一种由道格拉斯·克罗克福特构想和设计、轻量级的数据交换语言，该语言以易于让人阅读的文字为基础，用来传输由属性值或者序列性的值组成的数据对象。尽管 JSON 是 JavaScript 的子集，但是 JSON 是独立于语言的文本格式。

JSON 数据格式与语言无关。即便它源自 JavaScript，但很多编程语言都支持 JSON 格式数据的生成和解析，例如在 Java 中就有 fastjson、gson 等工具类对 JSON 进行操作。

小结：

JSON 是数据交换语言。
JSON 是独立于任何程序语言的文本格式。

为什么有 JSON

提到这里，就不得不和 XML 进行比较了。XML 也是可以作为跨平台的数据交换格式。但是为什么我们大多用 JSON，而不用 XML 呢？有下面几点原因：

javaScript 原生支持 JSON，解析速度更快。而 XML 解析成 DOM 对象的时候，浏览器会有差异。
对于 AJAX 应用程序来说，JSON 比 XML 更快更易使用。
使用 XML ：读取 XML 文档，使用 XML DOM 循环遍历文档，将读取值存入变量。
使用 JSON：读取 JSON 字符串，JSON.parse 解析 JSON 字符串。

综上，我们更倾向于选择 JSON 来进行数据交换。

如何使用 JSON

JSON 的数据结构

对象

JSON 对象使用在大括号“{}”中书写，对象可以有多个键值对（key/value）。

key 必须是字符串，value 可以是合法的 JSON 数据类型（字符串、数字、对象、数组、布尔值或null）

key 和 value 中使用冒号“:”分割，键值对之间用逗号“,”分割。

{"name":"关注公众号：小李不秃","age":18,"money":null}

数组

JSON 数组在中括号“[]”中书写。JSON 中数组值必须是合法的 JSON 数据类型。

[        {"name":"张三"},    {"name":"李四"),    {"name":"王五"}]

Json 在 javaScript 中的使用

操作 Json 对象

访问对象值

可以使用点号“.”来访问对象的值，也可以使用中括号“[]”来访问对象的值。

var data, x;data = {"name":"xiaoli", "area":"china", "money":null};x = data.name; #或者myObj["name"]运行结果:xiaoli

循环对象

使用 for-in 来循环对象的属性

var data, x;data = {"name":"xiaoli", "area":"china", "money":null};for(x in data){    console.log(x + ":" + data[x]);}运行结果：name:xiaoliarea:china money:null

修改值

可以使用点号“.”来修改 JSON 对象的值，也可以使用中括号“[]”修改 JSON 对象的值。

data.money = 100;data["money"] = 100;

删除值

通过 delete 关键字来删除 JSON 对象的属性。

delete data.money;delete data["money"]

操作 JSON 数组

访问 JSON 数组值

通过索引值来访问数组。

var myObj, x;myObj = {    "name":"网站",    "num":3,    "sites":[ "Google", "Runoob", "Taobao" ]}x = myObj.sites[0];运行结果：Google

循环数组

通过 for-in 来访问数组。

var myObj, i, x = "";myObj = {    "name":"网站",    "num":3,    "sites":[ "Google", "Runoob", "Taobao" ]};for (i in myObj.sites) {    x += myObj.sites[i] + "<br>";}运行结果：GoogleRunoobTaobao

也可以通过 for 来循环访问数组。

var myObj, i, x = "";myObj = {    "name":"网站",    "num":3,    "sites":[ "Google", "Runoob", "Taobao" ]};for (i = 0; i < myObj.sites.length; i++) {    x += myObj.sites[i] + "<br>";}

javaScript 中的 for-in 类似于 Java 中的 foreach 。

修改数组元素

可以通过索引值来修改数组元素。

myObj.sites[1] = "Github";

删除数组元素

使用 delete 来删除数组元素

delete myObj.sites[1];

这里需要注意 delete 并没有彻底删除元素，而是删除它的值，仍然会保留空间。运算符 delete 只是将该值设置为 undefined，而不会影响数组的长度。如果想要实现彻底删除，需要使用 splice() 方法。

var myObj, i, x = "";myObj = {    "name":"网站",    "num":3,    "sites":[ "Google", "Runoob", "Taobao" ]};delete myObj.sites[1];x = "sites.length = " + myObj.sites.length + "<br><br>";for (i=0;i<myObj.sites.length;i++) {    console.log(i + ":" + myObj.sites[i]);    x += i + " " + myObj.sites[i] + "<br>";}document.getElementById("demo").innerHTML = x;运行结果：0:Google1:undefined2:Taobao

myObj.sites.splice(1,1);运行结果：0:Google1:Taobao

JSON.parse()

JSON 通常与服务端交换数据，接收服务器传输的数据时一般是字符串，我们可以通过 JSON.parse() 方法将数据转换为 JavaScipt 对象。

具体使用

var obj = JSON.parse(‘{"name":"关注公众号：小李不秃","age":18,"money":null}‘);console.log(obj.name + ":" + obj.age + ":" + obj.money)运行结果：关注公众号：小李不秃：18：null

JSON 存 Date 对象，需要将其转换为字符串，之后再将字符串转换为 Date 对象。

var text = ‘{ "name":"小李不秃", "initDate":"2020-1-17"}‘;var obj = JSON.parse(text, function (key, value) {    if (key == "initDate") {        return new Date(value);    } else {        return value;}});console.log(obj.name + ":" + obj.initDate);运行结果：小李不秃:Fri Jan 17 2020 00:00:00 GMT+0800 (中国标准时间)

JSON.stringify()

JSON 在向服务端传输的数据一般是字符串，所以我们可以使用 JSON.stringify() 方法将 JavaScript 对象转换为字符串。

具体使用

var obj = {"name":"xiaoli", "area":"china", "money":null};console.log(obj);var myJSON = JSON.stringify(obj);console.log(myJSON);

运行结果

eval

对于服务器返回的 JSON 字符串，如果 jQuery 异步请求没做类型说明，或者以字符串方式接收，那么需要做一次对象化处理，方式不是太麻烦，就是将该字符串放于 eval() 中执行一次。这种方式也适合以普通 javascipt 方式获取 json 对象，以下举例说明：

var u = eval(‘(‘+user+‘)‘);

为什么要 eval 这里要添加 (‘(‘+user+‘)‘) 呢？

原因在于：eval 本身的问题。由于 json 是以 {} 的方式来开始以及结束的，在 js 中，它会被当成一个语句块来处理，所以必须强制性的将它转换成一种表达式。

加上圆括号的目的是迫使 eval 函数在处理 JavaScript 代码的时候强制将括号内的表达式（expression）转化为对象，而不是作为语句（statement）来执行。举一个例子，例如对象字面量 {}，如若不加外层的括号，那么 eval 会将大括号识别为 javascript 代码块的开始和结束标记，那么{}将会被认为是执行了一句空语句。所以下面两个执行结果是不同的：

alert(eval("{}"); // return undefinedalert(eval("({})");// return object[Object]

测试用例

var user = ‘{"name":"关注公众号：小李不秃","age":18,"money":null,‘+      ‘showInfo:function(){‘+      ‘document.write("姓名："+this.name+"<br/>");‘+      ‘document.write("年龄："+this.age+"<br/>");‘+      ‘document.write("金钱："+this.money+"<br/>");}}‘; var u = eval(‘(‘+user+‘)‘);  u.showInfo();运行结果：姓名：关注公众号：小李不秃年龄：18金钱：null

Json 在 Java 中的使用

在 Java 中，解析 JSON 的第三方工具类有很多，常用的有几种：

Json-lib
Gson
Jackson
fastjson

统一用下面的 Person 类作为示例

@Datapublic class Person {    private String name;    private Integer age;    public Person() {    }    public Person(String name, Integer age) {        this.name = name;        this.age = age;    }}

那我们对这几个工具类进行一一介绍：

Json-lib

Json-lib 是一个 Java 类库，提供将 Java 对象（包括：beans，maps，collections，java arrays 和 XML等）和 JSON 互相转换的功能。

引入相关 jar 包

commons-io-2.0.1.jar
commons-lang-2.5.jar
commons-collections-3.1.jar
commons-beanutils-1.7.0.jar
ezmorph-1.0.3.jar
json-lib-2.1-jdk15.jar

Json-lib 工具类

封装一个 Json-lib 工具类，方便测试用。

// Json-lib 工具类public class JsonLibUtils {    /**     * bean 转换为 Json 字符串     */    public static String bean2json(Object o){        JSONObject jsonObject = JSONObject.fromObject(o);        return jsonObject.toString();    }    /**     * json 转换为 bean     */    public static Object json2bean(String s,Class c){        JSONObject jsonObject = JSONObject.fromObject(s);        return JSONObject.toBean(jsonObject,c);    }    /**     * list 转换为 Json 字符串     */    public static String list2json(List list){        JSONArray jsonArray = JSONArray.fromObject(list);        return jsonArray.toString();    }    /**     * json 转换为 list     */    public static List json2List(String s){        return JSONArray.fromObject(s);    }    /**     * set 转换为 Json 字符串     */    public static String set2json(Set set){        JSONArray jsonArray = JSONArray.fromObject(set);        return jsonArray.toString();    }    /**     * json 转换为 set     */    public static Set json2Set(String json) {        Set<Person> set = new HashSet<>(json2List(json));        return set;    }    /**     * map 转换为 Json 字符串     */    public static String map2json(Map map){        JSONObject jsonObject = JSONObject.fromObject(map);        return jsonObject.toString();    }    /**     * json 转换为 map     */    public static Map<Object, Object> json2Map(String json) {        JSONObject jsonObject = JSONObject.fromObject(json);        Map<Object, Object> map = (Map)jsonObject;        return map;    }}

示例代码：

public class JsonlibTest {    public static void main(String[] args) {        //1. bean 和 json 互转        Person person = new Person("xiaoli",18);        String json = JsonLibUtils.bean2json(person);        // {"age":18,"name":"xiaoli"}        Person person2 = (Person)JsonLibUtils.json2bean(json, Person.class);        //2. list 和 json 互转        List<Person> list = new ArrayList<Person>();        list.add(new Person("李四",10));        list.add(new Person("王五",20));        String listJson = JsonLibUtils.list2json(list);        // [{"age":10,"name":"李四"},{"age":20,"name":"王五"}]        List json2List = JsonLibUtils.json2List(listJson);        //3. map 转 json        Map<String,Person> map = new HashMap<String,Person>();        map.put("map1",new Person("李四",10));        map.put("map2",new Person("王五",20));        String mapJson = JsonLibUtils.map2json(map);        // {"map2":{"age":20,"name":"王五"},"map1":{"age":10,"name":"李四"}}        Map<Object, Object> map2 = JsonLibUtils.json2Map(mapJson);        //4. set 与 json 互转        Set<Person> set = new LinkedHashSet<Person>();        set.add(new Person("李四",10));        set.add(new Person("王五",20));        String setJson = JsonLibUtils.set2json(set);        // [{"age":10,"name":"李四"},{"age":20,"name":"王五"}]        JsonLibUtils.json2Set(setJson);    }}

缺点

依赖的包过多。
复杂类型的转换有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。
不推荐使用 Json-lib 的 n 个理由

小结

json-lib 提供两个对象，分别是 JSONObject 和 JSONArray，分别对应着 JSON 的两个数据结构。根据需要选取转换的对象。但是由于 json-lib 已经 n 多年没有维护，缺陷较多，在功能和性能方面已经无法满足我们的需求，所以尽量还是不用为好。

Gson

Gson 是 Google 公司发布的一个开源代码的 Java 库，主要用途为序列化 Java 对象为 JSON 字符串，或反序列化 JSON 字符串为 Java 对象。

Gson 提供了 fromJson()和 toJson() 两个用于解析和生成的方法，前者实现反序列化，后者实现了序列化。

依赖

使用 Gson 需要引入这个依赖。

<dependency>    <groupId>com.google.code.gson</groupId>    <artifactId>gson</artifactId>    <version>2.8.6</version>    <scope>compile</scope></dependency>

Gson 工具类

封装一些常用方法的转换工具类。

public class GsonUtil {    /**     * bean 转换为 Json 字符串     */    public static String bean2json(Object object){        Gson gson = new Gson();        return gson.toJson(object);    }    /**     * json 转换为 bean     */    public static Object json2bean(String json,Class c){        Gson gson = new Gson();        return gson.fromJson(json,c);    }    /**     * list 转换为 Json 字符串     */    public static String list2json(List list){        Gson gson = new Gson();        return gson.toJson(list);    }    /**     * json 转换为 list     */    public static List json2List(String json){        Gson gson = new Gson();        return gson.fromJson(json,new TypeToken<List>(){}.getType());    }    /**     * set 转换为 Json 字符串     */    public static String set2json(Set set){        Gson gson = new Gson();        return  gson.toJson(set);    }    /**     * json 转换为 set     */    public static Set json2Set(String json){        Gson gson = new Gson();        return gson.fromJson(json,new TypeToken<Set>(){}.getType());    }    /**     * map 转换为 Json 字符串     */    public static String map2json(Map map){        Gson gson = new Gson();        return  gson.toJson(map);    }    /**     * json 转换为 map     */    public static Map json2Map(String json){        Gson gson = new Gson();        return gson.fromJson(json,new TypeToken<Map>(){}.getType());    }}

示例代码

public static void main(String[] args) {    //1. bean 和 json 互转    Person person = new Person("xiaoli",18);    String json = GsonUtil.bean2json(person);    System.out.println(json);    Person person2 = (Person)GsonUtil.json2bean(json, Person.class);    System.out.println(person2.toString());    //2. list 和 json 互转    List<Person> list = new ArrayList<Person>();    list.add(new Person("李四",10));    list.add(new Person("王五",20));    String listJson = GsonUtil.list2json(list);    System.out.println(listJson);    List json2List = GsonUtil.json2List(listJson);    System.out.println(json2List.toString());    //3. map 转 json    Map<String,Person> map = new HashMap<String,Person>();    map.put("map1",new Person("李四",10));    map.put("map2",new Person("王五",20));    String mapJson = GsonUtil.map2json(map);    System.out.println(mapJson);    Map<Object, Object> map2 = GsonUtil.json2Map(mapJson);    System.out.println(map2.toString());    //4. set 与 json 互转    Set<Person> set = new LinkedHashSet<Person>();    set.add(new Person("李四",10));    set.add(new Person("王五",20));    String setJson = GsonUtil.set2json(set);    System.out.println(setJson);    Set set1 = GsonUtil.json2Set(setJson);    System.out.println(set1.toString());}运行结果：{"name":"xiaoli","age":18}Person(name=xiaoli, age=18)[{"name":"李四","age":10},{"name":"王五","age":20}][{name=李四, age=10.0}, {name=王五, age=20.0}]{"map2":{"name":"王五","age":20},"map1":{"name":"李四","age":10}}{map2={name=王五, age=20.0}, map1={name=李四, age=10.0}}[{"name":"李四","age":10},{"name":"王五","age":20}][{name=李四, age=10.0}, {name=王五, age=20.0}]

小结

Gson 是 Google 开发的，所以也是经过了很多的验证。但是将字符串解析为指定的集合类型需要花点信息，因为涉及到了泛型—TypeToken 。

具体的 Gson 文章详见：Gson使用指南

Jackson

Github 地址：jackson

简单介绍一下 Jackson：

Jackson 是基于 Stream 构建的一款用户序列化和反序列化 JSON 的 Java 开源库。
社区活跃，更新速度快。
Spring MVC 的默认 JSON 解析器。
擅长处理各种大量数据格式模块。

Jackson 的核心模块由三部分组成。

jackson-core，核心包，提供基于「流模式」解析的相关 API，它包括 JsonPaser 和 JsonGenerator。
jackson-annotations，注解包，提供标准注解功能。
jack-databind，数据绑定包，提供基于「对象绑定」解析的相关 API （ ObjectMapper ）和「树模型」解析的相关 API （JsonNode）；基于「对象绑定」解析的 API 和「树模型」解析的 API 依赖基于「流模式」解析的 API。

ObjectMapper 通过 writeValue()的系列方法可以将 Java 对象序列化为 JSON，并将 JSON 存储成不同的格式。

String （writeValueAsString）
Byte Array （writeValueAsBytes）

ObjectMapper 通过 readValue() 系列方法可以从不同的数据源（String、Bytes）将 JSON 反序列化为 Java 对象。

依赖

使用 Jackson 之前，需要先添加依赖。

<dependency>    <groupId>com.fasterxml.jackson.core</groupId>    <artifactId>jackson-databind</artifactId>    <version>2.9.1</version></dependency>

Jackson 工具类

public class JacksonUtil {    private static ObjectMapper mapper = null;    /**     * bean 转换为 Json 字符串     */    public static String bean2json(Object object){        mapper = new ObjectMapper();        try {            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        return null;    }    /**     * json 转换为 bean     */    public static Object json2bean(String json,Class c){        mapper = new ObjectMapper();        try {            return mapper.readValue(json,c);        } catch (IOException e) {            e.printStackTrace();        }        return null;    }    /**     * list 转换为 Json 字符串     */    public static String list2json(List list){        mapper = new ObjectMapper();        try {            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(list);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        return null;    }    /**     * json 转换为 list     */    public static List json2List(String json){        mapper = new ObjectMapper();        try {            return mapper.readValue(json,List.class);        } catch (IOException e) {            e.printStackTrace();        }        return null;    }    /**     * set 转换为 Json 字符串     */    public static String set2json(Set set){        mapper = new ObjectMapper();        try {            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(set);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        return null;    }    /**     * json 转换为 set     */    public static Set json2Set(String json){        mapper = new ObjectMapper();        try {            return mapper.readValue(json,Set.class);        } catch (IOException e) {            e.printStackTrace();        }        return null;    }    /**     * map 转换为 Json 字符串     */    public static String map2json(Map map){        mapper = new ObjectMapper();        try {            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        return null;    }    /**     * json 转换为 map     */    public static Map json2Map(String json){        mapper = new ObjectMapper();        try {            return mapper.readValue(json,Map.class);        } catch (IOException e) {            e.printStackTrace();        }        return null;    }}

示例代码

public static void main(String[] args) {    //1. bean 和 json 互转    Person person = new Person("xiaoli",18);    String json = JacksonUtil.bean2json(person);    System.out.println(json);    Person person2 = (Person)JacksonUtil.json2bean(json, Person.class);    System.out.println(person2.toString());    //2. list 和 json 互转    List<Person> list = new ArrayList<Person>();    list.add(new Person("李四",10));    list.add(new Person("王五",20));    String listJson = JacksonUtil.list2json(list);    System.out.println(listJson);    List json2List = JacksonUtil.json2List(listJson);    System.out.println(json2List.toString());    //3. map 转 json    Map<String,Person> map = new HashMap<String,Person>();    map.put("map1",new Person("李四",10));    map.put("map2",new Person("王五",20));    String mapJson = JacksonUtil.map2json(map);    System.out.println(mapJson);    Map<Object, Object> map2 = JacksonUtil.json2Map(mapJson);    System.out.println(map2.toString());    //4. set 与 json 互转    Set<Person> set = new LinkedHashSet<Person>();    set.add(new Person("李四",10));    set.add(new Person("王五",20));    String setJson = JacksonUtil.set2json(set);    System.out.println(setJson);    Set set1 = JacksonUtil.json2Set(setJson);    System.out.println(set1.toString());}

缺点

Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。
Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式。

上面两个缺点有待考察，如有具体例子会进行更新。

小结：

Jackson 可以通过 ObjectMapper 的 writeValue() 和 readValue() 系列方法对 JSON 进行序列化和反序列化。并且擅长处理各种大量数据格式模块。

具体 Jackson 文章详见：https://www.cnblogs.com/cnjavahome/p/8393178.html

fastJson

FastJson 是由阿里巴巴开源的 JSON 解析库，它可以进行快速的序列化和反序列化。功能还是很强大的。使用 fastjson 需要注意，转换的类必须有默认的无参构造函数。

Github：fastjson

fastjson 对于 JSON 字符串解析主要用到了下面三个类：

JSON：fastjson 的解析器，提供 toJSONString 和 parseObject 方法对 JSON 进行序列化和反序列化。
JSONObject：fastjson 提供的 json 对象。
JSONArray：fastjson 提供的 json 数组对象。

依赖

使用 fastjson 前，需要引入相关依赖。

<dependency>    <groupId>com.alibaba</groupId>    <artifactId>fastjson</artifactId>    <version>1.2.61</version></dependency>

fastjson 工具类

public class FastJsonUtil{    /**     * bean 转换为 Json 字符串     */    public static String bean2json(Object object){        return JSON.toJSONString(object);    }    /**     * json 转换为 bean     */    public static Object json2bean(String json,Class c){        return JSON.parseObject(json,c);    }    /**     * list 转换为 Json 字符串     */    public static String list2json(List list){        return JSON.toJSONString(list);    }    /**     * json 转换为 list     */    public static List json2List(String json,Class c){        return JSON.parseArray(json,c);    }    /**     * set 转换为 Json 字符串     */    public static String set2json(Set set){        return  JSON.toJSONString(set);    }    /**     * json 转换为 set     */    public static Set json2Set(String json){        return JSON.parseObject(json,Set.class);    }    /**     * map 转换为 Json 字符串     */    public static String map2json(Map map){        return  JSON.toJSONString(map);    }    /**     * json 转换为 map     */    public static Map json2Map(String json){        return JSON.parseObject(json);    }}

实例代码

public class FastJsonTest {    public static void main(String[] args) {        //1. bean 和 json 互转        Person person = new Person("xiaoli",18);        String json = FastJsonUtil.bean2json(person);        System.out.println(json);        Person person2 = (Person)FastJsonUtil.json2bean(json, Person.class);        System.out.println(person2.toString());        //2. list 和 json 互转        List<Person> list = new ArrayList<Person>();        list.add(new Person("李四",10));        list.add(new Person("王五",20));        String listJson = FastJsonUtil.list2json(list);        System.out.println(listJson);        List json2List = FastJsonUtil.json2List(listJson, Person.class);        System.out.println(json2List.toString());        //3. map 转 json        Map<String,Person> map = new HashMap<String,Person>();        map.put("map1",new Person("李四",10));        map.put("map2",new Person("王五",20));        String mapJson = FastJsonUtil.map2json(map);        System.out.println(mapJson);        Map<Object, Object> map2 = FastJsonUtil.json2Map(mapJson);        System.out.println(map2.toString());        //4. set 与 json 互转        Set<Person> set = new LinkedHashSet<Person>();        set.add(new Person("李四",10));        set.add(new Person("王五",20));        String setJson = FastJsonUtil.set2json(set);        System.out.println(setJson);        Set set1 = FastJsonUtil.json2Set(setJson);        System.out.println(set1.toString());    }}运行结果：{"age":18,"name":"xiaoli"}Person(name=xiaoli, age=18)[{"age":10,"name":"李四"},{"age":20,"name":"王五"}][Person(name=李四, age=10), Person(name=王五, age=20)]{"map2":{"age":20,"name":"王五"},"map1":{"age":10,"name":"李四"}}{"map2":{"name":"王五","age":20},"map1":{"name":"李四","age":10}}[{"age":10,"name":"李四"},{"age":20,"name":"王五"}][{"name":"王五","age":20}, {"name":"李四","age":10}]

小结

fastjson 虽然很快，我还是挺推荐使用的，但还是有些缺点的。具体详见:fastjson这么快老外为啥还是热衷 jackson?

总结

我们对本篇文章做个总结：

什么是 JSON：数据交互语言，独立于任何程序语言的文本格式。

为什么使用 JSON：javaScript 原生支持 JSON，解析速度更快；比 xml 更易使用。

如何使用 JSON：

了解了 JSON 的数据结构：对象和数组。
Json 在 javaScript 中的使用：操作 json 对象和数组，通过 parse() 和 stringift() 实现 json 的反序列化和序列化。
Json 在 Java 中的使用：介绍了 Json-lib、Gson、Jackson 和 fastjson，并且对这些工具常用的序列化和反序列化的实现进行了封装。

对此，我们了解了 JSON，并且会对 JSON 进行序列化和反序列化。