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

曾经终败给现在 2023-10-14 18:26 83阅读 0赞

#### 目录 ####

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

## 背景 ##

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

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

## 本文开发环境介绍 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">开发依赖</th> 
   <th align="left">版本</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Spring Boot</td> 
   <td align="left">3.1.2</td> 
  </tr> 
  <tr> 
   <td align="left">JDK</td> 
   <td align="left">17</td> 
  </tr> 
 </tbody> 
</table>

## 新建一个注解 ##

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));
        }
    }

单元测试结果截图  
![在这里插入图片描述][1ca6bdc7da114e60bdf37dd094ddb094.png]

## 总结 ##

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

[1ca6bdc7da114e60bdf37dd094ddb094.png]: https://img-blog.csdnimg.cn/1ca6bdc7da114e60bdf37dd094ddb094.png