SpringBoot整合Jasypt使用自定義注解+AOP實現敏感字段加解密

更新時間：2025年09月29日 08:49:23 作者：Micro麥可樂

這篇文章主要為大家詳細介紹了SpringBoot整合Jasypt使用自定義注解+AOP實現敏感字段加解密的相關知識,文中的示例代碼講解詳細,有需要的小伙伴可以了解下

前言

在博主前面一篇文章中，相信小伙伴對 Spring Boot 中整合 Jasypt 以及加解密的方法有了一定的了解，沒看過的小伙伴可以訪問【Spring Boot整合Jasypt 庫實現配置文件和數據庫字段敏感數據的加解密】一起探討。

本章節(jié)我們針對 Jasypt 來做一些升級的玩法，使用自定義注解 + AOP 來實現敏感字段的加解密。

開始接入

步驟一：添加依賴

首先構建我們的 Spring Boot 項目, 引入相關依賴 Jasypt 和 Spring AOP 的依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>

步驟二：配置Jasypt

這里博主復用了上一篇教程的配置，如果你希望更深入的了解 YML配置和各項配置的說明，可以訪問

【Spring Boot整合Jasypt 庫實現配置文件和數據庫字段敏感數據的加解密】

import com.ulisesbocchio.jasyptspringboot.annotation.EnableEncryptableProperties;
import org.jasypt.encryption.StringEncryptor;
import org.jasypt.encryption.pbe.PooledPBEStringEncryptor;
import org.jasypt.encryption.pbe.config.SimpleStringPBEConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableEncryptableProperties
public class StringEncryptorConfig {
    @Bean("jasyptStringEncryptor")
    public StringEncryptor stringEncryptor() {
        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        SimpleStringPBEConfig config = new SimpleStringPBEConfig();
        config.setPassword("password");
        config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
        config.setKeyObtentionIterations("1000");
        config.setPoolSize("1");
        config.setProviderName("SunJCE");
        config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
        config.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");
        config.setStringOutputType("base64");
        encryptor.setConfig(config);
        return encryptor;
    }
}

步驟三：創(chuàng)建自定義注解

接下來，我們創(chuàng)建兩個自定義注解，用于標記需要加解密的字段以及方法

舉個例子

前端傳遞后端某些值需要加密入庫（需要方法注解是加密）
后端返回前端某些值需要解密顯示（需要方法注解是解密）

定義一個作用在字段的注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

定義一個作用在方法上的注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface JasyptMethod {
    String value() default "ENC"; //ENC：加密 DEC：解密
}

步驟四：創(chuàng)建AOP切面

創(chuàng)建一個AOP切面，主要思路是找到方法上標注了 JasyptMethod 注解且定義枚舉類型是加密還是解密，獲取到對應參數 joinPoint.getArgs() 在進行加密或是獲取返回對象解密，無論加密解密最后調用 proceed(Object[] args) 方法改變值

需要注意處理的問題

1、獲取參數如果是字符串，直接加密字符串

2、獲取參數是對象，則通過反射獲取對象字段上@JasyptField注解的字段進行加密；

3、獲取參數是集合，需要循環(huán)上一步驟操作

4、解密返回對象同樣需要處理字符串、對象、集合操作

注意看代碼解釋！注意看代碼解釋！注意看代碼解釋！

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
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.aspectj.lang.reflect.MethodSignature;
import org.jasypt.encryption.StringEncryptor;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.List;

@Aspect
@Component
@Slf4j
public class JasyptAspect {

    //注入加密類
    private final StringEncryptor stringEncryptor;

    // jasyptStringEncryptor 配置類中定義的名稱
    public JasyptAspect(@Qualifier("jasyptStringEncryptor") StringEncryptor stringEncryptor) {
        this.stringEncryptor = stringEncryptor;
    }


    @Pointcut("@annotation(JasyptMethod)")
    public void pointCut() {
    }


    @SneakyThrows
    @Around("pointCut())")
    public Object jasyptAround(ProceedingJoinPoint joinPoint) {
        Object proceed;
        //獲取注解類
        JasyptMethod jasyptMethod = ((MethodSignature) joinPoint.getSignature()).getMethod().getAnnotation(JasyptMethod.class);
        //獲取注解傳遞值
        String value = jasyptMethod.value();
        //獲取參數
        Object[] args = joinPoint.getArgs();
        // 這里可以定義常量或枚舉判斷，博主就直接判斷了
        if(value.equals("ENC")){
            for(int i=0 ; i < args.length ; i++){
                // 判斷字符串還是對象
                if(args[i] instanceof String) {
                    args[i] = stringEncryptor.encrypt(String.valueOf(args[i]));
                }else {
                    //對象 還分集合還是單個對象
                    boolean isList = (args[i] instanceof List<?>);
                    handlerArgs(args[i], value, isList);
                }
            }
            proceed = joinPoint.proceed(args);
        }else{
            proceed = joinPoint.proceed();
            // 判斷字符串還是對象
            if(proceed instanceof String) {
                proceed = stringEncryptor.decrypt(String.valueOf(proceed));
            }else {
                //對象 還分集合還是單個對象
                boolean isList = (proceed instanceof List<?>);
                handlerArgs(proceed, value, isList);
            }
        }
        return proceed;
    }

    /**
     * 處理對象加解密
     * @param obj 參數對象
     * @param value 加解密值
     * @param isList 是否集合
     */
    private void handlerArgs(Object obj , String value , boolean isList){
        if(isList){
            List<Object> objs = (List<Object>)obj;
            for(Object o : objs){
                handlerFields(o, value);
            }
        }else{
            handlerFields(obj, value);
        }
    }

    /**
     * 抽取公共處理字段加解密方法
     * @param obj
     * @param value
     */
    private void handlerFields(Object obj , String value){
        Field[] fields = obj.getClass().getDeclaredFields();
        for(Field field : fields){
            //判斷是否存在注解
            boolean hasJasyptField = field.isAnnotationPresent(JasyptField.class);
            if (hasJasyptField) {
                try {
                    field.setAccessible(true);
                    String plaintextValue = null;
                    plaintextValue = (String)field.get(obj);
                    String handlerValue;
                    if(value.equals("ENC")){
                        handlerValue = stringEncryptor.encrypt(plaintextValue); //處理加密
                    }
                    else{
                        handlerValue = stringEncryptor.decrypt(plaintextValue); //處理解密
                    }
                    field.set(obj, handlerValue);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

步驟四：創(chuàng)建示例實體類

模擬一個User類，包含需要加密的字段，并使用 @JasyptField 注解標記

import lombok.Data;

@Data
public class UserDto {

    @JasyptField
    private String phone;

    @JasyptField
    private String idCard;

    private int age;
}

步驟五：創(chuàng)建測試Controller

創(chuàng)建一個 Controller ，用于處理用戶請求，主要模擬保存單個對象、集合對象，以及返回單個對象、集合對象的操作

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api")
@Slf4j
public class JasyptController {

    /**
     * 參數是字符串
     * @param text
     * @return
     */
    @RequestMapping("/param-text")
    @JasyptMethod
    public String isStringParam(String text){
        log.info("參數是字符串: {}" ,  text);
        return text;
    }

    /**
     * 參數是 單個對象
     * @param userDto
     * @return
     */
    @RequestMapping("/insert-user")
    @JasyptMethod
    public UserDto insertUser(@RequestBody UserDto userDto){
        log.info("參數是對象: {}" , userDto.toString());
        //TODO 操縱入庫
        return userDto;
    }

    /**
     * 參數是 集合對象
     * @param userDtos
     * @return
     */
    @RequestMapping("/insert-users")
    @JasyptMethod
    public List<UserDto> insertUsers(@RequestBody List<UserDto> userDtos){
        log.info("參數是集合: {}", userDtos.toString());
        //TODO 操縱入庫
        return userDtos;
    }
    
    /**
     * 返回是對象
     * @return
     */
    @RequestMapping("/get-user")
    @JasyptMethod("DEC")
    public UserDto getUser(){
        //模擬數據庫取出
        UserDto userDto = new UserDto();
        userDto.setAge(10);
        userDto.setPhone("WyXyMRDDdvZEri1XcsPyMA/Pxv+f/N9ODU612IXi4HazSK5NicKK+zZJKolEz8bv");
        userDto.setIdCard("/KP3oTWB4pDRyyio54fJ+634pIS7VyVxltNACLG/gtDof4UDYTICMd+zsimbHGDJ0JwiubTLhHqMNxztyAU7zg==");
        return userDto;
    }

    /**
     * 返回是集合對象
     * @return
     */
    @RequestMapping("/get-users")
    @JasyptMethod("DEC")
    public List<UserDto> getUsers(){
        //模擬數據庫取出
        UserDto userDto = new UserDto();
        userDto.setAge(10);
        userDto.setPhone("WyXyMRDDdvZEri1XcsPyMA/Pxv+f/N9ODU612IXi4HazSK5NicKK+zZJKolEz8bv");
        userDto.setIdCard("/KP3oTWB4pDRyyio54fJ+634pIS7VyVxltNACLG/gtDof4UDYTICMd+zsimbHGDJ0JwiubTLhHqMNxztyAU7zg==");

        UserDto userDto2 = new UserDto();
        userDto2.setAge(100);
        userDto2.setPhone("WyXyMRDDdvZEri1XcsPyMA/Pxv+f/N9ODU612IXi4HazSK5NicKK+zZJKolEz8bv");
        userDto2.setIdCard("/KP3oTWB4pDRyyio54fJ+634pIS7VyVxltNACLG/gtDof4UDYTICMd+zsimbHGDJ0JwiubTLhHqMNxztyAU7zg==");

        List<UserDto> userDtos = new ArrayList<>();
        userDtos.add(userDto);
        userDtos.add(userDto2);
        return userDtos;
    }
}

步驟六：驗證功能

運行 Spring Boot 應用程序，并發(fā)送請求到接口。觀察請求和響應中的數據，確保密碼字段已被加密

加密參數是字符串

加密參數是對象

加密參數是集合

解密返回是對象

解密返回是集合

至此，我們所有測試均已通過，小伙伴們可以復制博主的代碼進行測試，編寫的代碼結構如下（僅為了演示，所有類都放在一個包下）

結語

通過本文的步驟，我們成功地在Spring Boot項目中整合了Jasypt，并使用自定義注解結合AOP實現了敏感字段的自動加解密。這種方法不僅提高了代碼的可讀性和可維護性，還增強了數據的安全性。在實際項目中，您可以進一步擴展和優(yōu)化這個示例（比如數據入庫、數據查詢等），以適應更多復雜的需求。

到此這篇關于SpringBoot整合Jasypt使用自定義注解+AOP實現敏感字段加解密的文章就介紹到這了,更多相關SpringBoot Jasypt加解密內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: