Java中Json字符串和Java对象的互转

朱雀 2023-09-24 17:59 152阅读 0赞

> JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。诞生于 2002 年。易于人阅读和编写。同时也易于机器解析和生成。JSON 是目前主流的前后端数据传输方式。
> 
> JSON 采用完全独立于语言的文本格式，但是也使用了类似于 C 语言家族的习惯（包括C, C++, C\#, Java, JavaScript, Perl, Python等）。 这些特性使 JSON 成为理想的数据交换语言。几乎所有的APP、应用、网站、程序都离不开 JSON。
> 
> 常见的 Json 解析器：Gson，Fastjson，Json-lib，Jackson

--------------------

### 文章目录 ###

*   *  一、Java中Json字符串和Java对象的互转概述
     *   *   *  1、关于 Json
             *  2、Json 解析器
     *  二、使用 Gson 完成 Json 字符串和 Java 对象的互转
     *   *   *  1、Gson 介绍
             *  2、Gson 引入
             *  3、Gson 主要类介绍
             *  4、Gson Demo
             *  5、对象与 Json 互转
             *  6、直接操作 Json 以及一些 Json 的工具
             *  7、gsonUtil 工具类
     *  三、使用 FastJson 完成 Json 字符串和 Java 对象的互转
     *   *   *  1、FastJson 介绍
             *  2、FastJson 引入
             *  3、null 值对应 key 的序列化
             *  4、FastJson Demo
             *  5、对象与 Json 互转

--------------------

## 一、Java中Json字符串和Java对象的互转概述 ##

#### 1、关于 Json ####

Json（JavaScript Object Notation）是一种轻量级的数据交换格式。诞生于 2002 年。易于人阅读和编写。同时也易于机器解析和生成。Json 是目前主流的前后端数据传输方式。

Json 采用完全独立于语言的文本格式，但是也使用了类似于 C 语言家族的习惯（包括C, C++, C\#, Java, JavaScript, Perl, Python等）。 这些特性使 Json 成为理想的数据交换语言。几乎所有的APP、应用、网站、程序都离不开 Json。

#### 2、Json 解析器 ####

常见的 Json 解析器：Gson，FastJson，Json-lib，Jackson

*  Gson（又称Google Gson）是 Google 公司发布的一个开放源代码的 Java 库。特点是快速高效，代码量少、简洁；
 *  FastJson 是一个Java语言编写的高性能的 Json 处理器,由阿里巴巴公司开发。无依赖，不需要例外额外的 Jar，能够直接跑在 Jdk 上；
 *  Json-lib 最开始的也是应用最广泛的 Json 解析工具，Json-lib 不好的地方确实是依赖于很多第三方包；
 *  相比 Json-lib 框架，Jackson 所依赖的 Jar 包较少，简单易用并且性能也要相对高些。而且 Jackson 社区相对比较活跃，更新速度也比较快。Jackson 对于复杂类型的 Json 转换Bean 会出现问题，一些集合 Map，List 的转换出现问题。

序列化性能：FastJson > Jackson > Gson > Jsonlib

反序列化性能：Gson > Jackson > FastJson > Jsonlib

--------------------

## 二、使用 Gson 完成 Json 字符串和 Java 对象的互转 ##

#### 1、Gson 介绍 ####

Google 的 Gson 是目前功能最全的 Json 解析神器，Gson 当初是为因应 Google 公司内部需求而由 Google 自行研发，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。

Gson 的应用主要为 toJson 与 fromJson 两个转换函数，无依赖，不需要例外额外的 Jar，能够直接跑在 Jdk 上。而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将Json 字符串成功转换成相对应的对象。类里面只要有 get 和 set 方法，Gson 完全可以将复杂类型的 Json 到 Bean 或 Bean 到 Json 的转换，是 Json 解析的神器。

Ps：尽管 Gson 在功能上面无可挑剔，但是性能上面比 FastJson 有所差距。

#### 2、Gson 引入 ####

Maven 依赖引入：

<dependency>
         <groupId>com.google.code.gson</groupId>
         <artifactId>gson</artifactId>
         <version>2.10.1</version>
     </dependency>

#### 3、Gson 主要类介绍 ####

Gson 主要类：

*  Gson 类：解析 Json 的最基础的工具类
 *  JsonParser 类：解析器来解析 Json 到 JsonElements 的解析树
 *  JsonElement 类：一个类代表的 Json 元素
 *  JsonObject 类：Json 对象类型
 *  JsonArray 类：JsonObject 数组
 *  TypeToken 类：用于创建 type，比如泛型 List<?>

#### 4、Gson Demo ####

import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    
    public class GsonTestClass {
        
    
        public static void main(String[] args) {
        
            User user = new User();
            user.setId(1);
            user.setName("栗筝i");
            Gson g = new GsonBuilder().create();
            String str = g.toJson(user);
            System.out.println(str);
        }
    }

Ps：默认是不序列化 null 值对应的 key 的，若是想序列化 null 值对应的 key，只需要将以上创建代码改成以下代码就行：

Gson g = new GsonBuilder().serializeNulls().create();

#### 5、对象与 Json 互转 ####

\# bean 转换 Json

Gson gson = new Gson();
    // obj 是对象
    String json = gson.toJson(obj);

Ps：当我们需要把定义类的成员变量属性名和返回的 Json 中的格式名称隔离开，可以采用 @SerializedName 注解标记！！

\# Json 转换 bean

Gson gson = new Gson();
    String json = "{\"id\":\"1\",\"name\":\"栗筝i\"}";
    Book book = gson.fromJson(json, Book.class);

\# Json 转换复杂的 bean，比如 List，Set

Gson gson = new Gson();
    String json = "[{\"id\":\"1\",\"name\":\"栗筝i\"},{\"id\":\"2\",\"name\":\"栗筝ii\"}]";
    // 将 Json 转换成 List
    List list = gson.fromJson(json, new TypeToken<LIST>() {
        }.getType());
    // 将 Json 转换成 Set
    Set set = gson.fromJson(json, new TypeToken<SET>() {
        }.getType());

#### 6、直接操作 Json 以及一些 Json 的工具 ####

\# 格式化 Json：

String json = "[{\"id\":\"1\",\"name\":\"栗筝i\"},{\"id\":\"2\",\"name\":\"栗筝ii\"}]";
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    JsonParser jp = new JsonParser();
    JsonElement je = jp.parse(json);
    json = gson.toJson(je);

\# 判断字符串是否是 Json（通过捕捉的异常来判断是否是 Json）

String json = "[{\"id\":\"1\",\"name\":\"栗筝i\"},{\"id\":\"2\",\"name\":\"栗筝ii\"}]";
    boolean jsonFlag;
    try {
        
         new JsonParser().parse(str).getAsJsonObject();
         jsonFlag = true;
    } catch (Exception e) {
        
         jsonFlag = false;
    }

\# 从 Json 串中获取属性

String json = "{\"id\":\"1\",\"name\":\"栗筝i\"}";
    String propertyName = 'id';
    String propertyValue = "";
    try {
        
        JsonParser jsonParser = new JsonParser();
        JsonElement element = jsonParser.parse(json);
        JsonObject jsonObj = element.getAsJsonObject();
        propertyValue = jsonObj.get(propertyName).toString();
    } catch (Exception e) {
        
        propertyValue = null;
    }

\# 除去 Json 中的某个属性

String json = "{\"id\":\"1\",\"name\":\"栗筝i\"}";
    String propertyName = 'id';
    JsonParser jsonParser = new JsonParser();
    JsonElement element = jsonParser.parse(json);
    JsonObject jsonObj = element.getAsJsonObject();
    jsonObj.remove(propertyName);
    json = jsonObj.toString();

\# 向 Json 中添加属性

String json = "{\"id\":\"1\",\"name\":\"栗筝i\"}";
    String propertyName = 'age';
    Object propertyValue = "26";
    JsonParser jsonParser = new JsonParser();
    JsonElement element = jsonParser.parse(json);
    JsonObject jsonObj = element.getAsJsonObject();
    jsonObj.addProperty(propertyName, new Gson().toJson(propertyValue));
    json = jsonObj.toString();

\# 修改 Json 中的属性

String json = "{\"id\":\"1\",\"name\":\"栗筝i\"}";
    String propertyName = 'name';
    Object propertyValue = "栗筝ii";
    JsonParser jsonParser = new JsonParser();
    JsonElement element = jsonParser.parse(json);
    JsonObject jsonObj = element.getAsJsonObject();
    jsonObj.remove(propertyName);
    jsonObj.addProperty(propertyName, new Gson().toJson(propertyValue));
    json = jsonObj.toString();

\# 判断 Json 中是否有属性

String json = "{\"id\":\"1\",\"name\":\"栗筝i\"}";
    String propertyName = 'name';
    boolean isContains = false ;
    JsonParser jsonParser = new JsonParser();
    JsonElement element = jsonParser.parse(json);
    JsonObject jsonObj = element.getAsJsonObject();
    isContains = jsonObj.has(propertyName);

#### 7、gsonUtil 工具类 ####

import com.dechnic.common.anno.gson.Exclude;
    import com.dechnic.common.po.ObjectTypeAdapter;
    import com.google.gson.ExclusionStrategy;
    import com.google.gson.FieldAttributes;
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.internal.LinkedTreeMap;
    import com.google.gson.reflect.TypeToken;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    public class GsonUtll {
        
        private static Gson gson;
        static {
        
            ExclusionStrategy strategy = new ExclusionStrategy() {
        
                @Override
                public boolean shouldSkipField(FieldAttributes f) {
        
                    return f.getAnnotation(Exclude.class) !=null;
                }
    
                @Override
                public boolean shouldSkipClass(Class<?> clazz) {
        
                    return false;
                }
            };
            gson = new GsonBuilder().disableHtmlEscaping().setExclusionStrategies(strategy).registerTypeAdapter(new TypeToken<Map<String,Object>>(){
        }.getType(),new ObjectTypeAdapter()).serializeNulls().create();
        }
      
        public static Map<String,Object> jsonStr2Map(String jsonStr){
        
            return gson.fromJson(jsonStr, new TypeToken<Map<String, Object>>() {
        
            }.getType());
        }
      
        public static List<Map<String,Object>> jsonStr2ListMap(String jsonStr){
        
            return gson.fromJson(jsonStr, new TypeToken<List<Map<String, Object>>>() {
        
            }.getType());
        }
      
        public static String toJSON(Object object){
        
            return gson.toJson(object);
        }
      
        public static <T> List<T> json2ListBean(String result, Class<T> t){
        
            List list = gson.fromJson(result, new TypeToken<List>() {
        
            }.getType());
            List list2 = new ArrayList();
            for (Object o : list) {
        
                list2.add(json2Bean(toJSON(o),t));
            }
            return list2;
        }
      
        public static <T> T json2Bean(String result,Class<T>t){
        
            return gson.fromJson(result, t);
        }
    
    }

--------------------

## 三、使用 FastJson 完成 Json 字符串和 Java 对象的互转 ##

#### 1、FastJson 介绍 ####

Fastjson 由阿里巴巴公司开发，是一个 Java 语言编写的高性能的 Json 处理器。无依赖，不需要例外额外的 Jar，能够直接跑在 Jdk 上。

FastJson 在复杂类型的 Bean 转换 Json 上会出现一些问题，可能会出现引用的类型，导致 Json 转换出错，需要制定引用。

FastJson 采用独创的算法，将 parse 的速度提升到极致，超过所有 Json 库。

#### 2、FastJson 引入 ####

Maven 依赖引入：

<dependency>
        <groupId>com.alibaba.fastjson2</groupId>
        <artifactId>fastjson2</artifactId>
        <version>2.0.23</version>
    </dependency>

#### 3、null 值对应 key 的序列化 ####

FastJson 在转换 Java 对象为 Json 的时候，默认是不序列化 null 值对应的 key 的，也就是说当对象里面的属性为空的时候，在转换成 Json 时，不序列化那些为 null 值的属性

仔细看 FastJson 转换 Java 对象为 Json 的方法的入参：

public static String toJSONString(Object object, com.alibaba.fastjson2.JSONWriter.Feature... features)

可以看到 features 是一个数组 JSONWriter.Feature 则是其序列化属性：

*  QuoteFieldNames———-输出 key 时是否使用双引号，默认为 true
 *  WriteMapNullValue——–是否输出值为 null 的字段，默认为 false
 *  WriteNullNumberAsZero———-数值字段如果为 null，输出为 0,而非 null
 *  WriteNullListAsEmpty———-List 字段如果为 null，输出为\[\]，而非null
 *  WriteNullStringAsEmpty———-字符类型字段如果为 null，输出为”“，而非null
 *  WriteNullBooleanAsFalse———-Boolean 字段如果为 null，输出为 false，而非null

#### 4、FastJson Demo ####

import com.alibaba.fastjson2.JSONObject;
    import com.alibaba.fastjson2.JSONWriter;
    
    public class FastJsonTestClass {
        
    
        public static void main(String[] args) {
        
            User user = new User();
            user.setIdd(1);
            user.setName("栗筝i");
            String str = JSONObject.toJSONString(user, JSONWriter.Feature.WriteMapNullValue);
            System.out.println(str);
    
        }
    }

Ps：当我们需要把定义类的成员变量属性名和返回的 Json 中的格式名称隔离开，可以采用 @JSONField 注解标记！！

#### 5、对象与 Json 互转 ####

\# 对象转 Json

User user = new User();
    user.setId(1);
    user.setName("栗筝i");
    System.out.println(JSON.toJSONString(user, JSONWriter.Feature.UseSingleQuotes));

\# Json 转对象

String json = "{\"id\":1,'name':'张三'}";
    User userModel = JSON.parseObject(json, User.class);

\# 将 Json 解析为 JSONObject

String json = "{\"id\":1,'name':'张三'}";
    JSONObject data = JSON.parseObject(json);
    System.out.println(data.get("id"));

\# 将 Json 解析为 JSONArray

String text = "...";
    JSONArray data = JSON.parseArray(text);