package com.monkeylessey.framework.aspect; import com.monkeylessey.annotation.Cipher; import com.monkeylessey.annotation.CipherField; import com.monkeylessey.framework.service.cipher.CipherService; import com.monkeylessey.response.Result; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Component; import org.springframework.util.CollectionUtils; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Arrays; import java.util.Objects; @Aspect @Component public class AESAspectHandler { private final CipherService cipherService; public AESAspectHandler(@Qualifier("AESCipherService") CipherService cipherService) { this.cipherService = cipherService; } @Pointcut(value = "execution(* com.monkeylessey.controller.*.*(..,@com.monkeylessey.annotation.Cipher (*),..))") public void point() {} @Pointcut(value = "@annotation(com.monkeylessey.annotation.Cipher)") public void returnPoint() {} @AfterReturning(value = "returnPoint()", returning = "result") public void afterReturn(Object result) throws Exception { if (result.getClass() == Result.class) { Result res = (Result) result; Object data = res.get(Result.DATA); Class dataClass = data.getClass(); Field[] fields = dataClass.getDeclaredFields(); for (Field field : fields) { this.iterationCipherTargetField(false, data, dataClass, field); } } } /** * 必须使用@Around才能处理直接用String作为参数的接口 * @throws Throwable */ @Around(value = "point()") public void around(ProceedingJoinPoint joinPoint) throws Throwable { Object[] args = joinPoint.getArgs(); if (CollectionUtils.isEmpty(Arrays.asList(args))) { return; } MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod(); // 二维数组：第几个参数；参数上的注解 Annotation[][] parameterAnnotations = method.getParameterAnnotations(); for (int i = 0; i < parameterAnnotations.length; i++) { for (Annotation annotation : parameterAnnotations[i]) { if (annotation instanceof Cipher) { Object arg = args[i]; Class argClass = arg.getClass(); // 检查注解不能作用在Object类型上 this.checkAnnotationOnObject(argClass); // 如果注解作用于String，直接解密 if (argClass == String.class) { String decrypt = cipherService.decode((String) arg); args[i] = decrypt; continue; } // 获取目标对象的所有属性 Field[] fields = argClass.getDeclaredFields(); // 遍历，找到添加了CipherField注解的String类型属性 for (Field field : fields) { this.iterationCipherTargetField(true, arg, argClass, field); } } } } // 执行目标接口 joinPoint.proceed(args); } /** * 迭代对象 解密、加密 String字符串 * * @param arg 接口参数 * @param argClass 接口参数类型 * @param field 接口参数对象的属性 * @throws Exception */ public void iterationCipherTargetField(boolean decode, Object arg, Class argClass, Field field) throws Exception { if (Objects.isNull(arg)) { return; } CipherField annotation = field.getAnnotation(CipherField.class); if (Objects.isNull(annotation)) { return; } Class fieldClass = field.getType(); this.checkAnnotationOnObject(fieldClass); // 未开启解码，则无操作 if (decode && ! annotation.needDecode()) { return; } // 未开启编码，则无操作 if (! decode && ! annotation.needEncode()) { return; } if (fieldClass == String.class) { // String类型直接解密 this.cipherByReflection(decode, arg, argClass, field); } else { // 对象类型，需要判断对象的属性是否有CipherField注解的字符串，如果属性还是对象则继续深入遍历 Field[] childObjectFields = fieldClass.getDeclaredFields(); for (Field childObjectField : childObjectFields) { this.iterationCipherTargetField(decode, getValueByReflection(arg, field), fieldClass, childObjectField); } } } /** * 通过反射修改密文为明文 * @param decode 是否解密 * @param arg * @param argClass * @param field * @throws Exception */ public void cipherByReflection(boolean decode, Object arg, Class argClass, Field field) throws Exception { String fieldName = field.getName(); Method[] methods = argClass.getDeclaredMethods(); Method get = null; // 声明get方法 Method set = null; // 声明set方法 // 遍历目标对象的所有方法，主要是拿到目标属性的get、set方法 for (Method method : methods) { if (method.getName().equals(this.getMethodByFiledName("set", fieldName))) { set = method; } if (method.getName().equals(this.getMethodByFiledName("get", fieldName))) { get = method; } } // 必须要定义set、get方法，否则无法通过反射将密文修改为明文 if (Objects.isNull(set)) { throw new RuntimeException("请为需要解密的字段添加【set】方法"); } if (Objects.isNull(get)) { throw new RuntimeException("请为需要解密的字段添加【get】方法"); } if (decode) { // 解密 set.invoke(arg, cipherService.decode((String) get.invoke(arg))); } else { // 加密 set.invoke(arg, cipherService.encode((String) get.invoke(arg))); } } /** * 主要是获取，属性为对象的值，用于深度遍历 * @param arg 持有这个属性的对象 * @param field * @return * @throws InvocationTargetException * @throws IllegalAccessException */ public Object getValueByReflection(Object arg, Field field) throws InvocationTargetException, IllegalAccessException { Method[] methods = arg.getClass().getDeclaredMethods(); for (Method method : methods) { if (method.getName().equals(this.getMethodByFiledName("get", field.getName()))) { return method.invoke(arg); } } return null; } /** * 检查注解不能作用在Object类型上 * @param target */ public void checkAnnotationOnObject(Class target) { if (target == Object.class) { throw new RuntimeException("CipherField、CipherField注解不能作用在Object类型上"); } } /** * 获取方法名，属性名首字母大写 * * @param prefix * @param fieldName * @return */ public String getMethodByFiledName(String prefix, String fieldName) { String firstWord = fieldName.substring(0,1).toUpperCase(); String method = prefix + firstWord + fieldName.substring(1); return method; } }