Gson解析（序列化，反序列化）

Posted 2021-07-21 春招进大厂的梦想家

Gson解析（序列化，反序列化）

Gson 是google解析Json的一个开源框架，是Google提供的用来在java对象和JSON字符串之间进行映射的类库，可以将一个JSON字符串转成一个java对象（反序列化），或者把java对象转成一个JSON字符串（序列化）

1.导入依赖

 implementation 'com.google.code.gson:gson:2.8.6'

2.Gson的基本用法之JavaBean转换成Json字符串

gson提供 publicString toJson(Object src) 方法可以将对象转换成jsonStr

1.创建一个实体类

public class CommentItem {
    private String username;
    private String password;
    private String repassword;

    public String getRepassword() {
        return repassword;
    }

    public CommentItem(String username) {
        this.username = username;
    }

    public CommentItem(String username, String password,String repassword) {
        this.username = username;
        this.password = password;
        this.repassword = repassword;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

2.在.java文件中写入代码：

public class Test {
    @TestOnly
    public void test(){
        //java对象
        CommentItem commentItem = new CommentItem("13","14","14");
        commentItem.setPassword("12");
        //Gson提供的Gson对象
        Gson gson = new Gson();
        //序列化
        String json = gson.toJson(commentItem);
        System.out.println("序列化"+json);
    }
}

3.Gson的基本用法之Json字符串转换成JavaBean

public class Test {
    @TestOnly
    public void test(){
        //java对象
        CommentItem commentItem = new CommentItem("13","14","14");
        commentItem.setPassword("12");
        //Gson提供的Gson对象
        Gson gson = new Gson();
        //反序列化
        CommentItem commentItem1 = gson.fromJson(json,CommentItem.class);
        System.out.println("反序列化"+commentItem1);
    }
}

4.数组的序列化和反序列化

数组类型对象和普通对象一样，使用toJson和fromJson即可完成序列化和反序列化

1.首先创建一个实体类，和上面的创建一样

2.编写序列化反序列化代码

//数组对象 序列化和反序列化
    public void serializationTest() {
        CommentItem[] commentItems = new CommentItem[3];
        //java对象
        commentItems[0] = new CommentItem("1", "2", "3");
        commentItems[1] = new CommentItem("4", "5", "6");
        //Gson提供的Gson对象
        Gson gson = new Gson();
        //序列化
        String json = gson.toJson(commentItems);
        System.out.println("序列化：" + json);
        for (int i = 0; i < 2; i++) {
            System.out.println("序列化："+i+" "+commentItems[i]);
        }

        //反序列化
        CommentItem[] commentItems1 = gson.fromJson(json,CommentItem[].class);
        for (int i = 0; i < 2; i++) {
            System.out.println("反序列化："+i+" "+commentItems1[i]);
        }
    }

5.Array 与 List 的序列化和反序列化

1.实体类创建如上

2.编写代码：

 public void ListSerialization(){
        //创建一个集合
        List<CommentItem> list = new ArrayList<>();
        list.add(new CommentItem("1","2","3"));
        list.add(new CommentItem("4","5","6"));
        list.add(null);

        //Gson提供的Gson对象
        Gson gson = new Gson();

        //序列化
        String json = gson.toJson(list);
        System.out.println("序列化：" + json);

        //!!!反序列化
            //TypeToken是Gson类库提供的一个对象，可以把将要被反序列化的集合的泛型作为TypeToken的参数指定到TypeToken里面
            //然后得到一个type对象，反序列化时直接传入type
        Type type = new TypeToken<List<CommentItem>>() {
        }.getType();
        List<CommentItem> list1 = gson.fromJson(json,type);
        System.out.println("反序列化0"+list1.get(0));
        System.out.println("反序列化0"+list1.get(1).getUsername());
        System.out.println("反序列化0"+list1.get(2));
    }

**这里需要注意！！**不能直接把List.class作为fromJson的参数进行传递。因为List集合有泛型，反序列化的时候不知道把转成的对象放在什么下面，即不知道泛型的类型，所以会报错。

正确的做法是用Gson提供的TypeToken把将要被反序列化的集合的泛型作为TypeToken的参数指定到TypeToken里面，得到一个Type对象，然后再进行传递。

6.Map、Set集合的序列化和反序列化

 //Map、Set 集合的序列化反序列化
    public void MapSetSerialization() {
        Set<CommentItem> set = new HashSet<>();
        set.add(new CommentItem("1", "2", "3"));
        set.add(new CommentItem("4", "5", "6"));
        set.add(null);

        //Gson提供的Gson对象
        Gson gson = new Gson();

        //序列化
        String json = gson.toJson(set);
        System.out.println("序列化：" + json);

        //反序列化的第一种方法：使用List来进行反序列化
        Type type = new TypeToken<List<CommentItem>>() {
        }.getType();
        List<CommentItem> list = gson.fromJson(json, type);
        System.out.println("反序列化0" + list.get(0));
        System.out.println("反序列化0" + list.get(1).getUsername());
        System.out.println("反序列化0" + list.get(2));

        //反序列化得第二种方法：使用set来进行反序列化
        Type type2 = new TypeToken<Set<CommentItem>>() {
        }.getType();
        Set<CommentItem> set1 = gson.fromJson(json, type2);
        Iterator<CommentItem> iterator = set1.iterator();
        while (iterator.hasNext()) {
            CommentItem commentItem = iterator.next();
            System.out.println("反序列化：" + commentItem);
        }
    }

所以亲爱的宝贝们问题来了，为什么可以使用第一种方法用List来进行反序列化呢？

因为HashSet类型，完全可以使用反序列化为List,两者序列化后的json字符串数据完全一致！