2020-09-30

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface DataEncrypt {
    /**
     * 脱敏数据类型
     */
    EncryptType encryptType() default EncryptType.AES;

    String encryptedField();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataEncryptType {

    /**
     * 脱敏类型
     */
    EncryptType encryptType();
}

public enum EncryptType {
    /**
     * 默认脱敏策略
     */
    AES,
    /**
     * 中文名
     */
    RSA;
}

@Component
@DataEncryptType(encryptType = EncryptType.AES)
public class AesEncypt implements DataEncryptStrategy {

    @Override
    public String encrypt(String original) {
        return original + "AES:" + UUID.randomUUID().toString();
    }
}

 

public interface DataEncryptStrategy {

    String encrypt(String original);
}

@Slf4j
@Component
public class DataEncryptStrategyFactory implements InitializingBean {
    @Autowired
    private List<DataEncryptStrategy> encryptStrategies;

    private static final Map<EncryptType, DataEncryptStrategy> MASK_STRATEGY_MAP = Maps.newHashMap();

    @Override
    public void afterPropertiesSet() throws Exception {
        encryptStrategies.forEach(encryptStrategy -> {
            DataEncrypt maskType = encryptStrategy.getClass().getAnnotation(DataEncrypt.class);

            if (maskType == null) {
                log.error("Class[{}] must specify annotation [{}]", encryptStrategy.getClass(), DataEncrypt.class);
                return;
            }

            MASK_STRATEGY_MAP.put(maskType.encryptType(), encryptStrategy);
        });
    }

    /**
     * @param encryptType
     * @return com.lemon.mask.strategy.DataEncryptStrategy
     * @description 获取数据脱敏策略
     * @author lemon
     * @date 2020-07-06 11:15
     */
    public static DataEncryptStrategy getDataEncryptStrategy(EncryptType encryptType) {
        return MASK_STRATEGY_MAP.get(encryptType);
    }
}

public class EncryptedUtils {
    private EncryptedUtils() {
    }


    /**
     * @param original
     * @param encryptType
     * @return java.lang.String
     * @description 对字符串按指定类型脱敏
     * @author lemon
     * @date 2020-07-03 17:52
     */
    public static String encryptValue(String original, EncryptType encryptType) {

        DataEncryptStrategy maskStrategy = DataEncryptStrategyFactory.getDataEncryptStrategy(encryptType);

        if (maskStrategy == null) {
            log.warn("No matching Mask Strategy found for type [{}]", encryptType);
            return original;
        }

        log.debug("Find MaskStrategy [{}]", maskStrategy.getClass());
        return maskStrategy.encrypt(original);
    }
}

DesensitizedHandler

public static void setNewValueForField(Object javaBean, Field field, Object value) throws IllegalAccessException {
        String valueStr = (String) value;
        if (StringUtils.isBlank(valueStr)) {
            // 空白值的字段不需要脱敏和加密
            return;
        }
        // 先加密
        DataEncrypt dataEncrypt = field.getAnnotation(DataEncrypt.class);
        if (dataEncrypt != null) {
            try {
                // 获取加密后的字段
                String encryptedFieldStr = dataEncrypt.encryptedField();
                if (StringUtils.isNotBlank(encryptedFieldStr)) {
                    // 根据属性名获取字段对象
                    Field encryptedField = javaBean.getClass().getField(encryptedFieldStr);
                    encryptedField.set(javaBean, EncryptedUtils.encryptValue(valueStr, dataEncrypt.encryptType()));
                }
            } catch (NoSuchFieldException e) {

            } catch (Exception e) {

            }
        }


        //处理自身的属性
        DataMask dataMask = field.getAnnotation(DataMask.class);

        if (dataMask == null
                || StringUtils.isNotBlank(valueStr)
                || field.getType() != String.class ) {
            return;
        }
        DesensitizedConfig desensitizedConfig = DesensitizedUtils.getDesensitizedConfig(dataMask);
        field.set(javaBean, DesensitizedUtils.maskValue(valueStr, desensitizedConfig));


    }