使用jackson对类的属性按要求序列化和反序列化@JsonDeserialize与@JsonSerialize及手动注册moudle,序列化反序列化指定别名

注解方式使用demo

@JsonDeserialize(using= LocalDateTimeJsonDeserializer.class)
@JsonSerialize(using= LocalDateTimeJsonSerializer.class)
private LocalDateTime time;

@JsonDeserialize反序列化时对应的字段的解析

在反序列化json字符串的时候,对被注解的字段按照要求的格式去解析为要求的类型

demo中Test类只有一个time属性

String str = """{"time":"2020-08-08 12:12:12"}"""
Test test = objectMapper.readValue(str,Test.class)

package com.fchan.layui.service;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import lombok.Data;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@Data
public class LocalDateTimeJsonDeserializer extends JsonDeserializer<LocalDateTime> {

    private final DateTimeFormatter dateTimeFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    @Override
    public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        if(!StringUtils.isEmpty(p)){
            return LocalDateTime.parse(p.getText(),dateTimeFormat);
        }
        return null;
    }
}

@JsonSerialize

demo将Date类型的属性在序列化的时候变成时间戳

package com.chan.wechatshop.utils.serializer;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

import java.io.IOException;
import java.util.Date;

public class Date2LongSerializer extends JsonSerializer<Date> {

    @Override
    public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeNumber(date.getTime() / 1000);
    }
}

Jackson的ObjectMapper手动注册module设置序列化和反序列化时的需求

package com.fchan.layui.service;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class JSONUtils {
    private static ObjectMapper objectMapper = new ObjectMapper();

    private static final String STANDARD_PATTERN = "yyyy-MM-dd HH:mm:ss";
    private static final String DATE_PATTERN = "yyyy-MM-dd";
    private static final String TIME_PATTERN = "HH:mm:ss";

    static {

        //设置java.util.Date时间类的序列化以及反序列化的格式
        objectMapper.setDateFormat(new SimpleDateFormat(STANDARD_PATTERN));

        // 初始化JavaTimeModule
        JavaTimeModule javaTimeModule = new JavaTimeModule();

        //处理LocalDateTime
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(STANDARD_PATTERN);
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(dateTimeFormatter));
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(dateTimeFormatter));

        //处理LocalDate
        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(DATE_PATTERN);
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(dateFormatter));
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(dateFormatter));

        //处理LocalTime
        DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern(TIME_PATTERN);
        javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(timeFormatter));
        javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(timeFormatter));

        //注册时间模块, 支持支持jsr310, 即新的时间类(java.time包下的时间类)
        objectMapper.registerModule(javaTimeModule);

        // 包含所有字段
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);

        // 在序列化一个空对象时时不抛出异常
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);

        // 忽略反序列化时在json字符串中存在, 但在java对象中不存在的属性
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    }

}

Jackson序列化和反序列化忽略字段

设置Jackson序列化时只包含不为空的字段

new ObjectMapper().setSerializationInclusion(Include.NON_NULL);

设置在反序列化时忽略在JSON字符串中存在，而在Java中不存在的属性

new ObjectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

Jackson序列化时忽略特定字段的方式

方式一：FilterProvider

a)在需要忽略某些字段的class上添加@JsonFilter("fieldFilter")

b)ObjectMapper设置过滤器

FilterProvider filterProvider = new SimpleFilterProvider();

SimpleBeanPropertyFilter fieldFilter = SimpleBeanPropertyFilter().serializeAllExcept("name");
filterProvider.addFilter("fieldFilter");
new ObjectMapper.setFilters(filterProvider );

方式二：使用@JsonIgnore

在需要忽略的字段上标注注解@JsonIgnore,在序列化时即可忽略该字段

序列化反序列化指定别名

public class Cat {
  @JsonProperty("fn") // 定义了一个更精简的别名
  public String firstName;
}

序列化：

{"fn": "杨XX"}

反序列化：
这个时候要注意原来的属性名已经无法再反序列化的时候拿到值了，传递给后端的json对象中该属性要用别名

// 请求参数_1：{"fn": "456"}，后端成功解析。