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":"xiaomin@sina.com"}
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\":\"xiaomin@sina.com\"}";
/**
 * 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", "john.doe@example.com");
    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/