Java-json序列化和反序列化

java開發中經常會遇到json的序列化與反序列化，常用的json序列化工具有阿里的Fastjson、spring mvc內置的Jackson、還有就是我們接下來要說的谷歌的Gson。

Fastjson 的常見使用

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

反序列化
// 把JSON文本parse為JSONObject或者JSONArray 
public static final Object parse(String text); 

// 把JSON文本parse成JSONObject
public static final JSONObject parseObject(String text)；   

// 把JSON文本parse為JavaBean 
public static final <T> T parseObject(String text, Class<T> clazz); 

// 把JSON文本parse成JSONArray 
public static final JSONArray parseArray(String text); 

//把JSON文本parse成JavaBean集合
public static final <T> List<T> parseArray(String text, Class<T> clazz); 


序列化 // 將JavaBean序列化為JSON文本 
public static final String toJSONString(Object object);

// 將JavaBean序列化為帶格式的JSON文本 
public static final String toJSONString(Object object, boolean prettyFormat);

//將JavaBean轉換為JSONObject或者JSONArray。
public static final Object toJSON(Object javaObject);

示例

fastjson反序列化json字符串為四種類型

1. JavaBean
     Student student =  JSON.parseObject(jsonString, Student.class); 2. List<JavaBean>
     List<Student> listPerson =JSON.parseArray(jsonString, Student.class); 3. Map<String,Student>
     Map<String, Object> listPerson = JSON.parseObject(jsonString,new TypeReference<Map<String,Object>>(){}); 4. List<Map<String,Object>>
     List<Map<String, Object>> listMap = JSON.parseObject(jsonString, new TypeReference<List<Map<String,Object>>>(){});

 JackJson的常見使用

需要包：
jackson-core-2.2.3.jar（核心jar包）
jackson-annotations-2.2.3.jar（該包提供Json注解支持）
jackson-databind-2.2.3.jar

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

1、指定對象Class轉成 json字符串

/**

ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中實現。
ObjectMapper有多個JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介質中。
writeValue(File arg0, Object arg1)把arg1轉成json序列，並保存到arg0文件中。
writeValue(OutputStream arg0, Object arg1)把arg1轉成json序列，並保存到arg0輸出流中。
writeValueAsBytes(Object arg0)把arg0轉成json序列，並把結果輸出成字節數組。
writeValueAsString(Object arg0)把arg0轉成json序列，並把結果輸出成字符串。 */ ObjectMapper mapper = new ObjectMapper();

//User類轉JSON

{"name":"小民","age":20,"birthday":844099200000,"email":"[e-mail]"}
String json = mapper.writeValueAsString(user);
System.out.println(json);

2、List集合轉化成json字符串

List<User> users = new ArrayList<User>();
users.add(user);
String jsonlist = mapper.writeValueAsString(users);
System.out.println(jsonlist);

3、Json字符串轉化成指定Class類

String json = "{\"name\":\"小民\",\"age\":20,\"birthday\":844099200000,\"email\":\"[e-mail]\"}";
/**
 * ObjectMapper支持從byte[]、File、InputStream、字符串等數據的JSON反序列化。
 */ ObjectMapper mapper = new ObjectMapper(); User user = mapper.readValue(json, User.class);
System.out.println(user);

4、Json字符串轉化成集合List

String jsonString="[{'id':'1'},{'id':'2'}]";
ObjectMapper mapper = new ObjectMapper();
List<Bean> beanList = mapper.readValue(jsonString, new TypeReference<List<Bean>>() {});

5.創建一個JSON對象

try {
    // create `ObjectMapper` instance
    ObjectMapper mapper = new ObjectMapper();

    // create a JSON object
    ObjectNode user = mapper.createObjectNode();
    user.put("id", 1);
    user.put("name", "John Doe");
    user.put("email", "[e-mail]");
    user.put("salary", 3545.99);
    user.put("role", "QA Engineer");
    user.put("admin", false);

    // convert `ObjectNode` to pretty-print JSON
    // without pretty-print, use `user.toString()` method
    String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user); // print json
    System.out.println(json);

} catch (Exception ex) {
    ex.printStackTrace();
}

Gson 的常見使用

GSON是Google提供的用來在Java對象和JSON數據之間進行映射的Java類庫。可以將一個Json字符轉成一個Java對象，或者將一個Java轉化為Json字符串。

     Gson特點：1：面向對象；2：簡潔高效；3：數據傳遞和解析方便

下面介紹一下Gson的常用方法

首先貼一下我用來做示例的實體類Test的代碼，如下：

public class Test {
    /* 姓名*/
    private String name;
    /* 性別*/
    private String sex;
    /* 年齡*/
    private Integer age;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getSex() {
        return sex;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "StudentEntity{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
 
    public Test(String name, String sex, Integer age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}

1.gson.tojso();//形參為要序列化的json串

方法作用：把實體對象轉換為json（序列化）

public static void main(String[] args) {
       //創建實體類
      Test test = new Test("序列化", "男", 25);
      //實例化Gson
      Gson gson = new Gson(); //把對象序列化為json
      String s = gson.toJson(test); //輸出---序列化后的結果為：{"name":"序列化","sex":"男","age":25}
      System.out.println("序列化后的結果為："+s);
      //定義List集合
      List<Test> tests = new ArrayList<>();
      tests.add(test);
      String s1 = gson.toJson(tests); //輸出---List集合序列化后的結果為：[{"name":"序列化","sex":"男","age":25}]
      System.out.println("List集合序列化后的結果為："+s1);
      Map<String, Test> testMap = new HashMap<>();
      testMap.put("序列化測試",test);
      //輸出--Map集合序列化后的結果為：{序列化測試=StudentEntity{name='序列化', sex='男', age=25}}
      System.out.println("Map集合序列化后的結果為："+testMap);
}

2.gson.fromJson();

方法作用：

（1）把json轉換為List對象（反序列化）

public static void main(String[] args) {
      // 定義json
      String json = "[{\"name\":\"轉換對象\",\"sex\":\"女\",\"age\":20}]";
      //實例化Gson
      Gson gson = new Gson(); //把json序列化為List對象
      List<Test> o = gson.fromJson(json, new TypeToken<List<Test>>() {
 }.getType()); //輸出---序列化后的結果為：[StudentEntity{name='轉換對象', sex='女', age=20}]
      System.out.println("反序列化成List后的結果為："+o.toString());
  }

（2）把json轉換為Map對象（反序列化）

public static void main(String[] args) {
      //實例化Gson
      Gson gson = new Gson(); //定義json
      String jsonMap = "{'序列化測試':{name='序列化', sex='男', age=25}}";
      //把json序列化為Map對象
      HashMap<String,Test> o1 = gson.fromJson(jsonMap, new TypeToken<HashMap<String,Test>>() { }.getType()); //輸出---{序列化測試=StudentEntity{name='序列化', sex='男', age=25}}
      System.out.println("反序列化成Map后的結果為："+o1);
  }

（3）把json轉換為實體對象（反序列化）

public static void main(String[] args) {
      // 定義json
      String json = "{\"name\":\"轉換對象\",\"sex\":\"女\",\"age\":20}";
      //實例化Gson
      Gson gson = new Gson(); //把json序列化為實體類（Test）對象
      Test test = gson.fromJson(json, Test.class); //輸出---反序列化后的結果為：StudentEntity{name='轉換對象', sex='女', age=20}
      System.out.println("反序列化成實體類后的結果為："+test.toString());
  }

注意：

一、把實體類序列化為json時，如果實體類某個屬性的值為null，gson在序列化該對象是則默認過濾掉該屬性，該屬性不會參與序列化。

二、反序列化時需注意json串的格式，如果是數組則最外層是用‘[ ]’來包括的，如果是對象或者是Map則是用‘{ }’來包括的，

根據需要反序列化的json格式來選定需要反序列化用的方法gson.fromJson()應該傳遞哪種參數，反序列化成對象參數應該是這個對象的反射（entity.Class），如果是List或者是Map，參數則是泛型。

參考網址：

Fastjson

https://github.com/alibaba/fastjson 

https://blog.csdn.net/chq88888/article/details/100591317?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduend~default-2-100591317.nonecase&utm_term=json%E5%BA%8F%E5%88%97%E5%8C%96%E4%BB%80%E4%B9%88%E6%84%8F%E6%80%9D&spm=1000.2123.3001.4430

JackJson

https://attacomsian.com/blog/jackson-create-json-object

https://www.jianshu.com/p/3931b3b6e7b6

https://www.javaguides.net/p/java-jackson-json-tutorial-with-examples.html

Gson

https://blog.csdn.net/weixin_41763995/article/details/88063847

https://github.com/google/gson

https://howtodoinjava.com/gson/gson-serialize-deserialize-json/