博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
JSON的学习与使用
阅读量：3535 次
发布时间：2019-05-20

本文共 20234 字，大约阅读时间需要 67 分钟。

公众号：小李不秃，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] + "
";}运行结果：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] + "
";}

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 + "
";	for (i=0;i
";}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+"
");'+      'document.write("年龄："+this.age+"
");'+      'document.write("金钱："+this.money+"
");}}'; 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
   
     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
    
      json2Map(String json) {
           JSONObject jsonObject = JSONObject.fromObject(json);        Map
     
       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
   
     list = new ArrayList
    
     ();        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
     
       map = new HashMap
      
       ();        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
       
         map2 = JsonLibUtils.json2Map(mapJson);        //4. set 与 json 互转        Set
        
          set = new LinkedHashSet
         
          (); 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 需要引入这个依赖。

       
    
     com.google.code.gson
        
    
     gson
        
    
     2.8.6
        
    
     compile

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
   
    (){
   }.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
    
     (){
   }.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
     (){
   }.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
   
     list = new ArrayList
    
     ();    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
     
       map = new HashMap
      
       ();    map.put("map1",new Person("李四",10));    map.put("map2",new Person("王五",20));    String mapJson = GsonUtil.map2json(map);    System.out.println(mapJson);    Map
       
         map2 = GsonUtil.json2Map(mapJson);    System.out.println(map2.toString());        //4. set 与 json 互转    Set
        
          set = new LinkedHashSet
         
          (); 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 文章详见：

Jackson

Github 地址：

简单介绍一下 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 之前，需要先添加依赖。

       
    
     com.fasterxml.jackson.core
        
    
     jackson-databind
        
    
     2.9.1

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
   
     list = new ArrayList
    
     ();    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
     
       map = new HashMap
      
       ();    map.put("map1",new Person("李四",10));    map.put("map2",new Person("王五",20));    String mapJson = JacksonUtil.map2json(map);    System.out.println(mapJson);    Map
       
         map2 = JacksonUtil.json2Map(mapJson);    System.out.println(map2.toString());    //4. set 与 json 互转    Set
        
          set = new LinkedHashSet
         
          (); 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 对于 JSON 字符串解析主要用到了下面三个类：

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

依赖

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

   	
    
     com.alibaba
    	
    
     fastjson
    	
    
     1.2.61

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
   
     list = new ArrayList
    
     ();        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
     
       map = new HashMap
      
       ();        map.put("map1",new Person("李四",10));        map.put("map2",new Person("王五",20));        String mapJson = FastJsonUtil.map2json(map);        System.out.println(mapJson);        Map
       
         map2 = FastJsonUtil.json2Map(mapJson);        System.out.println(map2.toString());        //4. set 与 json 互转        Set
        
          set = new LinkedHashSet
         
          (); 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 虽然很快，我还是挺推荐使用的，但还是有些缺点的。具体详见:

总结

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

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

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

如何使用 JSON：

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

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

参考

推荐阅读

你可能感兴趣的文章
Springboot项目利用Java客户端调用FastDFS
查看>>
全文检索工具elasticsearch的安装和简单介绍
查看>>
利用Kibana学习全文检索工具elasticsearch
查看>>
SpringBoot在Test测试类或自定义类中通过@Autowired注入为null
查看>>
使用docker搭建YAPI服务
查看>>
西南科技大学OJ题 邻接表到邻接矩阵1056
查看>>
西南科技大学OJ题 有向图的出度计算1057
查看>>
西南科技大学OJ题 有向图的最大出度计算1059
查看>>
西南科技大学OJ题 带权有向图计算1063
查看>>
oracle主键自增触发器编写
查看>>
String与StringBuilder与StringBuffer三者的差别
查看>>
各种IO流之间的关系和区别
查看>>
SSM如何实现上传单图片
查看>>
SSM环境下java如何实现语音识别（百度语音识别版）
查看>>
ajax方法参数的用法和他的含义
查看>>
数据库基础技巧及用法
查看>>
实用方法：无request参数时获得当前的request的方法
查看>>
JS操作数组常用实用方法
查看>>
java实现MD5多次进行加密加盐操作
查看>>
springboot实现CAS的server服务器端的搭建，并实现链接mysql数据库，自定义加密算法
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-09-13 00:47:54   当前IP: 3.137.181.170   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我