使用自定义注解加密实体中手机号码字段

通常我们数据库中带有用户手机号的数据，在展示给前端的时候，都需要进行部分加密，也就是真实手机号为15066668888的数据在加密返回给前端之后，应为150****8888

关于这个问题，解决方案很多很灵活，这里我写一个使用自定义注解来加密手机号码字段的小栗子

基本思路

1.首先我们把数据从数据库中查询出来，放到实体对象中，在实体对象中需要被加密的字段上面加上我们自定义的注解

2.在业务层中，我们拿到实体对象或实体对象的集合，之后调用加密方法，把加了注解的字段进行加密，并且返回新的实体对象或新的实体对象集合

3.我们拿到新的结果之后，就可以按照之前的逻辑进行处理了。我自认为这样的操作对业务层的代码入侵不是很大

代码示例

注意：本示例依赖Hutool工具类hutool-core

1.自定义加密注解

/**
 * 虚拟手机号注解<br>
 * 在实体中需要被加密的字段上使用该注解(目前仅用于加密手机号码中间4位)<br>
 * conditionField参数可以为空,为空时,强制解密注解字段<br>
 * conditionField参数会告知程序,依据这个字段的数值,来决定是否加密注解字段
 *
 * @author MrXionGe
 * @since 2019/2/22
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface VirtualMobile {

    /**
     * 加密条件字段<br>
     * 这个参数所指向的字段需要是integer类型<br>
     * 条件字段为1执行加密,为0不执行加密(如果这个字段是别的整数数值,强制加密;如果是别的类型的值,打印异常信息,并返回原值)<br>
     * 若该参数是一个不存在的字段,则强制加密
     *
     * @return String
     */
    String conditionField() default "";

}

2.注解处理器(这里写了静态方法，调用方法时执行加密操作)

/**
 * @author MrXionGe
 * @since 2019/2/22
 */
public class VirtualMobileProcessor {

    /**
     * 加密Bean对象中的指定字段<br>
     * 用于加密实体对象中的手机号码字段
     *
     * @param object Bean对象
     * @param clazz  对象类型
     * @return 加密之后的JavaBean
     */
    public static <T> T cryptoMobile(T object, Class<T> clazz) {
        String cryptoField;
        String conditionField;
        //判断是否有打了注解的字段
        for (Field declaredField : clazz.getDeclaredFields()) {
            VirtualMobile annotation = declaredField.getAnnotation(VirtualMobile.class);
            //找到注解字段,则执行字段加密
            if (Validator.isNotNull(annotation)) {
                cryptoField = declaredField.getName();
                conditionField = annotation.conditionField();
                return copyBean(cryptoField, conditionField, object, clazz);
            }
        }
        //没有找到注解字段,直接返回传入的对象
        return Convert.convert(clazz, object);
    }

    /**
     * 加密集合中每个对象的指定字段<br>
     * 用于加密实体对象中的手机号码字段
     *
     * @param collection Bean对象集合
     * @param clazz      集合中的对象类型
     * @return 加密之后的JavaBean集合
     */
    public static <T> Collection<T> cryptoMobileForList(Collection<T> collection, Class<T> clazz) {
        return collection.stream().map(t -> cryptoMobile(t, clazz)).collect(Collectors.toList());
    }

    /**
     * 加密Bean对象<br>
     * 传入需要被加密的Bean,返回加密之后的Bean
     *
     * @param cryptoField    需要被加密的字段
     * @param conditionField 参考是否加密的条件字段
     * @param object         Bean对象
     * @param clazz          对象类型
     * @return 加密之后的JavaBean
     */
    private static <T> T copyBean(String cryptoField, String conditionField, T object, Class<T> clazz) {
        try {
            //cryptoField参数为空,直接返回原对象
            if (Validator.isEmpty(cryptoField)) {
                return Convert.convert(clazz, object);
            }
            //判断条件字段
            if (Validator.isNotEmpty(conditionField)) {
                for (Field declaredField : clazz.getDeclaredFields()) {
                    declaredField.setAccessible(true);
                    //不加密
                    if (declaredField.getName().equals(conditionField) && Integer.valueOf(String.valueOf(declaredField.get(object))) == 0) {
                        return Convert.convert(clazz, object);
                    }
                    //加密
                    if (declaredField.getName().equals(conditionField) && Integer.valueOf(String.valueOf(declaredField.get(object))) == 1) {
                        return cryptoBean(cryptoField, object, clazz);
                    }
                }
            }
            //条件字段为空,强制加密
            return cryptoBean(cryptoField, object, clazz);
        } catch (Exception e) {
            e.printStackTrace();
            //发生异常,返回原对象
            return Convert.convert(clazz, object);
        }
    }

    /**
     * 加密Bean中的指定字段
     *
     * @param cryptoField 需要被加密的字段
     * @param object      Bean对象
     * @param clazz       对象类型
     * @return 加密之后的JavaBean
     */
    private static <T> T cryptoBean(String cryptoField, T object, Class<T> clazz) {
        try {
            for (Field declaredField : clazz.getDeclaredFields()) {
                declaredField.setAccessible(true);
                if (declaredField.getName().equals(cryptoField)) {
                    BeanUtil.setFieldValue(object, cryptoField, createVirtualMobile(String.valueOf(declaredField.get(object))));
                }
            }
            return Convert.convert(clazz, object);
        } catch (Exception e) {
            e.printStackTrace();
            return Convert.convert(clazz, object);
        }
    }

    /**
     * 加密手机号码中间4位<br>
     * 如果不是11位手机号码,直接返回原值
     *
     * @param mobile 加密前的手机号码
     * @return 加密后的手机号码
     */
    private static String createVirtualMobile(String mobile) {
        try {
            //转换成Long如果异常或者不是11位,就说明不是手机号码,直接返回传入的对象
            Long.valueOf(mobile);
            if (mobile.length() != 11) {
                return mobile;
            }
            return StrUtil.hide(mobile, 3, 7);
        } catch (Exception e) {
            return mobile;
        }
    }
}

3.测试实体类

/**
 * @author MrXionGe
 * @since 2019/2/22
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
class Student {

    private Long id;

    @VirtualMobile(conditionField = "cryptoStatus")
    private String mobile;

    private Integer cryptoStatus;

    private LocalDateTime createTime;
}

4.测试类

/**
 * @author MrXionGe
 * @since 2019/2/22
 */
public class Test {

    public static void main(String[] args) {
        //单对象测试
        System.out.println(cryptoMobile(new Student(randomLong(11111111L, 99999999L), String.valueOf(randomLong(13011111111L, 13099999999L)),
                1, LocalDateTime.now()), Student.class));
        //集合测试
        List<Student> studentList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Student student = new Student();
            student.setId(randomLong(11111111L, 99999999L));
            student.setMobile(String.valueOf(randomLong(13011111111L, 13099999999L)));
            student.setCryptoStatus(1);
            student.setCreateTime(LocalDateTime.now());
            studentList.add(student);
        }
        long startMillis = System.currentTimeMillis();
        Collection<Student> students = cryptoMobileForList(studentList, Student.class);
        long stopMillis = System.currentTimeMillis();
        System.out.println(stopMillis - startMillis + "ms");
        System.out.println(students);
    }
}

测试

测试类中，我们有单个对象的加密测试，也有集合的加密测试，我们一起跑一下

我们可以看到，手机号字段加密成功了

性能

我们测试一下加密10万数据所需要的时间

测试代码如下图

我测试五次分别是 267ms，241ms，254ms，272ms，257ms

我认为这样的处理速度还是可以接受的

以上就是使用自定义注解加密手机号码字段的全部示例，如果我的代码中有错误或您有更优的写法，欢迎大家吐槽