ObjectMapper objectMapper = new ObjectMapper();
Copy

String sam = objectMapper.writeValueAsString(new Person(1, "Sam", null));
Copy

objectMapper.readValue("{\"id\": 1, \"name\":\"Sam\",\"parent\":null}", Person.class);
Copy

class Person {
    int id;
    String name;
    public Person parent;

    public String getName() {
        return this.name;
    }
}
Copy

// {"n": "Sam"}
String name;
public String getN() {
    return this.name;
}
Copy

// {"name": "Sam"}
public String name;
public String getName() {
    return this.name + "!!!";
}
Copy

Map<String, String> xx = mapper.readValue(s, new TypeReference<Map<String,String>>() {});
Copy

// {"myName": "Sam"}
@JsonProperty("myName")
private String name;
Copy

// {"age": "11"}
@JsonIgnore
public String name;
public int age
Copy

// {"id": 1, "name": "Sam"}
class Person {
    public String name;
}
Copy

// {"id": 1, "name": "Sam"}
@JsonIgnoreProperties(ignoreUnknown = true)
class Person {
    public String name;
}
Copy

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Copy

// {"firstName": "Sam"}
String firstName;
Copy

// {"first-name": "Sam"}
@JsonNaming(
    value = PropertyNamingStrategy.KebabCaseStrategy.class)
String firstName;
Copy

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.KEBAB_CASE);
Copy

// {"type": 0}
// {"type": "A"}
// 上面两种json都可以反序列化成功
class Person {
    public Type type;
}
enum Type {
    A,
    B
}
Copy

objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_INDEX, true);
Copy

@Getter
@Setter
class TimeSpec{
    java.util.Date utilDate;
    Date sqlDate;
    Timestamp sqlTimestamp;
    Instant instant;
    LocalDate localDate;
    LocalDateTime localDateTime;
    ZonedDateTime zonedDateTime;
}
Copy

{
    "utilDate":1679973942379,
    "sqlDate":1679973942379,
    "sqlTimestamp":1679973942379,
    "instant":{
        "epochSecond":1679973942,
        "nano":379000000
    },
    "localDate":{
        "year":2023,
        "month":"MARCH",
        "monthValue":3,
        "dayOfMonth":28,
        "chronology":{
            "id":"ISO",
            "calendarType":"iso8601"
        },
        "era":"CE",
        "dayOfYear":87,
        "dayOfWeek":"TUESDAY",
        "leapYear":false
    },
    "localDateTime":{
        "year":2023,
        "month":"MARCH",
        "nano":379000000,
        "monthValue":3,
        "dayOfMonth":28,
        "hour":3,
        "minute":25,
        "second":42,
        "dayOfYear":87,
        "dayOfWeek":"TUESDAY",
        "chronology":{
            "id":"ISO",
            "calendarType":"iso8601"
        }
    },
    "zonedDateTime":{
        "offset":{
            "totalSeconds":0,
            "id":"Z",
            "rules":{
                "fixedOffset":true,
                "transitions":[
                    
                ],
                "transitionRules":[
                    
                ]
            }
        },
        "zone":{
            "id":"UTC",
            "rules":{
                "fixedOffset":true,
                "transitions":[
                    
                ],
                "transitionRules":[
                    
                ]
            }
        },
        "year":2023,
        "month":"MARCH",
        "nano":379000000,
        "monthValue":3,
        "dayOfMonth":28,
        "hour":3,
        "minute":25,
        "second":42,
        "dayOfYear":87,
        "dayOfWeek":"TUESDAY",
        "chronology":{
            "id":"ISO",
            "calendarType":"iso8601"
        }
    }
}
Copy

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
    <version>${jackson-version}</version>
</dependency>
Copy

objectMapper.registerModule(new JavaTimeModule());
Copy

{
    "utilDate":1679974795838,
    "sqlDate":1679974795838,
    "sqlTimestamp":1679974795838,
    "instant":1679974795.838000000,
    "localDate":[2023,3,28],
    "localDateTime":[2023,3,28,3,39,55,838000000],
    "zonedDateTime":1679974795.838000000
}
Copy

objectMapper.registerModule(new JavaTimeModule());
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

{
    "utilDate":"2023-03-28T03:44:38.889+0000",
    "sqlDate":"2023-03-28",
    "sqlTimestamp":"2023-03-28T03:44:38.889+0000",
    "instant":"2023-03-28T03:44:38.889Z",
    "localDate":"2023-03-28",
    "localDateTime":"2023-03-28T03:44:38.889",
    "zonedDateTime":"2023-03-28T03:44:38.889Z"
}
Copy

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ssZ")
ZonedDateTime zonedDateTime;
Copy

@JsonFormat(shape = JsonFormat.Shape.STRING)
public int Age;
Copy

class Person {
    protected int age;
    public String name;
}

class Woman extends Person {
    public int realAge;
}

class Man extends Person {
    public String realName;
}
Copy

Woman woman = mapper.readValue("{\"name\":\"www\",\"realAge\":12}", Woman.class);
Copy

@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, property = "class")
class Person {
    protected int age;
    public String name;
}
// {"class":"com.jackson.Woman","name":"www","realAge":12}
Copy

// sex = female的会按照Woman类型反序列化， sex = male的会按照Man类型
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME,  property = "sex")
@JsonSubTypes({
        @JsonSubTypes.Type(value = Woman.class, name = "female"),
        @JsonSubTypes.Type(value = Man.class, name = "male")})
class Person {
    protected String sex;
    protected int age;
    public String name;
}

class Woman extends Person {
    public int realAge;
    {
        sex = "female";
    }
}

class Man extends Person {
    public String realName;
    {
        sex = "male";
    }
}
Copy

class X {
    @JsonSerialize(using = MyMapSer.class)
    @JsonDeserialize(using = MyMapDes.class)
    public Map<String, String> m;
}
Copy

// {"m":[{"key":"k1","value":"v1"},{"key":"k2","value":"v2"},{"key":"k3","value":"v3"}]}
class MyMapSer extends JsonSerializer<Map<String, String>> {

    @Override
    public void serialize(Map<String, String> value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeStartArray();
        for (Map.Entry<String, String> entry : value.entrySet()) {
            gen.writeStartObject();
            gen.writeStringField("key", entry.getKey());
            gen.writeStringField("value", entry.getValue());
            gen.writeEndObject();
        }
        gen.writeEndArray();
    }
}
Copy

// {"m":[{"key":"k1","value":"v1"},{"key":"k2","value":"v2"},{"key":"k3","value":"v3"}]}
class MyMapDes extends JsonDeserializer<Map<String, String>> {

    @Override
    public Map<String, String> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        ArrayNode root = p.readValueAsTree();
        Map<String, String> res = new LinkedHashMap<>();
        for (JsonNode jsonNode : root) {
            res.put(jsonNode.get("key").textValue(), jsonNode.get("value").textValue());
        }
        return res;
    }
}
Copy

protected final ObjectNode deserializeObject(JsonParser p, DeserializationContext ctxt,
        final JsonNodeFactory nodeFactory) throws IOException
{
    final ObjectNode node = nodeFactory.objectNode();// node = {} 一开始 空的壳子

    // nextFieldName 需要保证token是FIELD_NAME，然后去获取这个name。ptr向下寻找到"，然后找到俩"之间的字符串就是这个key
    String key = p.nextFieldName(); 
    for (; key != null; key = p.nextFieldName()) {
        JsonNode value;
        // next操作都会向后移动，此时token指向VALUE了，根据形态可以判断出是哪一种value
        // 例如双引号是字符串有-号或0到9是数字，{是另一个对象，[则是数组等
        JsonToken t = p.nextToken();
        if (t == null) { // can this ever occur?
            t = JsonToken.NOT_AVAILABLE; // can this ever occur?
        }
        switch (t.id()) {
        // 第三次以parent进来，此时token是对象的start(也就是{)，那就递归解析对象
        // 这个内部对象解析完成后，ptr指向最后一个大括号了，再次调用next会close，并返回null，循环结束
        case JsonTokenId.ID_START_OBJECT:
            value = deserializeObject(p, ctxt, nodeFactory);
            break;
        case JsonTokenId.ID_START_ARRAY:
            value = deserializeArray(p, ctxt, nodeFactory);
            break;
        case JsonTokenId.ID_EMBEDDED_OBJECT:
            value = _fromEmbedded(p, ctxt, nodeFactory);
            break;
        // 例如一开始的Sam是字符串，匹配这个case，getText会找出Sam，并将ptr指向Sam后的逗号
        // 然后循环继续，去拿nextFieldName，skip逗号空格，拿到age
        case JsonTokenId.ID_STRING:
            value = nodeFactory.textNode(p.getText());
            break;
        // 第二次age进来匹配INT数字，用_fromInt转换，同时移动ptr到10后的逗号
        // 然后继续循环找到parent这个key
        case JsonTokenId.ID_NUMBER_INT:
            value = _fromInt(p, ctxt, nodeFactory);
            break;
        case JsonTokenId.ID_TRUE:
            value = nodeFactory.booleanNode(true);
            break;
        case JsonTokenId.ID_FALSE:
            value = nodeFactory.booleanNode(false);
            break;
        case JsonTokenId.ID_NULL:
            value = nodeFactory.nullNode();
            break;
        default:
            value = deserializeAny(p, ctxt, nodeFactory);
        }
        JsonNode old = node.replace(key, value);
        if (old != null) {
            _handleDuplicateField(p, ctxt, nodeFactory,
                    key, node, old, value);
        }
    }
    return node;
}
Copy

@Override
public final JsonToken nextToken() throws IOException
{
    if (_currToken == JsonToken.FIELD_NAME) {
        return _nextAfterName();
    }
    // But if we didn't already have a name, and (partially?) decode number,
    // need to ensure no numeric information is leaked
    _numTypesValid = NR_UNKNOWN;
    if (_tokenIncomplete) {
        _skipString(); // only strings can be partial
    }
    // 跳过空格等字符后的下一个字符
    int i = _skipWSOrEnd();
    if (i < 0) { // end-of-input
    // Should actually close/release things
        // like input source, symbol table and recyclable buffers now.
        close();
        return (_currToken = null);
    }
    // clear any data retained so far
    _binaryValue = null;

    // Closing scope?
    if (i == INT_RBRACKET || i == INT_RCURLY) {
        _closeScope(i);
        return _currToken;
    }

    // Nope: do we then expect a comma?
    if (_parsingContext.expectComma()) {
        // 跳过逗号
        i = _skipComma(i);

        // Was that a trailing comma?
        if ((_features & FEAT_MASK_TRAILING_COMMA) != 0) {
            if ((i == INT_RBRACKET) || (i == INT_RCURLY)) {
                _closeScope(i);
                return _currToken;
            }
        }
    }
    /* And should we now have a name? Always true for Object contexts, since
     * the intermediate 'expect-value' state is never retained.
     */
    boolean inObject = _parsingContext.inObject();
    if (inObject) {
        // First, field name itself:
        _updateNameLocation();
        String name = (i == INT_QUOTE) ? _parseName() : _handleOddName(i);
        _parsingContext.setCurrentName(name);
        _currToken = JsonToken.FIELD_NAME;
        i = _skipColon();
    }
    _updateLocation();

    // Ok: we must have a value... what is it?

    JsonToken t;

    switch (i) {
    case '"':
            _tokenIncomplete = true;
        t = JsonToken.VALUE_STRING;
        break;
    case '[':
        if (!inObject) {
            _parsingContext = _parsingContext.createChildArrayContext(_tokenInputRow, _tokenInputCol);
        }
        t = JsonToken.START_ARRAY;
        break;
    case '{':
        if (!inObject) {
            _parsingContext = _parsingContext.createChildObjectContext(_tokenInputRow, _tokenInputCol);
        }
        t = JsonToken.START_OBJECT;
        break;
    case '}':
        // Error: } is not valid at this point; valid closers have
        // been handled earlier
        _reportUnexpectedChar(i, "expected a value");
    case 't':
        _matchTrue();
        t = JsonToken.VALUE_TRUE;
        break;
    case 'f':
        _matchFalse();
        t = JsonToken.VALUE_FALSE;
        break;
    case 'n':
        _matchNull();
        t = JsonToken.VALUE_NULL;
        break;
    case '-':
        /* Should we have separate handling for plus? Although
         * it is not allowed per se, it may be erroneously used,
         * and could be indicate by a more specific error message.
     */
    t = _parseNegNumber();
        break;
    case '.': // [core#61]]
        t = _parseFloatThatStartsWithPeriod();
        break;
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
        t = _parsePosNumber(i);
        break;
    default:
        t = _handleOddValue(i);
        break;
    }
    if (inObject) {
        _nextToken = t;
        return _currToken;
    }
    _currToken = t;
    return t;
}
Copy

String s2 = "{\"a\" : 1}";
Map<String, String> xx = mapper.readValue(s2, Map.class); // Map<String,String>.class 没有这种写法，且就算有，因为擦除的原因也等于没写。
String v = xx.get("a");
Copy

String s2 = "{\"a\" : [1]}";
Map<String, int[]> xx = mapper.readValue(s2, new HashMap<String, int[]>(){}.getClass());
int[] v = xx.get("a");
Copy

String s2 = "{\"a\" : [1]}";
Map<String, int[]> xx = mapper.readValue(s2, new TypeReference<Map<String, int[]>>(){});
int[] v = xx.get("a");
Copy