自定义注解实现数据序列化时进行数据脱敏(基于springboot默认jackjson)、消息转换器HttpMessageConverter

消息转换器 HttpMessageConverter

消息转化器的作用

将请求报文转化为Java对象

将Java对象转化为响应报文

消息转换器接口

public interface HttpMessageConverter<T> {

	boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);

	boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

	List<MediaType> getSupportedMediaTypes();

	default List<MediaType> getSupportedMediaTypes(Class<?> clazz) {
		return (canRead(clazz, null) || canWrite(clazz, null) ?
				getSupportedMediaTypes() : Collections.emptyList());
	}

	T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;

	void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;

}

转换器加载流程

消息转换器是在项目启动的时候通过WebMvcConfigurationSupport进行加载，当getMessageConverters()被调用的时候会通过configureMessageConverters()、addDefaultHttpMessageConverters()和extendMessageConverters()三个方法进行初始话消息转换器。生成的消息转换器放在List<HttpMessageConverter<?>> messageConverters集合中

	protected final List<HttpMessageConverter<?>> getMessageConverters() {
        if (this.messageConverters == null) {
            this.messageConverters = new ArrayList();
            // 加载委托给WebMvcConfigurer类型的Bean
            this.configureMessageConverters(this.messageConverters);
            if (this.messageConverters.isEmpty()) {
                // 加载默认的转换器
                this.addDefaultHttpMessageConverters(this.messageConverters);
            }
            // 加载扩展消息转换器
            this.extendMessageConverters(this.messageConverters);
        }
        return this.messageConverters;
    }

自定义消息转换器参考下面

（1）直接注入Bean 的方式替换

（2）实现 WebMvcConfigurer#extendMessageConverters 接口方法

fastjson与jackjson

问题

在springboot中使用fastjson的@jsonField无效

原因：在springboot默认有json（jackjson）解析工具，所以使用fastjson不会生效

解决方案替换默认的解析工具（笔者不推荐，这里根据自己项目决定）

fastjson替换默认的jackjson

第一种方法bean方法

package com.anson.config;

import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

@Configuration
public class WebConfig {

    /**
     * @Author anson
     * @Description 配置消息转换器
     * @Date: 2019-12-8 11:23:33
     * @version: 1.0
     * new HttpMessageConverters(true, converters);
     * 一定要设为true才能替换否则不会替换
     * @return 返回一个消息转换的bean
     */
    @Bean
    public HttpMessageConverters fastJsonMessageConverters() {
        List<HttpMessageConverter<?>> converters = new ArrayList<>();
        //需要定义一个convert转换消息的对象;
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
        //添加fastJson的配置信息;
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
        //全局时间配置
        fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");
        fastJsonConfig.setCharset(Charset.forName("UTF-8"));
        //处理中文乱码问题
        List<MediaType> fastMediaTypes = new ArrayList<>();
        fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        //在convert中添加配置信息.
        fastConverter.setSupportedMediaTypes(fastMediaTypes);
        fastConverter.setFastJsonConfig(fastJsonConfig);

        converters.add(0, fastConverter);
        return new HttpMessageConverters(converters);
    }
}

第二种方法实现webMvcConfigurer

@Configuration
public class WebConfigure implements WebMvcConfigurer{

    /**
     * 配置消息转换器
     * @param converters
     */
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
       //需要定义一个convert转换消息的对象;
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
        //添加fastJson的配置信息;
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
        //全局时间配置
        fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");
        fastJsonConfig.setCharset(Charset.forName("UTF-8"));
        //处理中文乱码问题
        List<MediaType> fastMediaTypes = new ArrayList<>();
        fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        //在convert中添加配置信息.
        fastConverter.setSupportedMediaTypes(fastMediaTypes);
        fastConverter.setFastJsonConfig(fastJsonConfig);
        converters.add(0,fastConverter);
    }
}

jackjson注解实现原理

参考：https://blog.csdn.net/qq_18515155/article/details/128891441?spm=1001.2014.3001.5501

这里以Jackson中常用的@JsonFormat注解为例，目标就是将Company对象序列化。

public class Company {
    /**
     * 开张时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date openDate;

    public Date getOpenDate() {
        return openDate;
    }

    public void setOpenDate(Date openDate) {
        this.openDate = openDate;
    }
}

public class Test {
    public static void main(String[] args) {
        Company company = new Company();
        company.setOpenDate(new Date());

        ObjectMapper objectMapper = new ObjectMapper();

        String s;
        try {
            s = objectMapper.writeValueAsString(company);
            System.out.println(s);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

执行结果如下：
{"openDate":"2023-02-05"}

处理过程简述：

寻找合适的序列化器

序列化器二次处理（主要用于传递属性元信息）

执行序列化

详细如下：

一·寻找合适的序列化器



（1）根据当前数据类型从缓存中获取对应的序列化器

（2）如果获取不到，则创建序列化器

（3）根据Company上的注解获取序列化器（Company上没有注解）

（4）根据当前的注解内省器获取能够处理 步骤3 拿到的注解的序列化器（默认的注解内省器是JacksonAnnotationIntrospector，对于注解@JsonSerialize则返回注解指定的序列化器，对于注解JsonRawValue则返回RawSerializer）

（5）如果获取不到，再根据是否实现了JsonSerializable接口或者标注了 @JsonValue注解获取对应的序列化器（当前Company都没有）

（6）如果没有，就只能创建通用的对象处理器BeanSerialzer

（7）在创建BeanSerialzer之前，需要先去找到对象的属性元信息

（8）为对象的属性（Compnay.openDate）找到合适的序列化器（类似上面的步骤，一步一步找，这里最终没有找对于openDate属性的序列化器）

（9）把属性元信息设置到对象元信息里，然后new一个BeanSerialzer并返回

（10）拿到返回的序列化器以后，如果该序列化器实现了ContextualSerializer接口，则调用它的createContextual方法进行二次处理，并返回序列化器

二.序列化器二次处理（主要用于传递属性元信息）

步骤10即为序列化器二次处理：当找到合适的序列化器以后，还需要根据是否这个序列化器实现了ContextualSerializer接口，该接口声明了方法JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property)

该接口可以拿到属性的元信息，如属性上的注解信息，根据元信息可以做一些二次处理，然后再返回序列化器，再用这个返回的序列化器做序列化处理。

三.执行序列化



(1)序列化对象

(2)序列化对象的字段

(3)动态获取能处理字段的序列化器

(4)检索内置的序列化器集合

(5)根据类型从内置的序列化器集合获取对应的序列化器，即根据openDate的类型Date.class获取到DateSerializer

(6)序列化器二次处理

(7)设置需要传递到序列化器中的上下文信息

(8)将openDate上的JsonFormat注解的pattern字段值传递到DateSerializer，用来在序列化openDate时知道应该转为哪种时间格式

(9)调用DateSerializer.serialze进行字段序列化

jackjson实现数据脱敏

脱敏即是对数据的部分信息用脱敏符号（*）处理。

自定义注解：

package com.chinatower.platform.awh.framework;

import com.chinatower.platform.awh.framework.enums.SentitiveFieldEnum;

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

/**
 * @Description :
 * @Date : 2023/5/23
 * @Author :
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface SensitiveField {
    SentitiveFieldEnum type();
}

枚举类：

package com.chinatower.platform.awh.framework.enums;

/**
 * @Description :
 * @Date : 2023/5/23
 * @Author :
 */
public enum  SentitiveFieldEnum {
    /**
     * 身份证号
     */
    ID_CARD,
    /**
     * 姓名
     */
    NAME,
    /**
     * 手机号
     */
    PHONE,
}

工具类：

package com.chinatower.platform.awh.framework.config;

import cn.hutool.core.util.StrUtil;
import org.apache.commons.lang3.StringUtils;

/**
 * @Description :
 * @Date : 2023/5/23
 * @Author :
 */
public class SensitiveDataUtils {
    public static String encryptCard(String card){
        String left = StringUtils.left(card, 1);
        return StringUtils.rightPad(left,card.length(),"*");
    }
    public static String encryptPhone(String card){
        String left = StringUtils.left(card, 2);
        return StringUtils.rightPad(left,card.length(),"*");
    }
    public static String encryptName(String card){
        String left = StringUtils.left(card, 3);
        return StringUtils.rightPad(left,card.length(),"*");
    }
}

自定义处理注解的序列化器

package com.chinatower.platform.awh.framework.config;

import com.chinatower.platform.awh.framework.SensitiveField;
import com.chinatower.platform.awh.framework.enums.SentitiveFieldEnum;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;

import java.io.IOException;

/**
 * @Description :
 * @Date : 2023/5/23
 * @Author :
 */
public class SensitiveFieldSerializer extends JsonSerializer<String> implements ContextualSerializer {
    private  SentitiveFieldEnum eum ;
    public SensitiveFieldSerializer(){}
    public SensitiveFieldSerializer(SentitiveFieldEnum enu){this.eum = enu;}

    @Override
    public void serialize(String s, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {

        SentitiveFieldEnum sentitiveFieldEnum = eum;
        if (sentitiveFieldEnum == null){
            return;
        }
        switch (sentitiveFieldEnum){
            case ID_CARD:
                s=SensitiveDataUtils.encryptCard(s);
                break;
            case NAME:
                s=SensitiveDataUtils.encryptName(s);
                break;
            case PHONE:
                s=SensitiveDataUtils.encryptPhone(s);
                break;
            default:break;

        }
        jsonGenerator.writeObject(s);
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
        //获取注解
        System.out.println(1);
        if (beanProperty != null){
            SensitiveField annotation = beanProperty.getAnnotation(SensitiveField.class);
            SentitiveFieldEnum type = annotation.type();
            return new SensitiveFieldSerializer(type);
        }
        //返回处理枚举
        System.out.println(2);
        return serializerProvider.findNullValueSerializer(null);
    }
}

自定义注解内省器

package com.chinatower.platform.awh.framework;

import com.chinatower.platform.awh.framework.config.SensitiveFieldSerializer;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.introspect.NopAnnotationIntrospector;

/**
 * @Description :
 * @Date : 2023/5/23
 * @Author :
 */
public class SensitiveFieldAnnotationIntrospector extends NopAnnotationIntrospector {
    @Override
    public Object findSerializer(Annotated am) {
        SensitiveField annotation = am.getAnnotation(SensitiveField.class);
        if (annotation !=null){
            return SensitiveFieldSerializer.class;
        }
        return super.findSerializer(am);
    }
}

Jackson序列化配置

package com.chinatower.platform.awh.framework.config;

import com.chinatower.platform.awh.framework.SensitiveFieldAnnotationIntrospector;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

/**
 * @Description :
 * @Date : 2023/5/23
 * @Author :
 */
@Configuration
public class JacksonConfig {

    @Bean
    public SensitiveFieldAnnotationIntrospector sensitiveFieldAnnotationIntrospector(){
        return new SensitiveFieldAnnotationIntrospector();
    }

    @Bean
    public SensitiveFieldSerializer sensitiveFieldSerializer(){
        return new SensitiveFieldSerializer();
    }

    @Bean
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder, SensitiveFieldAnnotationIntrospector introspector){
        ObjectMapper mapper = builder.createXmlMapper(false).build();
        AnnotationIntrospector annotationIntrospector = mapper.getSerializationConfig().getAnnotationIntrospector();
        AnnotationIntrospector pair = AnnotationIntrospector.pair(annotationIntrospector, introspector);
        mapper.setAnnotationIntrospector(pair);
        return mapper;
    }
}

springboot的bean是单例模式

测试

/ 定义一个对象，字段标有注解
@Data
public class User {
    @SensitiveField(type = SensitiveFieldTypeEnum.NAME)
    private String name;
    @SensitiveField(type = SensitiveFieldTypeEnum.PHONE)
    private String phone;
    private Integer age;
}

@GetMapping("/get")
    public User get() {
        User user = new User();
        user.setAge(20);
        user.setName("徐小莫");
        user.setPhone("18211843612");
        return user;
    }
执行结果：
{
  "name": "***",
  "phone": "182****3672",
  "age": 20
}

代码分析：

（1）如何找到处理自定义注解的序列化器

就要通过注解內省器找到合适的序列化器。

所以我们自定义了一个注解內省器，并把它加入到了当前Jackson注解內省器集合里：

        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        AnnotationIntrospector annotationIntrospector = objectMapper.getSerializationConfig().getAnnotationIntrospector();
        // 将自定义注解內省器加入到Jackson注解内省器集合里，AnnotationIntrospector是双向链表结构
        AnnotationIntrospector pair = AnnotationIntrospectorPair.pair(annotationIntrospector, introspector);
        objectMapper.setAnnotationIntrospector(pair);

(2)**如何不影响已有的Jackson序列化配置 **

实际的SpringBoot项目中，对于Controller的返回数据，经常会在配置文件或者配置类进行一些Jackson的自定义配置。

如果针对当前的自定义注解序列化器新建一个ObjectMapper：

        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule simpleModule = new SimpleModule();
        SensitiveFieldSerializer sensitiveFieldSerializer = new SensitiveFieldSerializer();
        simpleModule.addSerializer(String.class, sensitiveFieldSerializer);
        objectMapper.registerModule(simpleModule);
        AnnotationIntrospector annotationIntrospector = objectMapper.getSerializationConfig().getAnnotationIntrospector();
        AnnotationIntrospector newIntro = AnnotationIntrospectorPair.pair(annotationIntrospector,new SensitiveFieldAnnotationIntrospector());
        objectMapper.setAnnotationIntrospector(newIntro);

那这个ObjectMapper不会包含原来的那些配置，因为他是一个新的对象。

要保证原来的配置生效，就需要对SpringBoot自动配置的ObjectMapper动手脚。

通过分析JacksonAutoConfiguration.class这个自动配置类

        @Bean
        JacksonAutoConfiguration.Jackson2ObjectMapperBuilderCustomizerConfiguration.StandardJackson2ObjectMapperBuilderCustomizer standardJacksonObjectMapperBuilderCustomizer(ApplicationContext applicationContext, JacksonProperties jacksonProperties) {
            return new JacksonAutoConfiguration.Jackson2ObjectMapperBuilderCustomizerConfiguration.StandardJackson2ObjectMapperBuilderCustomizer(applicationContext, jacksonProperties);
        }

        @Bean
        @Scope("prototype")
        //这个注解是多例模式
        @ConditionalOnMissingBean
        Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder(ApplicationContext applicationContext, List<Jackson2ObjectMapperBuilderCustomizer> customizers) {
            Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
            builder.applicationContext(applicationContext);
            this.customize(builder, customizers);
            return builder;
        }
        @Bean
        @Primary
        @ConditionalOnMissingBean
       // 这个注解代表没有自定义的ObjectMqpper bean对象时才会在这里创建
        ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
            return builder.createXmlMapper(false).build();
        }

发现SpringBoot会将配置信息封装成Jackson2ObjectMapperBuilder，进而去创建ObjectMapper对象。

所以需要通过注入已有的Jackson2ObjectMapperBuilder对象来创建我们自己的ObjectMapper，再将自定义注解内省器加入到它的內省器集合，使我们的自定义注解序列化器生效：

    @Bean
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder, SensitiveFieldAnnotationIntrospector introspector) {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        AnnotationIntrospector annotationIntrospector = objectMapper.getSerializationConfig().getAnnotationIntrospector();
        // 将自定义注解內省器加入到Jackson注解内省器集合里，AnnotationIntrospector是双向链表结构
        AnnotationIntrospector pair = AnnotationIntrospectorPair.pair(annotationIntrospector, introspector);
        objectMapper.setAnnotationIntrospector(pair);
        return objectMapper;
    }