Springboot AOP对指定敏感字段数据加密存储的实现

下面是详细的攻略：

一、前置知识

在介绍 AOP 对指定敏感字段数据加密存储的实现前，需要对以下知识点有基本了解：

• SpringBoot 框架
• SpringBoot AOP 相关概念
• 数据库加密存储方式

二、定义需求

我们需要实现一个 AOP 拦截器，拦截指定的敏感字段数据，进行加密处理后再存储到数据库中。

三、AOP 实现

1. Maven 依赖

我们需要添加 AOP 相关的 Maven 依赖：

<dependencies>
    <!-- SpringBoot AOP 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <!-- 密码加密依赖 -->
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-crypto</artifactId>
    </dependency>
</dependencies>

2. 注解定义

我们需要定义一个注解，用于标识需要加密存储的敏感字段：

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

3. 切面编写

我们需要编写一个 AOP 切面，用于拦截被标记需要加密的字段，并进行加密处理。

@Aspect
@Component
public class DataEncryptAspect {
    /**
     * 加密服务
     */
    private CryptoServices cryptoServices;

    @Autowired
    public void setCryptoServices(CryptoServices cryptoServices) {
        this.cryptoServices = cryptoServices;
    }

    /**
     * 加密切面
     *
     * @param point 切点
     * @return 返回值
     * @throws Throwable 异常
     */
    @Around("@annotation(com.example.myproject.annotation.EncryptField)")
    public Object encrypt(ProceedingJoinPoint point) throws Throwable {
        // 获取参数值
        Object[] args = point.getArgs();
        for (Object obj : args) {
            // 获取敏感字段
            Field[] fields = obj.getClass().getDeclaredFields();
            for (Field field : fields) {
                if (field.isAnnotationPresent(EncryptField.class)) {
                    field.setAccessible(true);
                    Object fieldValue = field.get(obj);
                    if (fieldValue != null && StringUtils.isNotBlank(fieldValue.toString())) {
                        // 加密
                        String encryptedValue = cryptoServices.encrypt(fieldValue.toString());
                        // 存储到数据库
                        field.set(obj, encryptedValue);
                    }
                }
            }
        }
        return point.proceed(args);
    }
}

4. 加密服务

我们需要实现一个加密服务，用于对数据进行加密处理。

@Service
public class CryptoServices {
    /**
     * 加密盐值
     */
    private static final String SALT = "1234567890";

    /**
     * 加密算法
     */
    private static final String ALGORITHM = "PBEWithMD5AndDES";

    /**
     * 迭代次数
     */
    private static final int ITERATIONS = 1000;

    /**
     * 密钥
     */
    private static final byte[] KEY = SALT.getBytes();

    /**
     * 加密
     *
     * @param data 待加密数据
     * @return 返回加密数据
     */
    public String encrypt(String data) {
        if (StringUtils.isBlank(data)) {
            return data;
        }
        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        encryptor.setAlgorithm(ALGORITHM);
        encryptor.setPassword(SALT);
        encryptor.setSaltGenerator(new RandomSaltGenerator());
        encryptor.setKeyObtentionIterations(ITERATIONS);
        encryptor.setProvider(new BouncyCastleProvider());
        return encryptor.encrypt(data);
    }
}

四、应用举例

1. 定义实体

public class User {
    /**
     * 用户ID
     */
    private Long id;

    /**
     * 用户名
     */
    private String username;

    /**
     * 密码
     */
    @EncryptField
    private String password;
}

2. 方法调用

@Service
public class UserService {
    /**
     * UserRepository
     */
    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    /**
     * 保存用户
     *
     * @param user 用户
     * @return 返回保存结果
     */
    public User save(User user) {
        return userRepository.save(user);
    }

    /**
     * 查询用户列表
     *
     * @return 返回用户列表
     */
    public List<User> list() {
        return userRepository.findAll();
    }
}

3. 验证加密存储

@SpringBootTest
public class UserServiceTest {
    /**
     * UserService
     */
    @Autowired
    private UserService userService;

    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("Tom");
        user.setPassword("123456");

        User savedUser = userService.save(user);
        Assert.assertEquals(savedUser.getPassword(), "密文");
    }

    @Test
    public void testList() {
        User user = new User();
        user.setUsername("Tom");
        user.setPassword("123456");
        userService.save(user);

        User savedUser = userService.list().get(0);
        Assert.assertEquals(savedUser.getPassword(), "密文");
    }
}

五、总结

通过本攻略，我们实现了使用 SpringBoot AOP 对指定敏感字段数据加密存储的功能，有效保护了敏感数据的安全性。