java中springaop实现对参数加解密

1，前置逻辑我就不写了，只给出关键性代码

可以直接切postMapping这个注解，然后获取入参，然后执行下面代码，
后续我会给出完整的代码

2.工具类

import com.example.study.annotation.Encryption;
import com.example.study.entity.User;
import com.example.study.entity.User1;
import com.example.study.entity.User2;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;

public class EncryptionUtils {

    public static void main(String[] args) {
        /**
         * @Data
         * public class User {
         *     @Encryption
         *     private String name;
         *     private Integer age;
         *     @Encryption
         *     private List<User1> users;
         *     @Encryption
         *     private User2 user2;
         * }
         *
         * @Data
         * public class User1 {
         *     @Encryption
         *     private String address;
         *     private String address1;
         * }
         * 
         * @Data
         * public class User2 {
         *     @Encryption
         *     private String nickName;
         *     private String password;
         * }
         */
        User user = new User();
        user.setName("name1");
        User1 user1 = new User1();
        user1.setAddress("address1");
        user1.setAddress1("address2");
        User1 user3 = new User1();
        user3.setAddress("address3");
        user3.setAddress1("address4");
        user.setUsers(Arrays.asList(user1, user3));
        User2 user2 = new User2();
        user2.setNickName("nuckName");
        user2.setPassword("123344");
        user.setUser2(user2);
        encryptFields(user);
        System.out.println(user);

    }

    public static void encryptFields(Object object) {
        Class<?> clazz = object.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            try {
                if (field.isAnnotationPresent(Encryption.class)) {
                    Object value = field.get(object);
                    if (value instanceof String) {
                        // 处理字符串字段
                        String encryptedValue = encrypt((String) value);
                        field.set(object, encryptedValue);
                    } else if (value instanceof Collection) {
                        // 处理集合字段
                        Collection<?> collection = (Collection<?>) value;
                        collection.forEach(item -> encryptFields(item));
                    } else if (value instanceof Map) {
                        // 处理Map字段
                        Map<?, ?> map = (Map<?, ?>) value;
                        map.forEach((key, val) -> encryptFields(val));
                    } else if (value != null && !value.getClass().isArray()) {
                        // 处理其他对象字段
                        encryptFields(value);
                    }
                }
            } catch (IllegalAccessException e) {
                throw new RuntimeException("Unable to access field", e);
            }
        }
    }

    public static String encrypt(String value) {
        // 实现加密逻辑
        return "encrypted_" + value;
    }

    public static String decrypt(String encryptedValue) {
        // 实现解密逻辑
        if (encryptedValue != null && encryptedValue.startsWith("encrypted_")) {
            return encryptedValue.substring("encrypted_".length());
        }
        return encryptedValue;
    }
}