jackson 反序列化(纯流程无POC)

pom.xml：

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

基础知识点：

https://drun1baby.top/2023/12/07/Jackson-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%EF%BC%88%E4%B8%80%EF%BC%89%E6%BC%8F%E6%B4%9E%E5%8E%9F%E7%90%86/

以下知识均来自上述链接，有空请移步仔细阅读

给个总结：

基础知识总结

jackson是用来序列化和反序列化json的解析器之一

Jackson 的核心模块由三部分组成。

jackson-core，核心包，提供基于”流模式”解析的相关 API，它包括 JsonPaser 和 JsonGenerator。 Jackson 内部实现正是通过高性能的流模式 API 的 JsonGenerator 和 JsonParser 来生成和解析 json。
jackson-annotations，注解包，提供标准注解功能；
jackson-databind ，数据绑定包，提供基于”对象绑定” 解析的相关 API （ ObjectMapper ）和”树模型” 解析的相关 API （JsonNode）

ObjectMapper

使用该对象的方法，可以解析JSON到java对象，也可以把java对象转化为JSON

json转化为对象

将json转化为对象code：（需要有Person类）

1
2
3

String json = "{\"name\":\"John\", \"age\":30}";
ObjectMapper objectMapper = new ObjectMapper();
Person person = objectMapper.readValue(json, Person.class);

对象转化为json

ObjectMapper objectMapper = new ObjectMapper();
      Person person = new Person();
      person.setAge(123);
      person.setName("fakes0u1");
String jsonstring = objectMapper.writeValueAsString(person);

共有三种方法可以将对象转化为json：

writeValue()
writeValueAsString()
writeValueAsBytes()

JsonParser

ObjectMapper.readValue其实底层就是用的JsonParser进行解析。算是另一种更底层的转化方式，由于底层，所以速度更快

json转化为对象

JsonParser的使用如下：

1
2
3

String json = "{\"name\":\"fakes0u1\",\"age\":123}";
      JsonFactory jsonFactory = new JsonFactory();
JsonParser parser = jsonFactory.createParser(json);

对象转化为Json

使用JsonGenerator从java对象生成JSON

JsonFactory jsonFactory = new JsonFactory();
      Person1 person1 = new Person1();
JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File("output.json"), JsonEncoding.UTF8);
      jsonGenerator.writeStartObject();
      jsonGenerator.writeStringField("name","fakes0u1");
      jsonGenerator.writeNumberField("age",123);
      jsonGenerator.writeEndObject();

      jsonGenerator.close();

也可以把文件流换成其他流进行写入

JacksonPolymorphicDeserialization 机制

简单地说，Java 多态就是同一个接口使用不同的实例而执行不同的操作。

那么问题来了，如果对多态类的某一个子类实例在序列化后再进行反序列化时，如何能够保证反序列化出来的实例即是我们想要的那个特定子类的实例而非多态类的其他子类实例呢？—— Jackson 实现了 JacksonPolymorphicDeserialization 机制来解决这个问题。

JacksonPolymorphicDeserialization 即 Jackson 多态类型的反序列化：在反序列化某个类对象的过程中，如果类的成员变量不是具体类型（non-concrete），比如 Object、接口或抽象类，则可以在 JSON 字符串中指定其具体类型，Jackson 将生成具体类型的实例。

简单地说，就是将具体的子类信息绑定在序列化的内容中以便于后续反序列化的时候直接得到目标子类对象，其实现有两种，即 DefaultTyping 和 @JsonTypeInfo 注解。这里和前面学过的 fastjson 是很相似的。

DefaultTyping

Jackson 提供一个 enableDefaultTyping 设置，该设置位于jackson-databind-2.7.9.jar!/com/fasterxml/jackson/databind/ObjectMapper.java

共有以下四个选项：

JAVA_LANG_OBJECT
OBJECT_AND_NON_CONCRETE
NON_CONCRETE_AND_ARRAYS
NON_FINAL

先用enableDefaultTyping进行设置，再调用writeValueAsString进行序列化。就会按照属性类型进行序列化和反序列化。看下case吧：

1
2
3

ObjectMapper mapper = new ObjectMapper(); 
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.JAVA_LANG_OBJECT);
String json = mapper.writeValueAsString(p);

左边是没设置enableDefaultTyping，右边是设置的

这四个选项能反序列化的属性范围如下：

DefaultTyping类型	能反序列化的属性
JAVA_LANG_OBJECT	属性的类型为Object
OBJECT_AND_NON_CONCRETE	属性的类型为Object、Interface、AbstractClass
NON_CONCRETE_AND_ARRAYS	属性的类型为Object、Interface、AbstractClass、Array
NON_FINAL	所有除了声明为final之外的属性

**enableDefaultTyping()**默认无参数设置为OBJECT_AND_NON_CONCRETE

有的不理解interface和Object在这里的区别是什么：

按CC链来举例，Transformer[]是数组，Transformer是接口，而InvokerTransformer这种就是Object

@JsonTypeInfo注解

和DefaultTyping功能类似，JsonTypeInfo是直接注解字段，达到相同的功能

比如在需要序列化和反序列化的对象内，标记Object字段：

public class Person {  
    public int age;  
    public String name;  
    @JsonTypeInfo(use = JsonTypeInfo.Id.NONE)  
    public Object object;  
  
	getter...setter...
}

以下两种注解能达到反序列化

JsonTypeInfo.Id.CLASS
JsonTypeInfo. Id. MINIMAL_CLASS

比如注解为@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS)

序列化出来的json字符如下：

1	{"age":6,"name":"drunkbaby","object":{"@class":"com.drunkbaby.Hacker","skill":"hiphop"}}

反序列化当然也能按照指定的类进行反序列化

注解为@JsonTypeInfo(use = JsonTypeInfo. Id. MINIMAL_CLASS)时，用 @c 替代了 @class，就是一个简单的缩短，和JsonTypeInfo.Id.CLASS作用相同

1	{"age":6,"name":"drunkbaby","object":{"@c":"com.drunkbaby.Hacker","skill":"hiphop"}}

总结

反序列化条件

达到以下任意一个条件，可以反序列化指定类：

开启了enableDefaultTyping()四个的任意一个设置，不过不同设置能反序列化的范围不同，trick也不同（不过范围最小的JAVA_LANG_OBJECT都够用）
使用了@JsonTypeInfo注解字段，注解值为JsonTypeInfo.Id.CLASS或者JsonTypeInfo. Id. MINIMAL_CLASS

反序列化json格式

当然，你也能观察到不同的指定方式，json的格式不同。比如enableDefaultTyping()设置后序列化出来的字符串，并没有@符号，而是用[]包裹了

enableDefaultTyping对应json格式：

1 2	// 设置JAVA_LANG_OBJECT {"age":6,"name":"mi1k7ea","object":["com.mi1k7ea.Hacker",{"skill":"Jackson"}]}

@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS)

1	{"age":6,"name":"drunkbaby","object":{"@class":"com.drunkbaby.Hacker","skill":"hiphop"}}

@JsonTypeInfo(use = JsonTypeInfo. Id. MINIMAL_CLASS)

1	{"age":6,"name":"drunkbaby","object":{"@c":"com.drunkbaby.Hacker","skill":"hiphop"}}

反序列化入口

反序列化的入口为以下两个的一种：

JsonFactory.createParser
objectMapper.readValue

OK，下面看看反序列化的过程，到底怎么反序列化的

调试

调试代码

这里就只调试开启了enableDefaultTyping()的case，注解的方式过程也差不多

Sex接口：

public interface Sex {
    public void setSex(int sex);
    public int getSex();
}

MySex类：

public class MySex implements Sex {
    int sex;
    public MySex() {
        System.out.println("MySex构造函数");
    }


    public int getSex() {
        System.out.println("MySex.getSex");
        return sex;
    }

    public void setSex(int sex) {
        System.out.println("MySex.setSex");
        this.sex = sex;
    }
}

Person类：

public class Person {
    public Person(){
        System.out.println("Person Constructor");
    }
    private String param1;
    private Sex sex;
    
    public String getParam1() {
        System.out.println("getParam1");
        return param1;
    }
    public void setParam1(String param1) {
        System.out.println("setParam1");
        this.param1 = param1;
    }
    public Sex getSex() {
        System.out.println("getSex");
        return sex;
    }
    public void setSex(Sex sex) {
        System.out.println("setSex");
        this.sex = sex;
    }
}

jacksoncase主类：

public class jacksoncase {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.enableDefaultTyping();

        String json = "{\"param1\":\"aaa\",\"sex\":[\"org.exploit.othercase.jackson.MySex\",{\"sex\":1}]}";
        Person p2 = mapper.readValue(json, Person.class);
        System.out.println(p2);
    }
}