首页 > 其他分享> 文章详细

Jackson 系列化之脱敏处理

2022-06-21 00:00:59 阅读：192 来源： 互联网

标签：origin return String 系列化 DesensitizedUtil Jackson null public 脱敏

>>>>>>>>>>>>> 码云中有封装好的：https://gitee.com/chxlay/iserver-common.git <<<<<<<<<<<<<<<<<<<<<

在码云项目中的： iserver-common-core 模块中

可参考文章： https://blog.csdn.net/liufei198613/article/details/79009015

介绍：

1、使用注解方式标记申明脱敏处理

自定义注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@JacksonAnnotationsInside
@JsonSerialize(using = StrSensitiveSerializer.class)
public @interface Sensitive {
    /**
     * 脱敏数据类型, 非Customer时, 将忽略 maskEndAt 和 maskEndAt 和 maskStr
     */
    Type type() default Type.CUSTOMER;

    /**
     * 打码起始长度
     */
    int maskStartLen() default 0;

    /**
     * 打码结束保留长度
     */
    int keepTailLen() default 0;

    /**
     * 用什么打码
     */
    String maskStr() default "*";

    enum Type {

        /**
         * 自定义
         */
        CUSTOMER,
        /**
         * 用户编码
         */
        USER_CODE,
        /**
         * 用户名, 刘*华
         */
        CHINESE_NAME,
        /**
         * 性别
         */
        SEX,
        /**
         * 身份证号, 110110********1234
         */
        ID_CARD,
        /**
         * 座机号, ****1234
         */
        FIXED_PHONE,
        /**
         * 手机号, 176****1234
         */
        MOBILE_PHONE,
        /**
         * 地址, 北京********
         */
        ADDRESS,
        /**
         * 电子邮件, s*****o@xx.com
         */
        EMAIL,
        /**
         * 银行卡, 622202************1234
         */
        BANK_CARD,
        /**
         * 密码, 永远是 ******, 与长度无关
         */
        PASSWORD,
        /**
         * 密钥, 永远是 ******, 与长度无关
         */
        KEY
    }
}

2、自定一个类，实现脱敏系列化的逻辑：

继承 Jackson 的系列化类 JsonSerializer<T>

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

    private Sensitive.Type type;

    private Integer prefixNoMaskLen;

    private Integer suffixNoMaskLen;

    private String maskStr;


    @Override
    public void serialize(String origin, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        switch (type) {
            case CHINESE_NAME:
                jsonGenerator.writeString(DesensitizedUtil.chineseName(origin));
                break;
            case USER_CODE:
                jsonGenerator.writeString(DesensitizedUtil.userCode(origin));
                break;
            case SEX:
                jsonGenerator.writeString(DesensitizedUtil.sex(origin));
                break;
            case ID_CARD:
                jsonGenerator.writeString(DesensitizedUtil.idCardNum(origin));
                break;
            case FIXED_PHONE:
                jsonGenerator.writeString(DesensitizedUtil.fixedPhone(origin));
                break;
            case MOBILE_PHONE:
                jsonGenerator.writeString(DesensitizedUtil.mobilePhone(origin));
                break;
            case ADDRESS:
                jsonGenerator.writeString(DesensitizedUtil.address(origin));
                break;
            case EMAIL:
                jsonGenerator.writeString(DesensitizedUtil.email(origin));
                break;
            case BANK_CARD:
                jsonGenerator.writeString(DesensitizedUtil.bankCard(origin));
                break;
            case PASSWORD:
                jsonGenerator.writeString(DesensitizedUtil.password(origin));
                break;
            case KEY:
                jsonGenerator.writeString(DesensitizedUtil.key(origin));
                break;
            case CUSTOMER:
                jsonGenerator.writeString(DesensitizedUtil.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, maskStr));
                break;
            default:
                throw new IllegalArgumentException("Unknown sensitive type enum " + type);
        }
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
        if (null != beanProperty) {
            if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
                Sensitive sensitive = beanProperty.getAnnotation(Sensitive.class);
                if (sensitive == null) {
                    sensitive = beanProperty.getContextAnnotation(Sensitive.class);
                }
                if (sensitive != null) {
                    return new StrSensitiveSerializer(sensitive.type(), sensitive.maskStartLen(), sensitive.keepTailLen(), sensitive.maskStr());
                }
            }
            return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
        }
        return serializerProvider.findNullValueSerializer(null);
    }
}

系列化辅助的工具类：

public class DesensitizedUtil {

    /**
     * 对字符串进行脱敏操作
     *
     * @param origin       原始字符串
     * @param keepTailLen  左侧需要保留几位明文字段
     * @param maskStartLen 右侧需要保留几位明文字段
     * @param maskStr      用于遮罩的字符串, 如'*'
     * @return 脱敏后结果
     */
    public static String desValue(String origin, int maskStartLen, int keepTailLen, String maskStr) {
        if (origin == null) {
            return null;
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0, n = origin.length(); i < n; i++) {
            if (i < maskStartLen) {
                sb.append(origin.charAt(i));
                continue;
            }
            if (i > (n - keepTailLen - 1)) {
                sb.append(origin.charAt(i));
                continue;
            }
            sb.append(maskStr);
        }
        return sb.toString();
    }

    /**
     * 【中文姓名】只显示最后一个汉字，其他隐藏为星号，比如：**梦
     *
     * @param fullName 姓名
     * @return 结果
     */
    public static String chineseName(String fullName) {
        if (fullName == null) {
            return null;
        }
        return desValue(fullName, 0, 1, "*");
    }

    public static String userCode(String userCode){
        if (userCode == null) {
            return null;
        }
        return desValue(userCode, 1, 1, "*");
    }
    /**
     * 性别
     *
     * @param fullName
     * @return
     */
    public static String sex(String fullName) {
        if (fullName == null) {
            return null;
        }
        return "*";
    }

    /**
     * 【身份证号】显示前六位, 四位，其他隐藏。共计18位或者15位，比如：340304*******1234
     *
     * @param id 身份证号码
     * @return 结果
     */
    public static String idCardNum(String id) {
        return desValue(id, 6, 4, "*");
    }

    /**
     * 【固定电话】后四位，其他隐藏，比如 ****1234
     *
     * @param num 固定电话
     * @return 结果
     */
    public static String fixedPhone(String num) {
        return desValue(num, 0, 4, "*");
    }

    /**
     * 【手机号码】前三位，后四位，其他隐藏，比如135****6810
     *
     * @param num 手机号码
     * @return 结果
     */
    public static String mobilePhone(String num) {
        return desValue(num, 3, 4, "*");
    }

    /**
     * 【地址】只显示到地区，不显示详细地址，比如：北京市海淀区****
     *
     * @param address 地址
     * @return 结果
     */
    public static String address(String address) {
        return desValue(address, 6, 0, "*");
    }

    /**
     * 【电子邮箱 邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示，比如：d**@126.com
     *
     * @param email 电子邮箱
     * @return 结果
     */
    public static String email(String email) {
        if (email == null) {
            return null;
        }
        int index = StrUtil.indexOf(email, '@');
        if (index <= 1) {
            return email;
        }
        String preEmail = desValue(email.substring(0, index), 1, 0, "*");
        return preEmail + email.substring(index);

    }

    /**
     * 【银行卡号】前六位，后四位，其他用星号隐藏每位1个星号，比如：622260**********1234
     *
     * @param cardNum 银行卡号
     * @return 结果
     */
    public static String bankCard(String cardNum) {
        return desValue(cardNum, 6, 4, "*");
    }

    /**
     * 【密码】密码的全部字符都用*代替，比如：******
     *
     * @param password 密码
     * @return 结果
     */
    public static String password(String password) {
        if (password == null) {
            return null;
        }
        return "******";
    }

    /**
     * 【密钥】密钥除了最后三位，全部都用*代替，比如：***xdS 脱敏后长度为6，如果明文长度不足三位，则按实际长度显示，剩余位置补*
     *
     * @param key 密钥
     * @return 结果
     */
    public static String key(String key) {
        if (key == null) {
            return null;
        }
        int viewLength = 6;
        StringBuilder tmpKey = new StringBuilder(desValue(key, 0, 3, "*"));
        if (tmpKey.length() > viewLength) {
            return tmpKey.substring(tmpKey.length() - viewLength);
        } else if (tmpKey.length() < viewLength) {
            int buffLength = viewLength - tmpKey.length();
            for (int i = 0; i < buffLength; i++) {
                tmpKey.insert(0, "*");
            }
            return tmpKey.toString();
        } else {
            return tmpKey.toString();
        }
    }

}

使用示例：

/**
 * 性别
 */
@Sensitive(type = Sensitive.Type.SEX)
private String sex;
/**
 * 电话
 */
@Sensitive(type = Sensitive.Type.MOBILE_PHONE)
private String phone;/**
 * 身份证号
 */
@Sensitive(type = Sensitive.Type.ID_CARD)
private String cardId;

这里只是抛砖引玉如果您的项目中使用的系列化是其他框架，也可以使用同样的原理，进行编写

标签：origin,return,String,系列化,DesensitizedUtil,Jackson,null,public,脱敏
来源： https://www.cnblogs.com/Alay/p/16395254.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Jackson 系列化 之 脱敏处理

Jackson 系列化之脱敏处理