【jackson】自定义字段注解完成序列化逻辑

目录

  • 背景
  • 本文开发环境介绍
  • 新建一个注解
  • 新建一个JavaBean
  • 新建一个JsonSerializer
  • 新建一个AnnotationIntrospector
  • 单元测试
  • 总结

背景

Spring默认的JSON序列化工具使用的是jacksonGitHub项目地址: https://github.com/FasterXML/jackson

我们在处理前后端接口交互的时候,可能需要实现各种各样的个性化需求,这篇文章主要介绍自定义注解,然后对特定字段进行业务逻辑处理。

本文开发环境介绍

开发依赖 版本
Spring Boot 3.1.2
JDK 17

新建一个注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@JsonSerialize(using = PrintFieldJsonSerializer.class)
public @interface PrintField {

    Type rule() default Type.TYPE_1;

    enum Type {
        TYPE_1, TYPE_2
    }
}

新建一个JavaBean

在字段上使用自定义注解

import lombok.Builder;
import lombok.Data;

/**
 * @author tangheng
 */
@Data
@Builder
public class DemoPerson {

    @PrintField(rule = PrintField.Type.TYPE_1)
    private String name;
    @PrintField(rule = PrintField.Type.TYPE_2)
    private String email;
}

新建一个JsonSerializer

用来做自定义的业务逻辑

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;

@Slf4j
@RequiredArgsConstructor
public class PrintFieldJsonSerializer extends JsonSerializer<String> {

    private final PrintField.Type rule;

    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        if(StringUtils.isBlank(value)) {
            return;
        }
        switch (rule) {
            case TYPE_1:
                log.info("hello, value: {}", value);
                break;
            default:
                log.info("rule: {}, value: {}", rule, value);
                break;
        }
        gen.writeString(value);
    }
}

新建一个AnnotationIntrospector

import com.fasterxml.jackson.core.Version;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.introspect.Annotated;

import java.lang.annotation.Annotation;

public class PrintFieldAnnotationIntrospector extends AnnotationIntrospector {

    @Override
    public Version version() {
        return Version.unknownVersion();
    }

    @Override
    public Object findSerializer(Annotated a) {
        PrintField ann = _findAnnotation(a, PrintField.class);
        if (ann != null) {
            return new PrintFieldJsonSerializer(ann.rule());
        }
        return null;
    }

    @Override
    public boolean isAnnotationBundle(Annotation ann) {
        if (PrintField.class.isAssignableFrom(ann.getClass())) {
            return true;
        }
        return false;
    }
}
  • 这一步很关键,利用jackson的Introspector机制,起到承上启下的作用
  • 判断字段上有自定义注解,然后使用自定义的JsonSerializer
  • 这样就把整个事情串起来了

单元测试

class PrintFieldJsonSerializerTest extends JsonSpringbootTestBase {

    private ObjectMapper objectMapper = new ObjectMapper();

    @SneakyThrows
    @Test
    void serialize() {
        objectMapper.setAnnotationIntrospector(new PrintFieldAnnotationIntrospector());

        DemoPerson demoPerson = DemoPerson.builder()
                .name("zhangsan")
                .email("[email protected]")
                .build();

        String testResult = objectMapper.writeValueAsString(demoPerson);
        log.info("testResult: {}", testResult);
        assertTrue(StringUtils.isNotBlank(testResult));
    }
}

单元测试结果截图
【jackson】自定义字段注解完成序列化逻辑_第1张图片

总结

  • 实现一个需求的道路有千万条,对于一个有追求的程序员,研究源码,找到一条最精炼的路,用最简洁的方式实现目标,在可扩展性、可维护性方面都较优
  • 有需求的时候,不要着急写代码,研究下源码,可以帮助我们优雅的达到目的
  • 也许研究源码的时间远远大于写代码的时候,但收获和成就感还是很满足的
  • 即使最终仅用用几行代码实现需求,但一个优秀的程序员从来不是以代码的行数来衡量的
  • jackson的反序列化可以参考同样的原理来实现

你可能感兴趣的:(spring,jackson,json,序列化,反序列化,springboot)