【深度思考】如何优雅的实现脱敏？

最近做了个脱敏的需求，要对系统中的敏感信息，如手机号、车牌号、身份证号、银行卡号等进行脱敏显示。

效果类似下面这样：

简单来说，就是对敏感信息中的某几位进行掩码显示，常见的一般是使用*。

本篇文章就来讲解下在项目中该如何优雅的实现脱敏。

1. 工具类

首先，需要明确下脱敏规则：

手机号

显示前3位和后4位，中间4位脱敏，如182****6791。
车牌号

显示前3位和后1位，其余位脱敏，如沪B0***8。
身份证号

显示前3位和后4位，其余位脱敏，如410***********0007。
银行卡号

显示前4位和后4位，其余位脱敏，并且每4位分隔，如6214 **** **** 8533。

然后，需要一个实现了以上脱敏规则的工具类，这个工具类可以使用公司统一提供的，也可以使用第三方类库的，

或者使用自己实现的。

本篇文章使用第三方类库Hutool中自带的脱敏工具类DesensitizedUtil。

如果项目中之前没有使用过Hutool，需要添加以下依赖：

xml 复制代码

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-core</artifactId>
    <version>5.8.4</version>
</dependency>

使用示例：

java 复制代码

System.out.println(DesensitizedUtil.mobilePhone("18216556791"));
System.out.println(DesensitizedUtil.carLicense("沪B08U28"));
System.out.println(DesensitizedUtil.idCardNum("410328200001010007", 3, 4));
System.out.println(DesensitizedUtil.bankCard("6214856213978533"));

输出结果：

2. 硬编码方案

所谓硬编码方案，就是在所有需要脱敏的地方都调用下上面工具类提供的方法。

这种方案的优点是简单，容易理解，能很好的评估改动影响的范围，缺点是代码耦合度高，如果涉及脱敏的接口很多，

那改动起来简直是灾难。

因此，这种方案推荐在涉及脱敏的接口很少的情况下使用，如果涉及脱敏的接口很多，推荐使用下文讲解的使用注解的方案。

3. 使用注解方案

使用注解方案，指的是接口数据在返回之前，通过执行自定义序列化器的逻辑达到脱敏的效果，

这种方案需要在字段上添加自定义注解来标识这个字段需要进行脱敏以及脱敏的规则，

优点是代码耦合度低，脱敏代码和业务代码不耦合，缺点是有一定的理解成本，不能很好的评估改动影响的范围。

那如何使用注解来实现脱敏呢？

首先，定义一个脱敏类型的枚举：

java 复制代码

/**
 * 脱敏类型
 */
public enum DesensitizeType {
    /**
     * 手机号
     */
    MOBILE_PHONE,

    /**
     * 车牌号
     */
    LICENSE_NUMBER,

    /**
     * 身份证号
     */
    ID_CARD,

    /**
     * 银行卡
     */
    BANK_CARD,

    /**
     * 自定义
     */
    CUSTOM
}

然后，定义一个脱敏的注解：

java 复制代码

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = DesensitizeSerializer.class)
public @interface Desensitize {
    /**
     * 脱敏类型
     */
    DesensitizeType type() default DesensitizeType.CUSTOM;

    /**
     * 开始位置(包含)
     */
    int startIndex() default 0;

    /**
     * 结束位置(不包含)
     */
    int endIndex() default 0;
}

上面代码中的@Target和@Retention是JDK自带的元注解，@JacksonAnnotationsInside和@JsonSerialize属于

jackson-databind下的注解，而spring-boot-starter-web下包含了jackson-databind，因此大部分项目不需要单独添加依赖：

重点看下@JsonSerialize(using = DesensitizeSerializer.class)，该行代码指定json序列化时使用自定义的

脱敏序列化类DesensitizeSerializer，其代码如下所示：

java 复制代码

/**
 * 脱敏序列化类
 */
public class DesensitizeSerializer extends JsonSerializer<String> implements ContextualSerializer {
    private DesensitizeType type;

    private Integer startIndex;

    private Integer endIndex;

    public DesensitizeSerializer() {
    }

    public DesensitizeSerializer(DesensitizeType type, Integer startIndex, Integer endIndex) {
        this.type = type;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    @Override
    public void serialize(String value, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        switch (type) {
            // 手机号脱敏
            case MOBILE_PHONE:
                jsonGenerator.writeString(DesensitizedUtil.mobilePhone(String.valueOf(value)));
                break;
            // 车牌号脱敏
            case LICENSE_NUMBER:
                jsonGenerator.writeString(DesensitizedUtil.carLicense(String.valueOf(value)));
                break;
            // 身份证号脱敏
            case ID_CARD:
                jsonGenerator.writeString(DesensitizedUtil.idCardNum(String.valueOf(value), 3, 4));
                break;
            // 银行卡脱敏
            case BANK_CARD:
                jsonGenerator.writeString(DesensitizedUtil.bankCard(String.valueOf(value)));
                break;
            // 自定义脱敏
            case CUSTOM:
                jsonGenerator.writeString(CharSequenceUtil.hide(value, startIndex, endIndex));
                break;
            default:
                break;
        }
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
        if (beanProperty != null) {
            // 判断数据类型是否为String类型
            if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
                // 获取定义的注解
                Desensitize desensitize = beanProperty.getAnnotation(Desensitize.class);
                // 为null
                if (desensitize == null) {
                    desensitize = beanProperty.getContextAnnotation(Desensitize.class);
                }
                // 不为null
                if (desensitize != null) {
                    // 创建定义的序列化类的实例并且返回，入参为注解定义的type,开始位置，结束位置。
                    return new DesensitizeSerializer(desensitize.type(), desensitize.startIndex(),
                            desensitize.endIndex());
                }
            }

            return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
        }

        return serializerProvider.findNullValueSerializer(null);
    }
}

该类实现了com.fasterxml.jackson.databind.ser.ContextualSerializer接口并重写了createContextual方法，

该方法会解析字段的类型是不是String以及字段上有没有之前自定义的注解Desensitize，如果有的话，

就返回自定义的序列化类的实例，创建实例时用到了注解中的参数。

该类还继承了com.fasterxml.jackson.databind.JsonSerializer类并重写了serialize方法，

该方法会判断脱敏的类型，执行具体的脱敏逻辑，这里用到了之前提到的脱敏工具类。

最后，新建接口进行验证：

java 复制代码

@Getter
@Setter
public class CarInfoVO {
    @Desensitize(type = DesensitizeType.LICENSE_NUMBER)
    private String licenseNumber;

    @Desensitize(type = DesensitizeType.MOBILE_PHONE)
    private String ownerMobile;

    @Desensitize(type = DesensitizeType.ID_CARD)
    private String ownerIdCard;

    @Desensitize(type = DesensitizeType.BANK_CARD)
    private String ownerBankCardNo;

    @Desensitize(type = DesensitizeType.CUSTOM, startIndex = 0, endIndex = 1)
    private String ownerName;
}

java 复制代码

@GetMapping("/car/info")
@ResponseBody
public WebResult<CarInfoVO> queryCarInfo() {
    CarInfoVO carInfoVO = new CarInfoVO();
    carInfoVO.setLicenseNumber("沪B08U28");
    carInfoVO.setOwnerMobile("18216556791");
    carInfoVO.setOwnerIdCard("410328200001010007");
    carInfoVO.setOwnerBankCardNo("6214856213978533");
    carInfoVO.setOwnerName("叶子农");

    return WebResult.success(carInfoVO);
}

输出结果：

4. 注意事项

4.1 无参构造函数不要删

上文中新建的自定义序列化类的无参构造函数表面上看没有任何调用，在IDEA中看着是下图这样的：

但千万不要手贱删除（我就手贱了，哈哈），否则会抛运行时异常：

4.2 自定义脱敏注解不生效

如果上文中提到的每一步都正常操作了，但自定义脱敏注解还是不生效：

那很可能是Spring Boot默认的消息转换器被替换成fastjson了，因为Spring Boot默认是使用jackson进行序列化的，上面的方案也是

基于jackson的，但如果项目中明确指定了使用fastjson进行序列化，那上面的自定义脱敏注解就不会生效：

java 复制代码

@Bean
public HttpMessageConverters httpMessageConverters() {
    FastJsonConfig fastJsonConfig = new FastJsonConfig();
    fastJsonConfig.setSerializerFeatures(SerializerFeature.WriteMapNullValue, SerializerFeature.BrowserCompatible);
    FastJsonHttpMessageConverter fastJsonHttpMessageConverter = new FastJsonHttpMessageConverter();
    fastJsonHttpMessageConverter.setFastJsonConfig(fastJsonConfig);
    return new HttpMessageConverters(fastJsonHttpMessageConverter);
}

此时的解决方案是新建过滤器类，实现com.alibaba.fastjson.serializer.ValueFilter接口并重写process方法：

java 复制代码

public class DesensitizeValueFilter implements ValueFilter {
    @Override
    public Object process(Object object, String name, Object value) {
        try {
            Field field = object.getClass().getDeclaredField(name);
            Desensitize desensitize = field.getAnnotation(Desensitize.class);
            if (desensitize == null) {
                return value;
            }
            if (!(value instanceof String) || ((String) value).length() == 0) {
                return value;
            }
            String valueStr = (String) value;
            DesensitizeType type = desensitize.type();
            switch (type) {
                // 手机号脱敏
                case MOBILE_PHONE:
                    return DesensitizedUtil.mobilePhone(valueStr);
                // 车牌号脱敏
                case LICENSE_NUMBER:
                    return DesensitizedUtil.carLicense(valueStr);
                // 身份证号脱敏
                case ID_CARD:
                    return DesensitizedUtil.idCardNum(valueStr, 3, 4);
                // 银行卡脱敏
                case BANK_CARD:
                    return DesensitizedUtil.bankCard(valueStr);
                // 自定义脱敏
                case CUSTOM:
                    return CharSequenceUtil.hide(valueStr, desensitize.startIndex(), desensitize.endIndex());
                default:
                    break;
            }
        } catch (NoSuchFieldException e) {
            return value;
        }
        return value;
    }
}

然后在上面声明httpMessageConverters()的地方新增以下代码：

java 复制代码

fastJsonConfig.setSerializeFilters(new DesensitizeValueFilter());

此时，上文中自定义的脱敏注解中，@JacksonAnnotationsInside和@JsonSerialize(using = DesensitizeSerializer.class)

可以移除：

再次运行验证，会发现自定义脱敏注解生效了：

4.3 注意影响范围

在VO的某个字段上加上@Desensitize(type = DesensitizeType.MOBILE_PHONE)后，所有使用到该VO的接口，在返回数据时，

该字段都会被脱敏，如果列表页接口和详情接口共用了这个VO，但实际情况是列表页该字段需要脱敏，编辑页该字段不需要脱敏，

这种场景就需要特别注意。