Java自定义数据脱敏注解

应用场景

数据库中密文存储身份证、手机号等敏感信息时，Java需要将密文数据转换为明文并脱敏返回给前端。

脱敏方式枚举类

public enum DesensitizationTypeEnum {

    /**
     * 默认方式
     */
    DEFAULT,

    /**
     * 头部脱敏
     */
    HEAD,

    /**
     * 尾部脱敏
     */
    TAIL,

    /**
     * 中间脱敏
     */
    MIDDLE,

    /**
     * 头尾脱敏
     */
    HEAD_TAIL,

    /**
     * 全部脱敏
     */
    ALL,

    /**
     * 不脱敏，相当于没打这个注解
     */
    NONE;
}

 脱敏数据类型枚举类

@Getter
@NoArgsConstructor
public enum DesensitizationDataTypeEnum {

    /**
     * 用户ID
     */
    USER_ID,

    /**
     * 中文名
     */
    CHINESE_NAME,

    /**
     * 身份证
     */
    ID_CARD,

    /**
     * 座机号
     */
    FIXED_PHONE,

    /**
     * 手机号
     */
    MOBILE_PHONE,

    /**
     * 地址
     */
    ADDRESS,

    /**
     * 电子邮件
     */
    EMAIL,

    /**
     * 密码
     */
    PASSWORD,

    /**
     * 车牌
     */
    CAR_LICENSE,

    /**
     * 银行卡号
     */
    BANK_CARD,

    /**
     * 其他
     */
    OTHER;

}

脱敏工具类

public class DesensitizationUtil {
    public DesensitizationUtil() {
    }

    public static String desensitized(CharSequence str, DesensitizationDataTypeEnum desensitizedType) {
        if (StrUtil.isBlank(str)) {
            return "";
        } else {
            String newStr = String.valueOf(str);
            switch (desensitizedType.ordinal()) {
                case 1:
                    newStr = String.valueOf(userId());
                    break;
                case 2:
                    newStr = chineseName(String.valueOf(str));
                    break;
                case 3:
                    newStr = idCardNum(String.valueOf(str), 1, 2);
                    break;
                case 4:
                    newStr = fixedPhone(String.valueOf(str));
                    break;
                case 5:
                    newStr = mobilePhone(String.valueOf(str));
                    break;
                case 6:
                    newStr = address(String.valueOf(str));
                    break;
                case 7:
                    newStr = email(String.valueOf(str));
                    break;
                case 8:
                    newStr = password(String.valueOf(str));
                    break;
                case 9:
                    newStr = carLicense(String.valueOf(str));
                    break;
                case 10:
                    newStr = bankCard(String.valueOf(str));
            }

            return newStr;
        }
    }

    public static Long userId() {
        return 0L;
    }

    /**
     * 【中文姓名】只显示第一个汉字，其他隐藏为2个星号，比如：李**
     *
     * @param fullName 姓名
     * @return 脱敏后的姓名
     */
    public static String chineseName(String fullName) {
        return StrUtil.isBlank(fullName) ? "" : StrUtil.hide(fullName, 1, fullName.length());
    }

    /**
     * 【身份证号】显示前1位和后2位，其他隐藏。共计18位或者15位，比如：1*****************1
     *
     * @param idCardNum 身份证号
     * @param front     保留：前面的front位数；从1开始
     * @param end       保留：后面的end位数；从1开始
     * @return 脱敏后的身份证号
     */
    public static String idCardNum(String idCardNum, int front, int end) {
        if (StrUtil.isBlank(idCardNum)) {
            return "";
        } else if (front + end > idCardNum.length()) {
            return "";
        } else {
            return front >= 0 && end >= 0 ? StrUtil.hide(idCardNum, front, idCardNum.length() - end) : "";
        }
    }

    /**
     * 【固定电话】 前四位，后两位
     *
     * @param num 固定电话
     * @return 脱敏后的固定电话
     */
    public static String fixedPhone(String num) {
        return StrUtil.isBlank(num) ? "" : StrUtil.hide(num, 4, num.length() - 2);
    }

    /**
     * 【手机号码】前三位，后四位，其他隐藏，比如：138******1234
     *
     * @param num 手机号码
     * @return 脱敏后的手机号码
     */
    public static String mobilePhone(String num) {
        return StrUtil.isBlank(num) ? "" : StrUtil.hide(num, 3, num.length() - 4);
    }

    /**
     * 【地址】只显示到地区的三分之二，尾部脱敏，不显示详细地址，比如：北京市海淀区****
     *
     * @param address 地址
     * @return 脱敏后的地址
     */
    public static String address(String address) {
        if (StrUtil.isBlank(address)) {
            return "";
        } else {
            // 地址尾部脱敏三分之一
            int length = address.length();
            int end = length / 3;
            return StrUtil.hide(address, length - end, length);
        }
    }

    /**
     * 【电子邮箱】邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示，比如：d**@126.com
     *
     * @param email 邮箱
     * @return 脱敏后的邮箱
     */
    public static String email(String email) {
        if (StrUtil.isBlank(email)) {
            return "";
        } else {
            int index = StrUtil.indexOf(email, '@');
            return index <= 1 ? email : StrUtil.hide(email, 1, index);
        }
    }

    /**
     * 【密码】密码的全部字符都用*代替，比如：******
     *
     * @param password 密码
     * @return 脱敏后的密码
     */
    public static String password(String password) {
        return StrUtil.isBlank(password) ? "" : StrUtil.repeat('*', password.length());
    }

    /**
     * 【中国车牌】车牌中间用*代替 eg1：null -》 "" eg1："" -》 "" eg3：苏D40000 -》 苏D4***0 eg4：陕A12345D -》 陕A1****D eg5：京A123 -》 京A123 如果是错误的车牌，不处理
     *
     * @param carLicense 完整的车牌号
     * @return 脱敏后的车牌号
     */
    public static String carLicense(String carLicense) {
        if (StrUtil.isBlank(carLicense)) {
            return "";
        } else {
            if (carLicense.length() == 7) {
                carLicense = StrUtil.hide(carLicense, 3, 6);
            } else if (carLicense.length() == 8) {
                carLicense = StrUtil.hide(carLicense, 3, 7);
            }

            return carLicense;
        }
    }

    /**
     * 银行卡号脱敏 eg: 1101 **** **** **** 3256
     *
     * @param bankCardNo 银行卡号
     * @return 脱敏后的银行卡号
     */
    public static String bankCard(String bankCardNo) {
        if (StrUtil.isBlank(bankCardNo)) {
            return bankCardNo;
        } else {
            bankCardNo = StrUtil.trim(bankCardNo);
            if (bankCardNo.length() < 9) {
                return bankCardNo;
            } else {
                int length = bankCardNo.length();
                int midLength = length - 8;
                StringBuilder buf = new StringBuilder();
                buf.append(bankCardNo, 0, 4);

                for (int i = 0; i < midLength; ++i) {
                    if (i % 4 == 0) {
                        buf.append(' ');
                    }

                    buf.append('*');
                }

                buf.append(' ').append(bankCardNo, length - 4, length);
                return buf.toString();
            }
        }
    }
}

脱敏注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = DesensitizationSerializer.class)
public @interface Desensitization {

    /**
     * 脱敏数据类型
     *
     * @return
     */
    DesensitizationDataTypeEnum dataType();

    /**
     * 是否解密，默认false
     */
    boolean decrypt() default false;

    /**
     * 脱敏类型
     *
     * @return
     */
    DesensitizationTypeEnum type() default DesensitizationTypeEnum.DEFAULT;

    /**
     * 尾部不脱敏的长度，默认1，当type为HEAD或HEAD_TAIL时使用
     */
    int tailNoMaskLen() default 1;

    /**
     * 头部不脱敏的长度，默认1，当type为TAIL或HEAD_TAIL时使用
     */
    int headNoMaskLen() default 1;

    /**
     * 中间不脱敏的长度，默认1，当type为MIDDLE时使用
     */
    int middleNoMaskLen() default 1;

    /**
     * 脱敏字符，默认*
     */
    char maskCode() default '*';

}

脱敏序列化器

@NoArgsConstructor
public class DesensitizationSerializer extends JsonSerializer<String> implements ContextualSerializer {

    private Desensitization desensitization;

    public DesensitizationSerializer(Desensitization desensitization) {
        this.desensitization = desensitization;
    }

    @Override
    public void serialize(String s, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeString(desensitize(s));
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
        if (beanProperty != null) {
            if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
                Desensitization desensitization = beanProperty.getAnnotation(Desensitization.class);
                if (desensitization == null) {
                    desensitization = beanProperty.getContextAnnotation(Desensitization.class);
                }
                if (desensitization != null) {
                    return new DesensitizationSerializer(desensitization);
                }
            }
            return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
        }
        return serializerProvider.findNullValueSerializer(null);
    }

    /**
     * 脱敏处理
     */
    private String desensitize(String s) {
        if (StrUtil.isNotBlank(s)) {
            DesensitizationDataTypeEnum dataType = desensitization.dataType();
            DesensitizationTypeEnum type = desensitization.type();
            // 解密处理
            boolean decrypt = desensitization.decrypt();
            if (decrypt) {
                String value = PasswordUtil.decrypt(s);
                // 正则匹配，如果匹配到身份证或手机号，则返回解密后的值，否则返回原值
                if (ReUtil.contains(ReConstant.ID_CARD, value) || ReUtil.contains(ReConstant.MOBILE, value)) {
                    s = value;
                }
            }
            switch (type) {
                case DEFAULT:
                    // 默认方式，根据dataType自动选择脱敏方式
                    s = autoDesensitize(s, dataType);
                    break;
                case HEAD:
                    // 头部脱敏
                    s = headDesensitize(s);
                    break;
                case TAIL:
                    // 尾部脱敏
                    s = tailDesensitize(s);
                    break;
                case MIDDLE:
                    s = middleDesensitize(s);
                    break;
                case HEAD_TAIL:
                    s = headTailDesensitize(s);
                    break;
                case ALL:
                    s = allDesensitize(s);
                    break;
                case NONE:
                    // 不做脱敏
                    break;
                default:
            }
        }
        return s;
    }

    /**
     * 全部脱敏
     */
    private String allDesensitize(String s) {
        return StrUtil.fillBefore(s, desensitization.maskCode(), s.length());
    }

    /**
     * 头尾脱敏
     */
    private String headTailDesensitize(String s) {
        int middleNoMaskLen = desensitization.middleNoMaskLen();
        if (middleNoMaskLen >= s.length()) {
            // 如果中间不脱敏的长度大于等于字符串的长度，不进行脱敏
            return s;
        }
        int len = s.length() - middleNoMaskLen;
        // 头部脱敏
        int headStart = 0;
        int headEnd = len / 2;
        s = StrUtil.replace(s, headStart, headEnd, desensitization.maskCode());
        // 尾部脱敏
        int tailStart = s.length() - (len - len / 2);
        int tailEnd = s.length();
        return StrUtil.replace(s, tailStart, tailEnd, desensitization.maskCode());
    }

    /**
     * 中间脱敏
     */
    private String middleDesensitize(String s) {
        int headNoMaskLen = desensitization.headNoMaskLen();
        int tailNoMaskLen = desensitization.tailNoMaskLen();
        if (headNoMaskLen + tailNoMaskLen >= s.length()) {
            // 如果头部不脱敏的长度+尾部不脱敏长度 大于等于字符串的长度，不进行脱敏
            return s;
        }
        int start = headNoMaskLen;
        int end = s.length() - tailNoMaskLen;
        return StrUtil.replace(s, start, end, desensitization.maskCode());
    }

    /**
     * 尾部脱敏
     */
    private String tailDesensitize(String s) {
        int headNoMaskLen = desensitization.headNoMaskLen();
        if (headNoMaskLen >= s.length()) {
            // 如果头部不脱敏的长度大于等于字符串的长度，不进行脱敏
            return s;
        }
        int start = headNoMaskLen;
        int end = s.length();
        return StrUtil.replace(s, start, end, desensitization.maskCode());
    }

    /**
     * 头部脱敏
     */
    private String headDesensitize(String s) {
        int tailNoMaskLen = desensitization.tailNoMaskLen();
        if (tailNoMaskLen >= s.length()) {
            // 如果尾部不脱敏的长度大于等于字符串的长度，不进行脱敏
            return s;
        }
        int start = 0;
        int end = s.length() - tailNoMaskLen;
        return StrUtil.replace(s, start, end, desensitization.maskCode());
    }

    /**
     * 根据数据类型自动脱敏
     */
    private String autoDesensitize(String s, DesensitizationDataTypeEnum dataType) {
        switch (dataType) {
            case CHINESE_NAME:
                s = DesensitizationUtil.chineseName(s);
                break;
            case FIXED_PHONE:
                s = DesensitizationUtil.fixedPhone(s);
                break;
            case MOBILE_PHONE:
                s = DesensitizationUtil.mobilePhone(s);
                break;
            case ADDRESS:
                s = DesensitizationUtil.address(s);
                break;
            case PASSWORD:
                s = DesensitizationUtil.password(s);
                break;
            case BANK_CARD:
                s = DesensitizationUtil.bankCard(s);
                break;
            case EMAIL:
                s = DesensitizationUtil.email(s);
                break;
            case ID_CARD:
                s = DesensitizationUtil.idCardNum(s, 6, 4);
                break;
            case OTHER:
                // 其他类型的不支持以默认方式脱敏，直接返回
                break;
            default:
        }
        return s;
    }
}

 返回对象

    @ApiModelProperty(value = "证件号码")
    @Desensitization(dataType = DesensitizationDataTypeEnum.ID_CARD, decrypt = true)
    @Encrypt // 前端传参时对数据进行加密匹配数据库密文身份证
    private String idcard;

    @ApiModelProperty(value = "联系电话: 一般登记手机密码，将在找回密码、修改密码时用于发送验证短信。")
    @Desensitization(dataType = DesensitizationDataTypeEnum.MOBILE_PHONE, decrypt = true)
    @Encrypt
    private String tel;

    @ApiModelProperty(value = "住址")
    @Desensitization(dataType = DesensitizationDataTypeEnum.ADDRESS)
    private String address;