<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.3.3</version>
</dependency>

//解密字段注解
@Target(value = {ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DecryptField {
}

//加密字段注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface EncryptField {
}

//作用于對返回值進行解密處理的方法上
@Target(value = {ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedDecrypt {
}

//作用于需要對入參數(shù)進行加密處理的方法上
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedEncrypt {
}

@Slf4j
@Data
public class Person  {
 private Integer id;
 private String userName;
 private String loginNo;
 @EncryptField
 @DecryptField
 private String phoneNumber;
 private String sex;
 @DecryptField
 @EncryptField
 private String IDCard;
 private String address;
 @EncryptField
 @DecryptField
 private String houseNumber;
}

@RestController
@RequestMapping("/person")
@Slf4j
public class PersonController {
    @Autowired
    private IPersonService personService;
    //添加人員信息
    @PostMapping("/add")
    @NeedEncrypt
    public Person add(@RequestBody Person person, Model model) {
        Person result = this.personService.registe(person);
        log.info("http://增加person執(zhí)行完成");
        return result;
    }
    //人員信息列表查詢
    @GetMapping("/list")
    @NeedDecrypt
    public List<Person> getPerson() {
        List<Person> persons = this.personService.getPersonList();
        log.info("http://查詢person列表執(zhí)行完成");
        return persons;
    }
    //人員信息詳情查詢
    @GetMapping("/{id}")
    @NeedDecrypt
    public Person get(@PathVariable Integer id) {
        Person persnotallow= this.personService.get(id);
        log.info("http://查詢person詳情執(zhí)行完成");
        return person;
    }
}

@Component
@Aspect
@Slf4j
public class EncryptAop {
    /**
     * 定義加密切入點
     */
    @Pointcut(value = "@annotation(com.fanfu.anno.NeedEncrypt)")
    public void pointcut() {
    }


    /**
     * 命中加密切入點的環(huán)繞通知
     *
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("http://環(huán)繞通知 start");
        //獲取命中目標方法的入參數(shù)
        Object[] args = proceedingJoinPoint.getArgs();
        if (args.length > 0) {
            for (Object arg : args) {
                //按參數(shù)的類型進行判斷，如果業(yè)務中還有其他的類型，可酌情增加
                if (arg != null) {
                    if (arg instanceof List) {
                        for (Object tmp : ((List) arg)) {
                            //加密處理
                            this.deepProcess(tmp);
                        }
                    } else {
                        this.deepProcess(arg);
                    }
                }
            }
        }
        //對敏感數(shù)據(jù)加密后執(zhí)行目標方法
        Object result = proceedingJoinPoint.proceed();
        log.info("http://環(huán)繞通知 end");
        return result;
    }


    public void deepProcess(Object obj) throws IllegalAccessException {
        if (obj != null) {
            //獲取對象的所有字段屬性并遍歷
            Field[] declaredFields = obj.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                //判斷字段屬性上是否標記了@EncryptField注解
                if (declaredField.isAnnotationPresent(EncryptField.class)) {
                    //如果判斷結果為真，則取出字段屬性值，進行加密、重新賦值
                    declaredField.setAccessible(true);
                    Object valObj = declaredField.get(obj);
                    if (valObj != null) {
                        String value = valObj.toString();
                        //開始敏感字段屬性值加密
                        String decrypt = this.encrypt(value);
                        //把加密后的字段屬性值重新賦值
                        declaredField.set(obj, decrypt);
                    }
                }
            }
        }
    }


    private String encrypt(String value) {
        //這里特別注意一下，對稱加密是根據(jù)密鑰進行加密和解密的，加密和解密的密鑰是相同的，一旦泄漏，就無秘密可言，
        //“fanfu-csdn”就是我自定義的密鑰，這里僅作演示使用，實際業(yè)務中，這個密鑰要以安全的方式存儲；
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DES.getValue(), "fanfu-csdn".getBytes()).getEncoded();
        SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.DES, key);
        String encryptValue = aes.encryptBase64(value);
        return encryptValue;
    }


}

@Component
@Aspect
@Slf4j
public class DecryptAop {
    /**
     * 定義需要解密的切入點
     */
    @Pointcut(value = "@annotation(com.fanfu.anno.NeedDecrypt)")
    public void pointcut() {
    }


    /**
     * 命中的切入點時的環(huán)繞通知
     *
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("http://環(huán)繞通知 start");
        //執(zhí)行目標方法
        Object result = proceedingJoinPoint.proceed();
        //判斷目標方法的返回值類型
        if (result instanceof List) {
            for (Object tmp : ((List) result)) {
                //數(shù)據(jù)脫敏處理邏輯
                this.deepProcess(tmp);
            }
        } else {
            this.deepProcess(result);
        }
        log.info("http://環(huán)繞通知 end");
        return result;
    }


    public void deepProcess(Object obj) throws IllegalAccessException {
        if (obj != null) {
            //取出輸出對象的所有字段屬性，并遍歷
            Field[] declaredFields = obj.getClass().getDeclaredFields();
            for (Field declaredField : declaredFields) {
                //判斷字段屬性上是否標記DecryptField注解
                if (declaredField.isAnnotationPresent(DecryptField.class)) {
                    //如果判斷結果為真，則取出字段屬性數(shù)據(jù)進行解密處理
                    declaredField.setAccessible(true);
                    Object valObj = declaredField.get(obj);
                    if (valObj != null) {
                        String value = valObj.toString();
                        //加密數(shù)據(jù)的解密處理
                        value = this.decrypt(value);
                        DecryptField annotation = declaredField.getAnnotation(DecryptField.class);
                        boolean open = annotation.open();
                        //把解密后的數(shù)據(jù)重新賦值
                        declaredField.set(obj, value);
                    }
                }
            }
        }
    }


    private String decrypt(String value) {
        //這里特別注意一下，對稱加密是根據(jù)密鑰進行加密和解密的，加密和解密的密鑰是相同的，一旦泄漏，就無秘密可言，
        //“fanfu-csdn”就是我自定義的密鑰，這里僅作演示使用，實際業(yè)務中，這個密鑰要以安全的方式存儲；
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DES.getValue(), "fanfu-csdn".getBytes()).getEncoded();
        SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.DES, key);
        String decryptStr = aes.decryptStr(value);
        return decryptStr;
    }
}