利用aop 在访问接口修改之前 将前端参数修改(加密aes)

import java.lang.annotation.*;
/**
 * @author ：Nan
 * @date ：Created in 2021/9/19 13:26
 * @description：注解
 * @version: $
 */


@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface InterfaceFace {
    
}

aop切面层

import cn.xfdc.therehavehousr.utils.EncryptionUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;

@Aspect
@Order(2)
@Component
public class AesAspect {

    @Autowired
    private EncryptionUtil encryptionUtil;

    // 切面
    @Pointcut("@annotation(cn.xfdc.therehavehousr.annotation.InterfaceFace)")
    private void pointcut() {
    }
    
    //环绕通知
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //获取相关参数
        Object[] arguments = joinPoint.getArgs();
        if (arguments != null && arguments.length > 0) {
            for (int i = 0; i < arguments.length; i++) {
                // 参数加密  还是有问题的  当传入的参数为对象类型 无法怎么做 再想想办法
                String decrypt = encryptionUtil.decrypt(arguments[i] + "", "!$3*5@D&*…6-6^");
                arguments[i] = decrypt;
            }
            System.err.println(Arrays.toString(arguments));
        }
        // 脱敏参数
        Object proceed = joinPoint.proceed(arguments);
        return proceed;
    }
}

加密解密方法 aes cbc方式

import cn.hutool.core.codec.Base64;
import cn.xfdc.therehavehousr.data.constant.StaticConstant;
import lombok.SneakyThrows;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.springframework.stereotype.Service;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.AlgorithmParameters;
import java.security.Security;
import java.util.Arrays;

/**
 * @author : Nan
 * @date : 2021/07/09
 * @description : 加密解密
 */
@Service
public class EncryptionUtil {

    /**
     * aes cbc 加密
     *
     * @param src 被加密
     * @param key 秘钥
     * @return 加密后的
     */
    // region 加密
    @SneakyThrows
    public String encrypt(String src, String key) {
        byte[] raw = key.getBytes(StaticConstant.CHARSET_NAME);
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal(src.getBytes(StaticConstant.CHARSET_NAME));
        return Base64.encode(encrypted);
    }
    // endregion

    /**
     * aes cbc 解密
     *
     * @param src 密文
     * @param key 秘钥
     * @return 解密后的
     */
    // region 解密
    @SneakyThrows
    public String decrypt(String src, String key) {
        byte[] raw = key.getBytes(StaticConstant.CHARSET_NAME);
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, skeySpec);
        // 先用base64解密
        byte[] encrypted1 = Base64.decode(src);
        byte[] original = cipher.doFinal(encrypted1);
        return new String(original, StaticConstant.CHARSET_NAME);
    }
    // endregion

    // 微信获取用户信息解密
    @SneakyThrows
    public String get(String encryptedData, String sessionKey, String iv) {
        // 被加密的数据
        byte[] dataByte = Base64.decode(encryptedData);
        // 加密秘钥
        byte[] keyByte = Base64.decode(sessionKey);
        // 偏移量
        byte[] ivByte = Base64.decode(iv);
        // 如果密钥不足16位，那么就补足.  这个if 中的内容很重要
        int base = 16;
        if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + (keyByte.length % base != 0 ? 1 : 0);
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
        }

        // 初始化
        Security.addProvider(new BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding", "BC");
        SecretKeySpec spec = new SecretKeySpec(keyByte, "AES");
        AlgorithmParameters parameters = AlgorithmParameters.getInstance("AES");
        parameters.init(new IvParameterSpec(ivByte));
        cipher.init(Cipher.DECRYPT_MODE, spec, parameters);// 初始化
        byte[] resultByte = cipher.doFinal(dataByte);
        if (null != resultByte && resultByte.length > 0) {
            return new String(resultByte, StaticConstant.CHARSET_NAME);
        }
        return null;
    }
}