Gson系列1 --- Gson 序列化与反序列化 -- 类的继承 序列化

1、简述

> 类的继承 序列化
  
  单个类序列化与反序列化： 等同于简单对象的序列化
  多态类型是可以进行 序列化，但是 反序列化会出错
  解决方式 ： 见泛型序列化 / 多态序列化

2、基本类 

GsonFather 是 父类 ，GsonSon 和 GsonDaughter 是子类

GsonExtends 是 包含的父类 -- 进行绑定子类进行测试

@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class GsonFather {
    private Integer id;
    private String name;
}

@Data
@NoArgsConstructor
public class GsonSon extends GsonFather{
    private Integer ids;
    private String nickName;

    public GsonSon(Integer id, String name, Integer ids, String nickName) {
        super(id, name);
        this.ids = ids;
        this.nickName = nickName;
    }

    public GsonSon(Integer ids, String nickName) {
        this.ids = ids;
        this.nickName = nickName;
    }
}

@Data
@NoArgsConstructor
public class GsonDaughter extends GsonFather{
    private Integer idx;
    private String realName;

    public GsonDaughter(Integer id, String name, Integer idx, String realName) {
        super(id, name);
        this.idx = idx;
        this.realName = realName;
    }

    public GsonDaughter(Integer idx, String realName) {
        this.idx = idx;
        this.realName = realName;
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class GsonExtends {
    private GsonFather gs;
    private GsonFather gd;
}

3、测试类

package sun.rain.amazing.gson.quickstart;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import org.junit.Test;
import sun.rain.amazing.gson.quickstart.extend.GsonDaughter;
import sun.rain.amazing.gson.quickstart.extend.GsonExtends;
import sun.rain.amazing.gson.quickstart.extend.GsonFather;
import sun.rain.amazing.gson.quickstart.extend.GsonSon;

/**
 * @author sunRainAmazing
 */
public class GsonExtendsTest {

    private Gson gson = new Gson();

    /**
     * {"ids":102,"nickName":"tomcat"}
     * GsonSon(ids=102, nickName=tomcat)
     * {"ids":102,"nickName":"tomcat","id":null,"name":null}
     */
    @Test
    public void testGsonExtends(){
        GsonSon gs = new GsonSon(102,"tomcat");
        // json 序列化
    String json = gson.toJson(gs);
        System.out.println(json);
        // json 反序列化
    GsonSon s = gson.fromJson(json,GsonSon.class);
        System.out.println(s);

        gson = new GsonBuilder().serializeNulls().create();
        json = gson.toJson(gs);
        System.out.println(json);
    }

    /**
     * {"ids":102,"nickName":"tomcat","id":111,"name":"Kent"}
     * GsonSon(ids=102, nickName=tomcat)
     * 111 -- Kent
     */
    @Test
    public void testGsonExtends1(){

        GsonSon gs = new GsonSon(111,"Kent",102,"tomcat");
        // json 序列化
    String json = gson.toJson(gs);
        System.out.println(json);
        // json 反序列化
    GsonSon s = gson.fromJson(json,GsonSon.class);
        System.out.println(s);
        System.out.println(s.getId() + " -- " + s.getName());
    }


    /**
     * {"gs":{"ids":102,"nickName":"tomcat","id":111,"name":"Kent"},
     *   "gd":{"idx":103,"realName":"jerry","id":111,"name":"Kent"}}
     *
     * java.lang.RuntimeException:
     * Failed to invoke public
     *     sun.rain.amazing.gson.quickstart.extend.GsonFather() with no args
     *
     * 不能正确的解析 多态的数据
  *   解决方式 ：
  *      1、可采用泛型
  *      2、添加一个唯一标示(见 后续的文章 多态的反序列化 )
     */
    @Test
    @Deprecated
    public void testGsonExtends2(){

        GsonSon gs = new GsonSon(111,"Kent",102,"tomcat");
        GsonDaughter gd = new GsonDaughter(111,"Kent",103,"jerry");

        GsonExtends ge = new GsonExtends(gs,gd);
        // json 序列化
    String json = gson.toJson(ge);
        System.out.println(json);
        // json 反序列化
    GsonExtends s = gson.fromJson(json,GsonExtends.class);
        System.out.println(s);
        System.out.println(s.getGd().getId() + " -- " + s.getGs().getName());
    }


}