AOP实现对多数据类型字段进行加密解密

紫荆之后-

已于 2022-12-16 17:55:48 修改

阅读量1.2k

点赞数 2

分类专栏： Java 文章标签：策略模式 AOP 加密算法 AES

于 2022-12-01 02:13:12 首次发布

本文链接：https://blog.csdn.net/qq_41683000/article/details/128125478

版权

Java 专栏收录该内容

10 篇文章 2 订阅

订阅专栏

前言

最近接到一个需求，需要在无感前提下对指定的字段进行数据加密和解密。首先对关键字进行提取，“无感”，“指定字段”，“加密解密”。无感很好理解，即对客户来说没有感知，对开发者来说不用修改代码，那就可以考虑AOP；指定字段如果想被AOP监控到可以在字段上加自定义注解，考虑到字段类型不唯一，需要对不同数据类型进行不同方式的加密，比如密码是int类型，那加密之后必须也是int类型，要想实现这个功能肯定要进行判断，然而作为一个有追求的程序员肯定不屑于用if else，这里考虑用策略模式定义接口和多个实现类来实现；至于加密解密，网上搜了一下，针对String类型选择了常用的AES加密方式配合base64转码，至于其他数据类型后期有需要再选择不同的加密方式。

关键字分析完毕，思路有了，理论上来说，首先我需要定义三个注解，分别是用在新增或更新方法上的加密注解、get方法上的解密注解和字段上的注解。在需要进行加密或解密的add或get方法上添加注解，AOP会对方法内的实体对象的字段进行扫描，看哪些字段需要进行加密或解密；其次我需要用策略模式实现对不同类型的字段进行不同方式的加解密，所以需要定义一个接口及若干实现类，这里为了演示方便只写一个String类型的实现类；最后就是要实现具体的加解密操作。

理论存在，实践开始

定义注解

该注解用在新增或更新方法上，AOP扫描到之后会对添加该注解的方法内的数据进行加密操作

package com.th.dp.test;

import java.lang.annotation.*;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface EncryptMethod {

}

该注解用在get类方法上，AOP扫描到之后会对添加该注解的方法返回的数据进行解密操作

package com.th.dp.test;

import java.lang.annotation.*;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DecryptMethod {

}

该注解用在字段上，AOP扫描到之后会对添加该注解的字段进行具体的加解密操作

package com.th.dp.test;

import java.lang.annotation.*;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface EncryptField {
    
}

定义策略模式的接口和实现类

package com.th.dp.test;

public interface EncryptComparator {

    Object encrypt(Object fieldValue);

    Object decrypt(Object fieldValue);
}

package com.th.dp.test;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Base64Utils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.lang.reflect.Field;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

public class EncryptStringByAES implements EncryptComparator {

    private static final Logger log = LoggerFactory.getLogger(EncryptUtils.class);
    private static final String KEY_ALGORITHM = "AES";
    private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法

	@Value("${encrypt.secretKey}")
    private String secretKey;

    /**
     * AES 加密操作
     *
     * @param content  待加密内容
     * @param password 加密密码
     * @return 返回Base64转码后的加密数据
     */
    public String encrypt(Object content) {
        try {
            Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
            byte[] byteContent = content.toString().getBytes("utf-8");
            cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(secretKey));// 初始化为加密模式的密码器
            byte[] result = cipher.doFinal(byteContent);// 加密
            return Base64Utils.encodeToString(result);
        } catch (Exception ex) {
            log.error(ex.getStackTrace().toString());
        }

        return null;
    }

    /**
     * AES 解密操作
     *
     * @param content
     * @param password
     * @return
     */
    public String decrypt(Object content) {
        try {
            //实例化
            Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
            //使用密钥初始化，设置为解密模式
            cipher.init(Cipher.DECRYPT_MODE, getSecretKey(secretKey));
            //执行操作
            byte[] result = cipher.doFinal(Base64Utils.decodeFromString(content.toString()));
            return new String(result, "utf-8");
        } catch (Exception ex) {
            log.error(ex.getStackTrace().toString());
        }

        return null;
    }

    /**
     * 生成加密秘钥
     *
     * @return
     */
    private static SecretKeySpec getSecretKey(final String password) {
        //返回生成指定算法密钥生成器的 KeyGenerator 对象
        KeyGenerator kg = null;
        try {
            kg = KeyGenerator.getInstance(KEY_ALGORITHM);
            //AES 要求密钥长度为 128
            kg.init(128, new SecureRandom(password.getBytes()));
            //生成一个密钥
            SecretKey secretKey = kg.generateKey();
            return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥
        } catch (NoSuchAlgorithmException ex) {
            log.error(ex.getStackTrace().toString());
        }
        return null;
    }

}

定义切面类

该类主要负责扫描注解并调用具体实现类的加解密方法，具体逻辑看注释

package com.th.dp.test;

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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

@Aspect
@Component
public class EncryptFieldAop {

    private static final Logger log = LoggerFactory.getLogger(EncryptUtils.class);

    @Value("${encrypt.encryptMode}")
    private String encryptMode;
	
	@Autowired
    private EncryptStringByAES encryptStringByAES;

    // 定义map用来存放数据类型和实现类的映射关系
    private Map<String, Object> map = new HashMap();

    // @PostConstruct作用：在spring容器初始化的时候执行该方法，Constructor >> @Autowired >> @PostConstruct
    // initial方法初始化数据类型和实现类的映射集合
    @PostConstruct
    public void initial() {
        map.put("java.lang.String&AES", encryptStringByAES);
    }

    // 加密注解的切点
    @Pointcut("@annotation(com.th.dp.test.EncryptMethod)")
    public void encryptPointCut() {
    }

    // 解密注解的切点
    @Pointcut("@annotation(com.th.dp.test.DecryptMethod)")
    public void decryptPointCut() {
    }

    // 识别加密注解并处理
    @Around("encryptPointCut()")
    public Object aroundToEn(ProceedingJoinPoint joinPoint) {
        Object responseObj = null;
        try {
            if (joinPoint.getArgs().length != 0) {
                Object requestObj = joinPoint.getArgs()[0];
                //方法进来就加密
                handleEncrypt(requestObj);
                //方法执行
                responseObj = joinPoint.proceed();
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
            log.error("SecureFieldAop处理出现异常{}", e);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            log.error("SecureFieldAop处理出现异常{}", throwable);
        }
        return responseObj;
    }

    // 识别解密注解并处理
    @Around("decryptPointCut()")
    public Object aroundToDe(ProceedingJoinPoint joinPoint) {
        Object responseObj = null;
        try {
            if (joinPoint.getArgs().length != 0) {
                //方法执行
                responseObj = joinPoint.proceed();
                //方法返回就解密
                handleDecrypt(responseObj);
            }

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
            log.error("SecureFieldAop处理出现异常{}", e);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            log.error("SecureFieldAop处理出现异常{}", throwable);
        }
        return responseObj;
    }

    /**
     * 处理加密
     *
     * @param requestObj
     */
    private void handleEncrypt(Object requestObj) {
        if (Objects.isNull(requestObj)) {
            return;
        }
        //获取入参对象的字段
        Field[] fields = requestObj.getClass().getDeclaredFields();
        // 对所有字段进行遍历找出添加注解的字段
        Arrays.stream(fields).filter(field -> field.isAnnotationPresent(EncryptField.class)).forEach(field -> {
            // accessible 标志被设置为true，那么反射对象在使用的时候，不会去检查Java语言权限控制（private之类的）
            field.setAccessible(true);
            try {
                // 获取字段值
                Object plaintextValue = field.get(requestObj);
                // 策略模式的实现，根据字段值类型在map中找到对应的实现类
                EncryptComparator encryptComparator = (EncryptComparator) map.get(plaintextValue.getClass().getName()+"&"+encryptMode);
                // 调用实现类的加密方法
                Object encryptValue = encryptComparator.encrypt(plaintextValue);
                // 加密后的字段重新赋值
                field.set(requestObj, encryptValue);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        });
    }

    /**
     * 处理解密
     *
     * @param responseObj
     */
    private Object handleDecrypt(Object responseObj) throws IllegalAccessException {
        if (Objects.isNull(responseObj)) {
            return null;
        }
        Field[] fields = responseObj.getClass().getDeclaredFields();
        Arrays.stream(fields).filter(field -> field.isAnnotationPresent(EncryptField.class)).forEach(field -> {
            field.setAccessible(true);
            try {
                Object plaintextValue = field.get(responseObj);
                EncryptComparator encryptComparator = (EncryptComparator) map.get(plaintextValue.getClass().getName()+"&"+encryptMode);
                Object encryptValue = encryptComparator.decrypt(plaintextValue);
                field.set(responseObj, encryptValue);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        });
        return responseObj;
    }

}