背景

Spring默认的JSON序列化工具使用的是jackson，GitHub项目地址: 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("zhangsan@163.com")
                .build();

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