SpringBoot動態(tài)實現(xiàn)數(shù)據(jù)脫敏的實戰(zhàn)指南
更新時間：2025年12月18日 15:16:05 作者：悟空碼字
這篇文章主要為大家詳細(xì)介紹了SpringBoot動態(tài)實現(xiàn)數(shù)據(jù)脫敏的五種方法,文中的示例代碼講解詳細(xì),感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下
一、數(shù)據(jù)脫敏：數(shù)據(jù)界的“猶抱琵琶半遮面”
想象一下這樣的場景：你的身份證號、手機(jī)號、銀行卡號這些隱私數(shù)據(jù)，在系統(tǒng)中裸 奔——這簡直比在公共場所穿皇帝的新衣還尷尬！數(shù)據(jù)脫敏就是給這些敏感數(shù)據(jù)穿上得體的衣服。
數(shù)據(jù)脫敏的幾種常見姿勢：
- 靜態(tài)脫敏：像給照片打馬賽克，一勞永逸
- 動態(tài)脫敏：像智能變色玻璃，看人下菜碟
- 前端脫敏：只在展示時害羞一下
- 后端脫敏：從出生就帶著面具
二、SpringBoot脫敏方案實戰(zhàn)
方案1：注解+序列化方案（給字段貼上“此處打碼”標(biāo)簽）
步驟1：先來個脫敏注解，像給敏感部位貼標(biāo)簽
import java.lang.annotation.*;
/**
* 脫敏注解：給敏感字段貼上“此處需要打碼”的標(biāo)簽
* 就像在數(shù)據(jù)身上貼了個“兒童不宜”的警示條
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Sensitive {
/**
* 脫敏類型：決定怎么打碼
*/
SensitiveType type();
}
/**
* 脫敏類型枚舉：各種打碼方式任君選擇
*/
public enum SensitiveType {
/** 中文名：張*三 */
CHINESE_NAME,
/** 身份證號：110**********1234 */
ID_CARD,
/** 手機(jī)號：138****1234 */
PHONE,
/** 郵箱：t***@163.com */
EMAIL,
/** 銀行卡號：6217 **** **** 1234 */
BANK_CARD,
/** 地址：北京市海淀區(qū)**** */
ADDRESS
}
步驟2：實現(xiàn)脫敏序列化器，專業(yè)的“打碼師”
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import java.io.IOException;
/**
* 脫敏序列化器：專業(yè)的“馬賽克師傅”
* 負(fù)責(zé)給敏感數(shù)據(jù)穿上得體的衣服
*/
public class SensitiveSerializer extends JsonSerializer<String> {
private final SensitiveType type;
public SensitiveSerializer(SensitiveType type) {
this.type = type;
}
@Override
public void serialize(String value, JsonGenerator gen,
SerializerProvider serializers) throws IOException {
if (value == null) {
gen.writeNull();
return;
}
// 根據(jù)脫敏類型選擇不同的“打碼姿勢”
gen.writeString(maskData(value, type));
}
/**
* 核心脫敏邏輯：十八般武藝輪番上陣
*/
private String maskData(String data, SensitiveType type) {
if (data == null || data.isEmpty()) {
return data;
}
return switch (type) {
case CHINESE_NAME -> maskChineseName(data);
case ID_CARD -> maskIdCard(data);
case PHONE -> maskPhone(data);
case EMAIL -> maskEmail(data);
case BANK_CARD -> maskBankCard(data);
case ADDRESS -> maskAddress(data);
default -> data; // 默認(rèn)不脫敏，裸奔！
};
}
private String maskChineseName(String name) {
if (name.length() <= 1) return name;
if (name.length() == 2) return name.charAt(0) + "*";
return name.charAt(0) + "*" + name.charAt(name.length() - 1);
}
private String maskIdCard(String idCard) {
if (idCard.length() <= 8) return idCard;
return idCard.substring(0, 3) +
"*".repeat(Math.max(0, idCard.length() - 7)) +
idCard.substring(idCard.length() - 4);
}
private String maskPhone(String phone) {
if (phone.length() != 11) return phone;
return phone.substring(0, 3) + "****" + phone.substring(7);
}
private String maskEmail(String email) {
int atIndex = email.indexOf("@");
if (atIndex <= 1) return email;
return email.charAt(0) + "***" + email.substring(atIndex);
}
private String maskBankCard(String card) {
if (card.length() <= 8) return card;
return card.substring(0, 4) + " **** **** " +
card.substring(card.length() - 4);
}
private String maskAddress(String address) {
if (address.length() <= 4) return address;
return address.substring(0, address.length() - 4) + "****";
}
}
/**
* 注解序列化器：把注解和序列化器牽線搭橋
*/
public class SensitiveAnnotationIntrospector extends JacksonAnnotationIntrospector {
@Override
public Object findSerializer(Annotated am) {
Sensitive sensitive = am.getAnnotation(Sensitive.class);
if (sensitive != null) {
return new SensitiveSerializer(sensitive.type());
}
return super.findSerializer(am);
}
}
步驟3：配置Jackson，告訴它：“看這里，要打碼！”
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JacksonConfig {
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.setAnnotationIntrospector(new SensitiveAnnotationIntrospector());
return mapper;
}
}
步驟4：在實體類上使用，貼上標(biāo)簽就自動打碼
/**
* 用戶實體：敏感字段都穿上了“馬賽克小內(nèi)褲”
*/
@Data
public class UserDTO {
private Long id;
@Sensitive(type = SensitiveType.CHINESE_NAME)
private String username;
@Sensitive(type = SensitiveType.PHONE)
private String phone;
@Sensitive(type = SensitiveType.EMAIL)
private String email;
@Sensitive(type = SensitiveType.ID_CARD)
private String idCard;
@Sensitive(type = SensitiveType.BANK_CARD)
private String bankCard;
@Sensitive(type = SensitiveType.ADDRESS)
private String address;
// 這個字段沒注解，繼續(xù)裸奔
private String hobby;
}
步驟5：控制器測試一下效果
@RestController
@RequestMapping("/user")
public class UserController {
@GetMapping("/{id}")
public UserDTO getUser(@PathVariable Long id) {
// 模擬從數(shù)據(jù)庫查出的完整數(shù)據(jù)
UserDTO user = new UserDTO();
user.setId(id);
user.setUsername("張全蛋");
user.setPhone("13800138000");
user.setEmail("zhangquandan@example.com");
user.setIdCard("110101199001011234");
user.setBankCard("621700001234567890");
user.setAddress("北京市海淀區(qū)中關(guān)村大街1號");
user.setHobby("唱跳RAP籃球");
// 返回時自動脫敏，就像自動加了馬賽克
return user;
}
}
測試結(jié)果：
{
"id": 1,
"username": "張*蛋",
"phone": "138****8000",
"email": "z***@example.com",
"idCard": "110**********1234",
"bankCard": "6217 **** **** 7890",
"address": "北京市海淀區(qū)中關(guān)村大街****",
"hobby": "唱跳RAP籃球"
}
方案2：AOP切面方案（數(shù)據(jù)出門前的安檢員）
步驟1：定義脫敏策略接口
/**
* 脫敏策略：定義各種脫敏算法
* 就像不同的美顏濾鏡
*/
public interface SensitiveStrategy {
String mask(String data);
}
/**
* 策略工廠：根據(jù)類型選擇合適的濾鏡
*/
@Component
public class SensitiveStrategyFactory {
private final Map<SensitiveType, SensitiveStrategy> strategies = new HashMap<>();
public SensitiveStrategyFactory() {
// 注冊各種美顏濾鏡
strategies.put(SensitiveType.CHINESE_NAME, new ChineseNameStrategy());
strategies.put(SensitiveType.PHONE, new PhoneStrategy());
strategies.put(SensitiveType.ID_CARD, new IdCardStrategy());
// ... 其他策略
}
public SensitiveStrategy getStrategy(SensitiveType type) {
return strategies.getOrDefault(type, data -> data);
}
// 具體策略實現(xiàn)
private static class ChineseNameStrategy implements SensitiveStrategy {
@Override
public String mask(String data) {
if (data == null || data.length() <= 1) return data;
if (data.length() == 2) return data.charAt(0) + "*";
return data.charAt(0) + "*" + data.charAt(data.length() - 1);
}
}
private static class PhoneStrategy implements SensitiveStrategy {
@Override
public String mask(String data) {
if (data == null || data.length() != 11) return data;
return data.substring(0, 3) + "****" + data.substring(7);
}
}
// ... 其他策略實現(xiàn)
}
步驟2：AOP切面實現(xiàn)
@Aspect
@Component
@Slf4j
public class SensitiveAspect {
@Autowired
private SensitiveStrategyFactory strategyFactory;
/**
* 攔截所有Controller方法返回
* 就像在數(shù)據(jù)出門前設(shè)了個安檢門
*/
@Around("@annotation(org.springframework.web.bind.annotation.GetMapping) || " +
"@annotation(org.springframework.web.bind.annotation.PostMapping) || " +
"@annotation(org.springframework.web.bind.annotation.RequestMapping)")
public Object aroundController(ProceedingJoinPoint joinPoint) throws Throwable {
// 放行方法執(zhí)行
Object result = joinPoint.proceed();
// 給返回結(jié)果穿上衣服
return processSensitiveData(result);
}
/**
* 遞歸處理脫敏：連數(shù)據(jù)對象的子孫后代都不放過
*/
private Object processSensitiveData(Object obj) {
if (obj == null) return null;
// 如果是集合，給每個元素都穿上衣服
if (obj instanceof Collection) {
return processCollection((Collection<?>) obj);
}
// 如果是數(shù)組，也不放過
if (obj.getClass().isArray()) {
return processArray((Object[]) obj);
}
// 如果是Map，處理每個值
if (obj instanceof Map) {
return processMap((Map<?, ?>) obj);
}
// 如果是普通對象，深度掃描敏感字段
if (isCustomClass(obj.getClass())) {
return processObject(obj);
}
// 基本類型，直接返回
return obj;
}
private Object processObject(Object obj) {
Class<?> clazz = obj.getClass();
Object newObj;
try {
newObj = clazz.newInstance();
} catch (Exception e) {
log.warn("創(chuàng)建對象實例失敗: {}", clazz.getName());
return obj;
}
// 反射獲取所有字段
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
try {
Object value = field.get(obj);
// 如果有脫敏注解，穿上馬賽克
Sensitive sensitive = field.getAnnotation(Sensitive.class);
if (sensitive != null && value instanceof String) {
SensitiveStrategy strategy = strategyFactory.getStrategy(sensitive.type());
value = strategy.mask((String) value);
} else if (value != null) {
// 遞歸處理嵌套對象
value = processSensitiveData(value);
}
field.set(newObj, value);
} catch (Exception e) {
log.warn("處理字段 {} 失敗", field.getName(), e);
}
}
return newObj;
}
}
方案3：MyBatis攔截器方案（數(shù)據(jù)庫查詢時的美顏相機(jī)）
/**
* MyBatis攔截器：在數(shù)據(jù)從數(shù)據(jù)庫出來時實時美顏
*/
@Intercepts({
@Signature(type = ResultSetHandler.class,
method = "handleResultSets",
args = {Statement.class})
})
@Component
@Slf4j
public class SensitiveInterceptor implements Interceptor {
@Autowired
private SensitiveStrategyFactory strategyFactory;
@Override
public Object intercept(Invocation invocation) throws Throwable {
// 先執(zhí)行原方法獲取結(jié)果
Object result = invocation.proceed();
if (result == null) {
return null;
}
// 處理結(jié)果集
if (result instanceof List) {
for (Object obj : (List<?>) result) {
processObject(obj);
}
} else {
processObject(result);
}
return result;
}
private void processObject(Object obj) {
if (obj == null) return;
Class<?> clazz = obj.getClass();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Sensitive sensitive = field.getAnnotation(Sensitive.class);
if (sensitive != null) {
field.setAccessible(true);
try {
Object value = field.get(obj);
if (value instanceof String) {
SensitiveStrategy strategy = strategyFactory.getStrategy(sensitive.type());
String maskedValue = strategy.mask((String) value);
field.set(obj, maskedValue);
}
} catch (Exception e) {
log.error("脫敏處理失敗", e);
}
}
}
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
// 可以配置一些屬性
}
}
方案4：自定義消息轉(zhuǎn)換器方案（HTTP出口處的安檢機(jī)）
/**
* 自定義HTTP消息轉(zhuǎn)換器：在數(shù)據(jù)離開系統(tǒng)前最后一道安檢
*/
@Component
public class SensitiveHttpMessageConverter extends MappingJackson2HttpMessageConverter {
@Autowired
private SensitiveStrategyFactory strategyFactory;
@Override
protected void writeInternal(Object object, Type type,
HttpOutputMessage outputMessage) throws IOException {
// 先脫敏再序列化
Object processedObject = processSensitiveData(object);
super.writeInternal(processedObject, type, outputMessage);
}
// 脫敏處理方法（同上，省略重復(fù)代碼）
private Object processSensitiveData(Object obj) {
// 實現(xiàn)同AOP方案中的processSensitiveData方法
// ...
}
}
方案5：數(shù)據(jù)庫層脫敏方案（給數(shù)據(jù)庫戴上口罩）
/**
* Hibernate事件監(jiān)聽器：數(shù)據(jù)入庫時自動加密，出庫時自動解密
*/
@Component
public class SensitiveEventListener implements
PostLoadEventListener, PreInsertEventListener, PreUpdateEventListener {
@Autowired
private EncryptionService encryptionService;
@Override
public void onPostLoad(PostLoadEvent event) {
Object entity = event.getEntity();
// 加載后解密
decryptEntity(entity);
}
@Override
public boolean onPreInsert(PreInsertEvent event) {
// 插入前加密
encryptEntity(event.getEntity());
return false;
}
@Override
public boolean onPreUpdate(PreUpdateEvent event) {
// 更新前加密
encryptEntity(event.getEntity());
return false;
}
private void encryptEntity(Object entity) {
if (entity == null) return;
Field[] fields = entity.getClass().getDeclaredFields();
for (Field field : fields) {
if (field.isAnnotationPresent(SensitiveEncrypt.class)) {
field.setAccessible(true);
try {
Object value = field.get(entity);
if (value instanceof String) {
String encrypted = encryptionService.encrypt((String) value);
field.set(entity, encrypted);
}
} catch (Exception e) {
log.error("加密字段失敗", e);
}
}
}
}
private void decryptEntity(Object entity) {
// 類似encryptEntity，調(diào)用encryptionService.decrypt
}
}
三、脫敏方案選擇指南：對癥下藥
1.注解+序列化方案
適用場景：REST API返回數(shù)據(jù)脫敏
優(yōu)點：簡單優(yōu)雅，與業(yè)務(wù)解耦
缺點：只對JSON序列化有效
2.AOP切面方案
適用場景：需要對Controller層統(tǒng)一處理
優(yōu)點：集中管理，支持復(fù)雜邏輯
缺點：性能開銷，可能誤傷
3.MyBatis攔截器方案
適用場景：數(shù)據(jù)庫查詢結(jié)果脫敏
優(yōu)點：從源頭控制，一勞永逸
缺點：影響所有查詢，不夠靈活
4.自定義消息轉(zhuǎn)換器方案
適用場景：全局HTTP響應(yīng)處理
優(yōu)點：最徹底的出口控制
缺點：可能與其他組件沖突
5.數(shù)據(jù)庫層方案
適用場景：存儲加密，展示脫敏
優(yōu)點：最安全，防止數(shù)據(jù)泄露
缺點：影響查詢性能，實現(xiàn)復(fù)雜
四、最佳實踐建議
1.分層防御：不要把所有雞蛋放在一個籃子里
數(shù)據(jù)安全防護(hù)體系：
存儲層：加密存儲（最后的底線）
業(yè)務(wù)層：邏輯脫敏（靈活控制）
展示層：展示脫敏（用戶體驗）
2.配置化脫敏：像調(diào)美顏強(qiáng)度一樣可配置
@Component
@ConfigurationProperties(prefix = "sensitive")
@Data
public class SensitiveProperties {
/**
* 是否開啟脫敏
*/
private boolean enabled = true;
/**
* 脫敏規(guī)則配置
*/
private Map<SensitiveType, Rule> rules = new HashMap<>();
@Data
public static class Rule {
/**
* 保留前幾位
*/
private Integer keepPrefix = 3;
/**
* 保留后幾位
*/
private Integer keepSuffix = 4;
/**
* 替換字符
*/
private Character maskChar = '*';
}
}
3.性能優(yōu)化：脫敏也要注意效率
@Component
public class SensitiveCache {
private final Cache<String, String> cache =
Caffeine.newBuilder()
.maximumSize(10000)
.expireAfterWrite(5, TimeUnit.MINUTES)
.build();
public String maskWithCache(String data, SensitiveType type,
SensitiveStrategy strategy) {
String key = type.name() + ":" + data;
return cache.get(key, k -> strategy.mask(data));
}
}
4.監(jiān)控與日志：知道誰在什么時候脫敏
@Aspect
@Component
@Slf4j
public class SensitiveMonitorAspect {
@Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
public Object monitorSensitive(ProceedingJoinPoint joinPoint) throws Throwable {
long start = System.currentTimeMillis();
Object result = joinPoint.proceed();
long cost = System.currentTimeMillis() - start;
// 記錄脫敏統(tǒng)計
log.info("脫敏處理完成，方法：{}，耗時：{}ms",
joinPoint.getSignature(), cost);
return result;
}
}
五、總結(jié)：數(shù)據(jù)脫敏的智慧
數(shù)據(jù)脫敏就像給敏感數(shù)據(jù)穿上得體的衣服——既不能裸奔（安全風(fēng)險），也不能裹成木乃伊（影響使用）。通過SpringBoot的各種方案，我們可以：
- 因地制宜：根據(jù)不同的場景選擇合適的脫敏方案
- 層層設(shè)防：構(gòu)建多層次的數(shù)據(jù)安全防護(hù)體系
- 靈活配置：像調(diào)節(jié)美顏相機(jī)一樣輕松調(diào)整脫敏策略
- 性能平衡：在安全和性能之間找到最佳平衡點
沒有一種方案是萬能的。就像穿衣服要分場合（泳池穿泳衣，會議室穿正裝），數(shù)據(jù)脫敏也要根據(jù)具體場景選擇最合適的方案。
最終目標(biāo)：讓敏感數(shù)據(jù)既能保守秘密，又能履行職責(zé)。畢竟，數(shù)據(jù)的價值在于使用，而不是鎖在保險柜里吃灰。脫敏就是讓數(shù)據(jù)在"安全"和"可用"之間優(yōu)雅地走鋼絲！
// 最后送大家一個萬能脫敏方法
public String universalMask(String data) {
return "****"; // 簡單粗暴，但最安全?。ㄩ_玩笑的，別真用）
}
過多的脫敏會影響業(yè)務(wù)，過少的脫敏又存在風(fēng)險。找到那個剛剛好的平衡點，才是數(shù)據(jù)脫敏的最高境界！
以上就是SpringBoot動態(tài)實現(xiàn)數(shù)據(jù)脫敏的實戰(zhàn)指南的詳細(xì)內(nèi)容，更多關(guān)于SpringBoot數(shù)據(jù)脫敏的資料請關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
Java中調(diào)用Python的實現(xiàn)示例
本文主要介紹了Java中調(diào)用Python的實現(xiàn)示例，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2023-05-05
這篇文章主要給大家介紹了關(guān)于SpringBoot輕松整合MongoDB的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-01-01
java_時間戳與Date_相互轉(zhuǎn)化的實現(xiàn)代碼
本篇文章是對java_時間戳與Date_相互轉(zhuǎn)化的實現(xiàn)代碼進(jìn)行了詳細(xì)的分析介紹,需要的朋友參考下如下。2016-11-11
spring 整合mybatis后用不上session緩存的原因分析
因為一直用spring整合了mybatis，所以很少用到mybatis的session緩存。什么原因呢？下面小編給大家介紹spring 整合mybatis后用不上session緩存的原因分析,需要的朋友可以參考下2017-02-02
這篇文章主要介紹了使用ResponseEntity處理API返回問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-07-07
Java多線程編程之使用Exchanger數(shù)據(jù)交換實例
這篇文章主要介紹了Java多線程編程之使用Exchanger數(shù)據(jù)交換實例,本文直接給出實例代碼,需要的朋友可以參考下2015-05-05
這篇文章主要介紹了java操作cookie示例，包括設(shè)置Cookie、讀取Cookie、刪除Cookie,需要的朋友可以參考下2014-02-02
本文主要介紹了MyBatis查詢數(shù)據(jù)返回null的解決，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2023-02-02
這篇文章主要介紹了Java中通過反射實現(xiàn)代理Proxy代碼實例,java實現(xiàn)代理可以通過java.lang.reflect.Proxy接口結(jié)合java.lang.reflect.InvocationHandler來實現(xiàn),需要的朋友可以參考下2023-08-08
Spring的核心技術(shù)IOC(Intorol of Converse控制反轉(zhuǎn))的實現(xiàn)途徑是DI(dependency Insert依賴注入)。而依賴注入(DI)的實現(xiàn)方式又有兩種，xml方式和注解方式。本文就來詳細(xì)聊聊這兩個方式，需要的可以了解一下2022-10-10