Jackson多态处理

时间  2019-11-26
标签 jackson 处理 繁體版
原文   原文链接

前言

博主github

博主我的博客http://blog.healerjean.com

Jackson容许配置多态类型处理，当进行反序列话时，Json数据匹配的对象可能有多个子类型，为了正确的读取对象的类型，咱们须要添加一些类型信息。java

一、解释

1.一、@JsonTypeInfo

@JsonTypeInfo这个注解能够直接放在类上，也能够放在某个属性上：下面是内部的属性值git

1.1.一、use： （必选）：

use： （必选）：定义使用哪种类型识别码（property为识别码的key），可选值有多种：在序列化时标志出不一样的类型用什么区分，用在反序列化时转换成响应的类型github

use属性值 若不指定property则默认 做用 是否依赖JsonTypeInfo的值
JsonTypeInfo.Id.NAME @type 使用JsonTypeInfo的值做为识别码的值 若是有多个子类的状况，必须有 @JsonSubTypes，不然没法判断是哪一个子类
JsonTypeInfo.Id.CLASS @class 用类的全路劲名称来做为识别码的值 与是否有@JsonSubTypes无关
JsonTypeInfo.Id.MINIMAL_CLASS @c 表示具备最小路径的Java类名称用做识别 是否有@JsonSubTypes无关
JsonTypeInfo.Id.NONE 暂不介绍
JsonTypeInfo.Id.CUSTOM 暂不介绍

1.1.二、include （可选）

设置识别码包含在哪里。 包含类型元数据的一种机制web

include属性值 做用
JsonTypeInfo.As.PROPERTY 做为POJO的属性出现 默认
JsonTypeInfo.As.WRAPPER_OBJECT 做为一个包装的对象
JsonTypeInfo.As.WRAPPER_ARRAY 做为一个包装的数组
JsonTypeInfo.As.EXTERNAL_PROPERTY 做为一个额外的属性，跟POJO同级，只能用于属性，如何做用于类则跟JsonTypeInfo.As.PROPERTY是相同效果
JsonTypeInfo.As.EXISTING_PROPERTY 序列化，则Jackson不主动处理，由咱们自行处理。 反序列化的时候，跟JsonTypeInfo.As.PROPERTY的处理相同；

1.1.三、property 可选）

设置识别码是名称， 自定义的区分类型的id，根据 use的属性值不一样，默认值不一样，具体默认值看（1.1.1）json

1.1.四、visible （可选）

visible（可选）：定义识别码在反序列化时是否保留（无论false或true都不影响序列化）。默认是false，表示Jackson能够将识别码识别为类型后就删除。数组

1.二、@JsonSubTypes

能够用来代表这个父类的子类型有哪些微信

二、准备

2.一、Demo实体类

public abstract class Human {

    private String district;

    @Data
    public static class Man extends Human {
        private String manField;
    }

    @Data
    public static class Woman extends Human {
        private String womanField;
    }

}

2.二、正常状况下的错误的演示

@Test
    public void normal() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        Man man = new Man();
        man.setManField("男人");
        man.setDistrict("山西");
        String json = mapper.writeValueAsString(man);
        System.out.println(json);
        // {"district":"山西","manField":"男人"}
        //报错 子类转父类，再不能直接序列化为子类
        man =((Man)mapper.readValue(json, Human.class)) ;
    }

三、开始

3.一、实体demo

@Data
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.PROPERTY
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})
public abstract class Human {

    private String district;

    @Data
    public static class Man extends Human {
        private String manField;
    }

    @Data
    public static class Woman extends Human {
        private String womanField;
    }

}

3.二、测试用例

@Test
    public void testOne() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        Man man = new Man();
        man.setManField("男人");
        man.setDistrict("北京");

        String manJson = mapper.writeValueAsString(man);
        log.info("序列化Man ：【 {} 】", manJson);
        Human human = mapper.readValue(manJson, Human.class);
        log.info("子类转父类 ======================");
        String humanJson = mapper.writeValueAsString(human);
        log.info("反序列化man -> Human ：【 {} 】", humanJson);
        log.info("human.getDistrict() ：【 {} 】",  human.getDistrict());
}

3.1.三、Use （必选）

3.1.3.一、use = JsonTypeInfo. Id.NAME

使用JsonTypeInfo的值做为识别码的值，若是有多个子类的状况，必须有 @JsonSubTypes，不然没法判断是哪一个子类app

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})


序列化Man ：【 {"@type":"man","district":"北京","manField":"男人"} 】
子类转父类 ======================
反序列化man -> Human ：【 {"@type":"man","district":"北京","manField":"男人"} 】
human.getDistrict()  ：【 北京 】

  • **use = JsonTypeInfo.Id.NAME, 若是不写property ，则识别码 的名字默认为 @type **svg

  • 根据Json数据，识别以后，其值为@JsonSubTypes.Type(value = Human.Man.class, name = "man")中子类Man的name值测试

一、配置 property = “type”
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME
			  property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})

序列化Man ：【 {"type":"man","district":"北京","manField":"男人"} 】 
子类转父类 ======================
反序列化man -> Human ：【 {"type":"man","district":"北京","manField":"男人"} 】
human.getDistrict()  ：【 北京 】
  • 这个时候默认"@type就变成了type，若是换成其余的use，则默认值失效，变成这里的property 的值

3.1.3.二、use = JsonTypeInfo. Id.CLASS、property = “type”

**用类的全路劲名称来做为识别码的值，和@JsonSubType不要紧，写上了也不起做用，能够自动判断有哪些子类 **

@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS,
        	  property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})

序列化Man ：【 {"type":"com.healerjean.proj.a_test.json.jackson.d02_JsonType.Human$Man","district":"北京","manField":"男人"} 】 
反序列化man -> Human ：【 {"type":"com.healerjean.proj.a_test.json.jackson.d02_JsonType.Human$Man","district":"北京","manField":"男人"} 】 
human.getDistrict()  ：【 北京 】

  • **use = JsonTypeInfo.Id.CLASS, 若是不写property ，则识别码 的名字默认为 @class **

  • 根据Json数据，识别以后，值为，这个子类所在类路径，用.链接

一、这个时候发现和@JsonSubTypes中的值彷佛没有什么关系，我果断去掉@JsonSubTypes属性
@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS)



序列化Man ：【 {"@class` ":"com.healerjean.proj.a_test.json.jackson.d02_JsonType.Human$Man","district":"北京","manField":"男人"} 】 
反序列化man -> Human ：【 {"@class` ":"com.healerjean.proj.a_test.json.jackson.d02_JsonType.Human$Man","district":"北京","manField":"男人"} 】 
human.getDistrict()  ：【 北京 】

3.1.3.三、use = JsonTypeInfo. Id.MINIMAL_CLASS

**表示具备最小路径的Java类名称用做识别码的值，和@JsonSubType不要紧，写上了也不起做用，能够自动判断有哪些子类 **

@Data
@JsonTypeInfo(use = JsonTypeInfo.Id.MINIMAL_CLASS)


序列化Man ：【 {"@c":".Human$Man","district":"北京","manField":"男人"} 】
子类转父类 ====================== 
反序列化man -> Human ：【 {"@c":".Human$Man","district":"北京","manField":"男人"} 】human.getDistrict()  ：【 北京 】
  • **use = JsonTypeInfo.Id.CLASS, 若是不写property ，则识别码 的名字默认为 @c **

3.1.四、include （可选）

默认是 JsonTypeInfo.As.PROPERTY，上面全部的都是以它进行测试的

3.1.4.一、include = JsonTypeInfo.As.WRAPPER_OBJECT

做为一个包装的对象

@Data
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.WRAPPER_OBJECT,
        property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})


序列化Man ：【 {"man":{"district":"北京","manField":"男人"}} 】
子类转父类 ====================== 
反序列化man -> Human ：【 {"man":{"district":"北京","manField":"男人"}} 】
human.getDistrict()  ：【 北京 】

3.1.4.二、include = JsonTypeInfo.As.WRAPPER_ARRAY

做为一个包装的数组 （看下面，这个数组但是不太规则哦，就是说里面放的不必定的同类型的），和有无property无关，看下面的测试打印结果就知道

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.WRAPPER_ARRAY,
        property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})


序列化Man ：【 ["man",{"district":"北京","manField":"男人"}] 】
子类转父类 ====================== 
反序列化man -> Human ：【 ["man",{"district":"北京","manField":"男人"}] 】
human.getDistrict()  ：【 北京 】

3.1.4.三、include = JsonTypeInfo.As.EXTERNAL_PROPERTY

做为一个额外的属性，跟POJO同级，只能用于属性，如何做用于类则跟JsonTypeInfo.As.PROPERTY是相同效果

@Data
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.EXTERNAL_PROPERTY,
        property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})


序列化Man ：【 {"type":"man","district":"北京","manField":"男人"} 】
类转父类 ======================
反序列化man -> Human ：【 {"type":"man","district":"北京","manField":"男人"} 】
human.getDistrict()  ：【 北京 】

3.1.4.四、include = JsonTypeInfo.As.EXISTING_PROPERTY

反序列化 ：

  • 这个属性但是骚的厉害了，它要求property识别码的名称必须在被该属性表示的类中也存在一份，不然反序列化就会报错。
  • 反序列化的时候这个识别码名字属性被认为是识别码，若是这个识别码的值，不在@JsonSubTypes 的name中就会报错
  • 再者，反序列化以后这个属性值就不存在了，字段值也不存在了，除非再给对象从新赋值，这个值必须和咱们真正意义上的反序列化的子类的JsonSubTypes 中 name同样，不能够任意挑选，不然会报错

序列化 ：

  • 跟它没半毛钱关系，和整个注解也不要紧

序列化的时候，跟它没半毛钱关系，可是不会像上面的那样

@Data
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.EXISTING_PROPERTY,
        property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})
public class Human {

    private String district;

    private String type;

    @Data
    public static class Man extends Human {
        private String manField;
    }

    @Data
    public static class Woman extends Human {
        private String womanField;
    }

}




序列化Man ：【 {"district":"北京","type":"man","manField":"男人"} 】
子类转父类 ======================
 反序列化man -> Human ：【 {"district":"北京","type":null,"manField":"男人"} 】
 human.getDistrict()  ：【 北京 】

2.1.五、property （可选）

设置识别码是名称，根据use的属性，通常状况下有默认值

除了JsonTypeInfo.As.EXISTING_PROPERTY 有些特殊以外，JsonTypeInfo.As.EXTERNAL_PROPERTY、JsonTypeInfo.As.PROPERTY 注解的类中有了相同的属性（剩下的不讲解，由于其余的和property 没半毛钱关系），则会出现两次 以JsonTypeInfo.As.PROPERTY 举例

注意点

  • 在visible 为默认值 false的状况下反序列化， 虽然会出现两次，可是在位置上有严格要求，我测试过好屡次，发现这个标识码确定是靠前的，并且不能删除，删除就错了（固然啊，删除了，怎么判断你是哪一个子类）
@Data
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.EXTERNAL_PROPERTY,
        property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})
public class Human {

    private String district;

    private String type;

    @Data
    public static class Man extends Human {
        private String manField;
    }

    @Data
    public static class Woman extends Human {
        private String womanField;
    }

}



   @Test
    public void testOne() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        Man man = new Man();
        man.setManField("男人");
        man.setDistrict("北京");
        man.setType("lalala");

        String manJson = mapper.writeValueAsString(man);
        log.info("序列化Man ：【 {} 】", manJson);
        Human human = mapper.readValue(manJson, Human.class);
        log.info("子类转父类 ======================");
        String humanJson = mapper.writeValueAsString(human);
        log.info("反序列化man -> Human ：【 {} 】", humanJson);
        log.info("human.getDistrict() ：【 {} 】",  human.getDistrict());
        log.info("human.getType() ：【 {} 】",  human.getType());
    }



序列化Man ：【 {"type":"man","district":"北京","type":"lalala","manField":"男人"} 
子类转父类 ======================
反序列化man -> Human ：【 {"type":"man","district":"北京","type":"lalala","manField":"男人"} 】 
human.getDistrict()  ：【 北京 】
 human.getType()  ：【 lalala 】

2.1.六、visible（可选）

visible（可选）：定义识别码在反序列化（反序列为对象内部是否保留给字段）时是否保留（无论false或true都不影响序列化）。默认是false，表示Jackson能够将识别码识别为类型后就删除。

@Test
    public void testOne() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        Man man = new Man();
        man.setManField("男人");
        man.setDistrict("北京");
        man.setType("1");

        String manJson = mapper.writeValueAsString(man);
        log.info("序列化Man ：【 {} 】", manJson);
        //只剩下一个type，必须放在第一个，这样才能识别子类
        manJson = "{\"type\":\"man\",\"district\":\"北京\",\"manField\":\"男人\"} ";
        Human human = mapper.readValue(manJson, Human.class);
        log.info("子类转父类 ======================");
        String humanJson = mapper.writeValueAsString(human);
        log.info("反序列化man -> Human ：【 {} 】", humanJson);
        log.info("human.getDistrict() ：【 {} 】",  human.getDistrict());
        log.info("human.getType() ：【 {} 】",  human.getType());
    }
  • 通常状况下 visible = false
@Data
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.PROPERTY,
        property = "type",
        visible = false
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Human.Man.class, name = "man"),
        @JsonSubTypes.Type(value = Human.Woman.class, name = "woman"),
})


序列化Man ：【 {"type":"man","district":"北京","type":"1","manField":"男人"} 】
子类转父类 ====================== 
反序列化man -> Human ：【 {"type":"man","district":"北京","type":null,"manField":"男人"} 】
human.getDistrict()  ：【 北京 】
human.getType()  ：【 null 】
  • visible = true

反序列化会把它当作一个属性值处理（保留给字段了），也就是说反序列化后仍是可见的，若是在这个上面我测试的Json中再加一个type，那么这个这个识别码照样能打印，可是会失效

序列化Man ：【 {"type":"man","district":"北京","type":"1","manField":"男人"} 】
子类转父类 ======================
反序列化man -> Human ：【 {"type":"man","district":"北京","type":"man","manField":"男人"} 】
 human.getDistrict()  ：【 北京 】
human.getType()  ：【 man 】



若是在这个上面我测试的Json中再加一个type，那么这个这个识别码照样能打印，可是会失效
manJson = "{\"type\":\"man\",\"district\":\"北京\",\"type\":\"1\",\"manField\":\"男人\"} ";

打印结果
反序列化man -> Human ：【 {"type":"man","district":"北京","type":"1","manField":"男人"} 】
human.getType()  ：【 1 】
感兴趣的，欢迎添加博主微信

哈，博主很乐意和各路好友交流，若是满意，请打赏博主任意金额，感兴趣的在微信转帐的时候，备注您的微信或者其余联系方式。添加博主微信哦。

请下方留言吧。可与博主自由讨论哦

微信 微信公众号 支付宝
微信 微信公众号 支付宝
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程