拋棄AOP！SpringBoot + YAML 零侵入數(shù)據(jù)脫敏神操作！

作者：儒猿團(tuán)隊(duì) 2025-09-09 09:34:37

不用寫復(fù)雜的 AOP 切面，不用改業(yè)務(wù)代碼，只改改 YAML 配置，就能實(shí)現(xiàn)接口響應(yīng)脫敏，還支持動(dòng)態(tài)配置、日志脫敏、性能優(yōu)化，新手也能快速上手。

兄弟們，今天咱們來聊個(gè)老生常談但又總讓人頭疼的話題 —— 數(shù)據(jù)脫敏。先跟大家嘮嘮我之前踩過的坑啊：去年做一個(gè)用戶中心項(xiàng)目，產(chǎn)品經(jīng)理拍著桌子說 “用戶手機(jī)號(hào)、身份證號(hào)必須脫敏！日志里不能有明文，接口返回也不能漏！”。我當(dāng)時(shí)一拍胸脯 “小意思，AOP 搞定！”，結(jié)果呢？

寫了個(gè)@SensitiveField注解，又搞了個(gè)切面攔截 Controller 返回值，用反射遍歷字段處理。一開始挺順利，直到遇到嵌套對(duì)象 —— 比如User里套了個(gè)Address，Address里有個(gè)contactPhone要脫敏，我那切面直接懵了，遞歸反射寫了三層才搞定；后來又遇到集合，List<User>得循環(huán)處理每個(gè)元素，代碼越改越亂，最后切面里全是 if-else，跟個(gè)迷宮似的。

更坑的是上線后，運(yùn)維說 “你這接口響應(yīng)慢了 100ms”，查了半天發(fā)現(xiàn)是反射次數(shù)太多，尤其是高并發(fā)的時(shí)候，CPU 占用直接上去了。當(dāng)時(shí)我就想：就不能有個(gè)不用寫切面、不用改業(yè)務(wù)代碼，甚至連實(shí)體類都不用動(dòng)的脫敏方案嗎？

還真讓我找到了！今天就給大家分享這個(gè) “偷懶神器”——SpringBoot + YAML 零侵入數(shù)據(jù)脫敏方案。不用 AOP，不用加注解，改改配置文件就能搞定，新手看一遍也能上手，看完你絕對(duì)想收藏！

一、先搞懂：為啥要做數(shù)據(jù)脫敏？別等踩坑才后悔

在講方案之前，先跟沒接觸過脫敏的兄弟補(bǔ)補(bǔ)課 —— 別覺得脫敏是 “多此一舉”，等出了問題你就知道有多重要了。

舉個(gè)真實(shí)案例：前兩年某電商平臺(tái)，開發(fā)在日志里打印了用戶的銀行卡號(hào)（明文），結(jié)果被黑客通過日志漏洞爬走了，最后不僅賠了用戶錢，還被監(jiān)管罰了幾百萬。你說這虧不虧？

咱們?nèi)粘ｉ_發(fā)里，需要脫敏的場(chǎng)景主要有 3 個(gè)：

接口返回：給前端返回用戶信息時(shí)，手機(jī)號(hào)不能是13800138000，得是1388000；身份證號(hào)不能是110101199001011234，得是110101****1234
日志打印：不管是業(yè)務(wù)日志還是異常日志，只要有敏感信息，必須脫敏，不然日志文件就是 “定時(shí)炸彈”
數(shù)據(jù)庫存儲(chǔ)：這個(gè)得區(qū)分情況 —— 像手機(jī)號(hào)、郵箱可以存明文（但響應(yīng)和日志要脫敏），但銀行卡號(hào)、身份證號(hào)這種高敏感信息，數(shù)據(jù)庫里最好存加密后的結(jié)果，脫敏只負(fù)責(zé) “前端展示”

簡單說：脫敏的核心是 “該看的人能看，不該看的人看不到”，既保證用戶信息安全，又不影響業(yè)務(wù)正常運(yùn)行。

之前用 AOP 做脫敏，雖然能實(shí)現(xiàn)功能，但有 3 個(gè)致命問題：

侵入性強(qiáng)：得給實(shí)體類加注解，改業(yè)務(wù)代碼，萬一后續(xù)要改脫敏規(guī)則，牽一發(fā)動(dòng)全身
代碼復(fù)雜：處理嵌套對(duì)象、集合、基本類型，反射邏輯寫得頭暈，還容易出 bug
性能拉胯：反射次數(shù)多，高并發(fā)場(chǎng)景下接口響應(yīng)變慢，CPU 占用飆升

而今天要講的方案，完美解決這 3 個(gè)問題 ——零侵入、配置化、輕量級(jí)，咱們一步步來拆解。

二、核心原理：SpringBoot 自帶的 “響應(yīng)攔截神器”，比 AOP 更輕

很多兄弟不知道，SpringMVC 里有個(gè)叫ResponseBodyAdvice的接口，它能在 “響應(yīng)體返回給前端之前” 攔截處理，相當(dāng)于給響應(yīng)加了個(gè) “過濾器”。

咱們之前用 AOP，還得自己寫切面、定義切點(diǎn)（比如攔截所有@RestController的方法），而ResponseBodyAdvice是 Spring 官方提供的擴(kuò)展點(diǎn)，不用處理復(fù)雜的切面表達(dá)式，也不用考慮攔截順序，比 AOP 更簡單、更輕量。

舉個(gè)通俗的例子：如果把接口響應(yīng)比作 “快遞”，ResponseBodyAdvice就是 “快遞分揀員”，在快遞送到用戶（前端）手里之前，先檢查一下里面有沒有 “敏感物品”（敏感字段），有就按規(guī)則 “包裝一下”（脫敏），再送出去。

整個(gè)方案的核心邏輯就是：

用ResponseBodyAdvice攔截所有接口響應(yīng)
從 YAML 配置里讀取 “哪些接口、哪些字段需要脫敏”
對(duì)響應(yīng)體里的敏感字段按規(guī)則處理
把處理后的響應(yīng)體返回給前端

全程不用改業(yè)務(wù)代碼，不用加注解，所有規(guī)則都在 YAML 里配置，這就是 “零侵入” 的關(guān)鍵！

三、實(shí)戰(zhàn)步驟：從 0 到 1 實(shí)現(xiàn)，復(fù)制代碼就能用

咱們先定個(gè)目標(biāo)：實(shí)現(xiàn)兩個(gè)接口的脫敏需求

接口 1：GET /api/user/get，返回用戶信息，需要脫敏phone（手機(jī)號(hào)）和idCard（身份證號(hào)）
接口 2：POST /api/order/list，返回訂單列表，需要脫敏bankCard（銀行卡號(hào)）和user.phone（嵌套字段）

環(huán)境準(zhǔn)備：JDK 1.8+，SpringBoot 2.7.x（其他版本也能用，差別不大）

第一步：引入依賴，就兩個(gè)，不多加

首先創(chuàng)建一個(gè) SpringBoot 項(xiàng)目，然后在pom.xml里加兩個(gè)依賴：

spring-boot-starter-web：必備，不用多說
hutool-all：國產(chǎn)工具包，里面有很多現(xiàn)成的脫敏方法，省得咱們自己寫正則

<dependencies>
    <!-- SpringBoot Web核心依賴 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Hutool工具包：簡化脫敏、字符串處理 -->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.8.20</version> <!-- 用最新版就行 -->
    </dependency>
    <!-- 可選：如果用Lombok，加這個(gè)，能少寫getter/setter -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

Hutool 不是必須的，如果你不想引入第三方包，自己寫正則也能實(shí)現(xiàn)脫敏，后面會(huì)講怎么自定義。

第二步：寫 YAML 配置，脫敏規(guī)則全在這里定

最關(guān)鍵的一步來了！咱們?cè)赼pplication.yml里配置脫敏規(guī)則，不用改任何 Java 代碼。

先看配置結(jié)構(gòu)，我都加了注釋，一看就懂：

# 應(yīng)用基礎(chǔ)配置
spring:
  application:
    name: sensitive-demo
  # 多環(huán)境配置：開發(fā)環(huán)境可以關(guān)閉脫敏，方便調(diào)試
  profiles:
    active: dev
# 脫敏核心配置：dev環(huán)境（開發(fā)）
---
spring:
  config:
    activate:
      on-profile: dev
# 開發(fā)環(huán)境關(guān)閉脫敏，方便調(diào)試接口，看明文數(shù)據(jù)
sensitive:
  enabled: false
# 脫敏核心配置：prod環(huán)境（生產(chǎn)）
---
spring:
  config:
    activate:
      on-profile: prod
sensitive:
  enabled: true # 生產(chǎn)環(huán)境開啟脫敏
  # 接口脫敏映射：按接口配置需要脫敏的字段
  mappings:
    # 第一個(gè)接口：獲取用戶信息
    - path: /api/user/get
      method: GET # 請(qǐng)求方法：GET/POST/PUT/DELETE，不區(qū)分大小寫
      fields: # 需要脫敏的字段
        - name: phone # 字段名：對(duì)應(yīng)響應(yīng)體里的phone字段
          rule: mobile # 脫敏規(guī)則：mobile（手機(jī)號(hào)）
        - name: idCard # 字段名：身份證號(hào)
          rule: idCard # 脫敏規(guī)則：idCard（身份證號(hào)）
    # 第二個(gè)接口：獲取訂單列表
    - path: /api/order/list
      method: POST
      fields:
        - name: bankCard # 字段名：銀行卡號(hào)
          rule: bankCard # 脫敏規(guī)則：bankCard（銀行卡號(hào)）
        - name: user.phone # 嵌套字段：order里的user對(duì)象的phone字段
          rule: mobile
    # 可以繼續(xù)加更多接口...
  # 自定義脫敏規(guī)則：如果Hutool的規(guī)則不夠用，自己加
  custom-rules:
    # 比如自定義郵箱脫敏規(guī)則：zhangsan@163.com → zh****@163.com
    - name: email
      regex: "([a-zA-Z0-9_]{2})[a-zA-Z0-9_]*@([a-zA-Z0-9.]+)" # 正則表達(dá)式
      replacement: "$1****@$2" # 替換規(guī)則：$1是第一個(gè)分組，$2是第二個(gè)分組

這里有幾個(gè)關(guān)鍵點(diǎn)要說明：

多環(huán)境區(qū)分：開發(fā)環(huán)境（dev）關(guān)閉脫敏，方便調(diào)試；生產(chǎn)環(huán)境（prod）開啟，保證安全。不用每次改代碼，切換環(huán)境就行。
接口映射：每個(gè)mapping對(duì)應(yīng)一個(gè)接口，path是接口路徑，method是請(qǐng)求方法，fields是需要脫敏的字段。
嵌套字段：支持user.phone這種嵌套字段，不管嵌套多少層，用 “.” 分隔就行。
脫敏規(guī)則：內(nèi)置了mobile、idCard、bankCard三種規(guī)則（后面會(huì)講怎么實(shí)現(xiàn)），還支持自定義規(guī)則（比如上面的email）。

第三步：把 YAML 配置映射成 Java 對(duì)象

SpringBoot 不能直接讀取 YAML 里的復(fù)雜結(jié)構(gòu)（比如mappings列表），所以咱們要寫個(gè)配置類，把 YAML 配置映射成 Java 對(duì)象，方便后續(xù)使用。

用@ConfigurationProperties注解就能實(shí)現(xiàn)，代碼很簡單：

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;
/**
 * 脫敏配置類：把YAML里的sensitive配置映射成Java對(duì)象
 */
@Component
@ConfigurationProperties(prefix = "sensitive") // 對(duì)應(yīng)YAML里的sensitive節(jié)點(diǎn)
@Data // Lombok注解，省得寫getter/setter
public class SensitiveProperties {
    /**
     * 是否開啟脫敏功能：true=開啟，false=關(guān)閉
     */
    private boolean enabled = false;
    /**
     * 接口脫敏映射列表
     */
    private List<SensitiveMapping> mappings;
    /**
     * 自定義脫敏規(guī)則列表
     */
    private List<CustomRule> customRules;
    /**
     * 單個(gè)接口的脫敏配置
     */
    @Data
    public static class SensitiveMapping {
        /**
         * 接口路徑：比如/api/user/get
         */
        private String path;
        /**
         * 請(qǐng)求方法：GET/POST/PUT/DELETE，不區(qū)分大小寫
         */
        private String method;
        /**
         * 該接口需要脫敏的字段列表
         */
        private List<SensitiveField> fields;
    }
    /**
     * 單個(gè)字段的脫敏配置
     */
    @Data
    public static class SensitiveField {
        /**
         * 字段名：支持嵌套字段，比如user.phone
         */
        private String name;
        /**
         * 脫敏規(guī)則：比如mobile、idCard、bankCard，或自定義規(guī)則名
         */
        private String rule;
    }
    /**
     * 自定義脫敏規(guī)則
     */
    @Data
    public static class CustomRule {
        /**
         * 規(guī)則名：比如email，在fields.rule里引用
         */
        private String name;
        /**
         * 正則表達(dá)式：用來匹配敏感字段
         */
        private String regex;
        /**
         * 替換規(guī)則：比如$1****@$2
         */
        private String replacement;
    }
}

這里用了 Lombok 的@Data注解，如果你沒加 Lombok 依賴，自己寫 getter 和 setter 就行，功能一樣。

第四步：實(shí)現(xiàn)脫敏工具類，規(guī)則全在這里

接下來寫個(gè)脫敏工具類，負(fù)責(zé)實(shí)現(xiàn)具體的脫敏邏輯 —— 包括內(nèi)置規(guī)則（手機(jī)號(hào)、身份證號(hào)、銀行卡號(hào)）和自定義規(guī)則（從 YAML 里讀）。

咱們用 Hutool 的DesensitizedUtil來實(shí)現(xiàn)內(nèi)置規(guī)則，省得自己寫正則，效率更高：

import cn.hutool.core.util.DesensitizedUtil;
import cn.hutool.core.util.StrUtil;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
/**
 * 脫敏工具類：實(shí)現(xiàn)各種脫敏規(guī)則
 */
@Component
public class SensitiveUtil {
    /**
     * 自定義脫敏規(guī)則緩存：key=規(guī)則名，value=正則Pattern
     */
    private final Map<String, Pattern> customRulePatterns = new HashMap<>();
    /**
     * 自定義脫敏替換規(guī)則緩存：key=規(guī)則名，value=替換字符串
     */
    private final Map<String, String> customRuleReplacements = new HashMap<>();
    @Resource
    private SensitiveProperties sensitiveProperties;
    /**
     * 初始化：把YAML里的自定義規(guī)則加載到緩存
     */
    public void init() {
        if (sensitiveProperties.getCustomRules() == null) {
            return;
        }
        // 遍歷自定義規(guī)則，編譯正則表達(dá)式并緩存
        for (SensitiveProperties.CustomRule customRule : sensitiveProperties.getCustomRules()) {
            customRulePatterns.put(
                    customRule.getName(),
                    Pattern.compile(customRule.getRegex())
            );
            customRuleReplacements.put(
                    customRule.getName(),
                    customRule.getReplacement()
            );
        }
    }
    /**
     * 核心方法：根據(jù)規(guī)則脫敏字符串
     * @param value 原始字符串（比如手機(jī)號(hào)13800138000）
     * @param rule  脫敏規(guī)則（比如mobile）
     * @return 脫敏后的字符串（比如138****8000）
     */
    public String desensitize(String value, String rule) {
        // 1. 空值直接返回，避免空指針
        if (StrUtil.isBlank(value)) {
            return value;
        }
        // 2. 處理內(nèi)置規(guī)則
        switch (rule.toLowerCase()) {
            case "mobile": // 手機(jī)號(hào)脫敏：138****8000
                return DesensitizedUtil.mobilePhone(value);
            case "idcard": // 身份證號(hào)脫敏：110101********1234
                return DesensitizedUtil.idCardNum(value, 6, 4);
            case "bankcard": // 銀行卡號(hào)脫敏：6222*******1234
                return DesensitizedUtil.bankCard(value);
            default: // 3. 處理自定義規(guī)則
                return handleCustomRule(value, rule);
        }
    }
    /**
     * 處理自定義脫敏規(guī)則
     */
    private String handleCustomRule(String value, String rule) {
        // 檢查自定義規(guī)則是否存在
        if (!customRulePatterns.containsKey(rule) || !customRuleReplacements.containsKey(rule)) {
            return value; // 規(guī)則不存在，返回原始值，避免報(bào)錯(cuò)
        }
        // 用自定義的正則和替換規(guī)則處理
        Pattern pattern = customRulePatterns.get(rule);
        String replacement = customRuleReplacements.get(rule);
        return pattern.matcher(value).replaceAll(replacement);
    }
}

這里有兩個(gè)關(guān)鍵點(diǎn)：

初始化方法：把 YAML 里的自定義規(guī)則編譯成Pattern緩存起來，避免每次脫敏都重新編譯正則（正則編譯很耗時(shí)，緩存能提高性能）。
內(nèi)置規(guī)則：直接用 Hutool 的DesensitizedUtil，里面還有很多其他規(guī)則（比如郵箱、密碼），如果需要可以自己加。
自定義規(guī)則：通過正則匹配和替換實(shí)現(xiàn)，靈活度很高，不管是郵箱、地址還是其他敏感字段，都能搞定。

第五步：實(shí)現(xiàn)核心攔截器，用 ResponseBodyAdvice

這是整個(gè)方案的 “靈魂”—— 用ResponseBodyAdvice攔截響應(yīng)體，然后調(diào)用上面的工具類進(jìn)行脫敏。

不用寫 AOP 切面，不用定義切點(diǎn)，只要實(shí)現(xiàn)ResponseBodyAdvice接口就行，代碼比 AOP 簡單多了：

import cn.hutool.core.util.StrUtil;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
import javax.annotation.Resource;
import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
 * 響應(yīng)體脫敏攔截器：用ResponseBodyAdvice實(shí)現(xiàn)零侵入脫敏
 */
@ControllerAdvice // 全局?jǐn)r截所有@Controller的響應(yīng)
public class SensitiveResponseBodyAdvice implements ResponseBodyAdvice<Object> {
    @Resource
    private SensitiveProperties sensitiveProperties;
    @Resource
    private SensitiveUtil sensitiveUtil;
    /**
     * 接口脫敏配置緩存：key=path#method（比如/api/user/get#GET），value=該接口的敏感字段列表
     */
    private final Map<String, List<SensitiveProperties.SensitiveField>> sensitiveFieldCache = new ConcurrentHashMap<>();
    /**
     * 初始化：1. 初始化脫敏工具類 2. 緩存接口脫敏配置
     */
    @PostConstruct
    public void init() {
        // 1. 初始化脫敏工具類（加載自定義規(guī)則）
        sensitiveUtil.init();
        // 2. 緩存接口脫敏配置，避免每次請(qǐng)求都遍歷mappings
        if (sensitiveProperties.getMappings() == null) {
            return;
        }
        for (SensitiveProperties.SensitiveMapping mapping : sensitiveProperties.getMappings()) {
            // 生成key：path#method（統(tǒng)一轉(zhuǎn)小寫，避免大小寫問題）
            String key = mapping.getPath().toLowerCase() + "#" + mapping.getMethod().toLowerCase();
            sensitiveFieldCache.put(key, mapping.getFields());
        }
    }
    /**
     * 第一步：判斷當(dāng)前請(qǐng)求是否需要脫敏
     * @param returnType 方法返回類型
     * @param converterType 消息轉(zhuǎn)換器類型
     * @return true=需要脫敏，false=不需要
     */
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 1. 如果脫敏功能關(guān)閉，直接返回false
        if (!sensitiveProperties.isEnabled()) {
            return false;
        }
        // 2. 只處理JSON響應(yīng)（大部分項(xiàng)目都是JSON，XML可以自己加）
        return MediaType.APPLICATION_JSON.equalsTypeAndSubtype(MediaType.valueOf(converterType.getSimpleName()));
    }
    /**
     * 第二步：對(duì)響應(yīng)體進(jìn)行脫敏處理
     * @param body 原始響應(yīng)體
     * @param returnType 方法返回類型
     * @param selectedContentType 響應(yīng)類型
     * @param selectedConverterType 消息轉(zhuǎn)換器類型
     * @param request 請(qǐng)求對(duì)象
     * @param response 響應(yīng)對(duì)象
     * @return 脫敏后的響應(yīng)體
     */
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
                                  Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                  ServerHttpRequest request, ServerHttpResponse response) {
        // 1. 獲取當(dāng)前請(qǐng)求的path和method
        String path = request.getURI().getPath().toLowerCase();
        String method = request.getMethod().name().toLowerCase();
        String cacheKey = path + "#" + method;
        // 2. 從緩存獲取當(dāng)前接口的敏感字段列表
        List<SensitiveProperties.SensitiveField> sensitiveFields = sensitiveFieldCache.get(cacheKey);
        if (sensitiveFields == null || sensitiveFields.isEmpty()) {
            return body; // 沒有需要脫敏的字段，直接返回原始響應(yīng)體
        }
        // 3. 對(duì)響應(yīng)體進(jìn)行脫敏處理
        processSensitiveField(body, sensitiveFields);
        // 4. 返回脫敏后的響應(yīng)體
        return body;
    }
    /**
     * 核心方法：處理響應(yīng)體里的敏感字段
     * @param body 響應(yīng)體對(duì)象（可能是單個(gè)對(duì)象、集合、Map等）
     * @param sensitiveFields 敏感字段列表
     */
    private void processSensitiveField(Object body, List<SensitiveProperties.SensitiveField> sensitiveFields) {
        if (body == null) {
            return;
        }
        // 1. 如果是集合（List、Set等），遍歷每個(gè)元素處理
        if (body instanceof List<?>) {
            List<?> list = (List<?>) body;
            for (Object item : list) {
                processSensitiveField(item, sensitiveFields); // 遞歸處理每個(gè)元素
            }
            return;
        }
        // 2. 如果是Map（比如接口返回Map<String, Object>），遍歷每個(gè)entry處理
        if (body instanceof Map<?, ?>) {
            Map<?, ?> map = (Map<?, ?>) body;
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                Object value = entry.getValue();
                if (value == null) {
                    continue;
                }
                // 檢查當(dāng)前key是否是敏感字段
                String key = entry.getKey().toString();
                for (SensitiveProperties.SensitiveField sensitiveField : sensitiveFields) {
                    // 如果是簡單字段（不是嵌套字段），直接脫敏
                    if (StrUtil.equals(key, sensitiveField.getName())) {
                        String desensitizedValue = sensitiveUtil.desensitize(value.toString(), sensitiveField.getRule());
                        entry.setValue(desensitizedValue);
                        break;
                    }
                }
                // 遞歸處理Map里的嵌套對(duì)象
                processSensitiveField(value, sensitiveFields);
            }
            return;
        }
        // 3. 如果是普通Java對(duì)象（比如User、Order），用反射處理字段
        Class<?> clazz = body.getClass();
        // 遍歷所有敏感字段，處理每個(gè)字段
        for (SensitiveProperties.SensitiveField sensitiveField : sensitiveFields) {
            try {
                // 處理字段：支持嵌套字段（比如user.phone）
                Object fieldValue = getNestedFieldValue(body, sensitiveField.getName());
                if (fieldValue == null) {
                    continue;
                }
                // 脫敏處理：把字段值轉(zhuǎn)成字符串，脫敏后再設(shè)回去
                String desensitizedValue = sensitiveUtil.desensitize(fieldValue.toString(), sensitiveField.getRule());
                setNestedFieldValue(body, sensitiveField.getName(), desensitizedValue, fieldValue.getClass());
            } catch (Exception e) {
                // 遇到異常不拋出，避免影響接口正常返回（脫敏是輔助功能，不能讓它搞崩主流程）
                e.printStackTrace();
            }
        }
    }
    /**
     * 獲取嵌套字段的值：比如從Order對(duì)象里獲取user.phone的值
     * @param obj 目標(biāo)對(duì)象（比如Order）
     * @param fieldName 嵌套字段名（比如user.phone）
     * @return 字段值（比如13800138000）
     */
    private Object getNestedFieldValue(Object obj, String fieldName) throws Exception {
        if (StrUtil.isBlank(fieldName)) {
            return null;
        }
        // 分割字段名：比如"user.phone" → ["user", "phone"]
        String[] fieldNames = fieldName.split("\\.");
        Object currentObj = obj;
        for (String name : fieldNames) {
            if (currentObj == null) {
                return null;
            }
            // 獲取當(dāng)前對(duì)象的字段（包括私有字段）
            Field field = getDeclaredField(currentObj.getClass(), name);
            if (field == null) {
                return null;
            }
            field.setAccessible(true); // 突破私有字段訪問限制
            currentObj = field.get(currentObj); // 獲取字段值，作為下一層的對(duì)象
        }
        return currentObj;
    }
    /**
     * 設(shè)置嵌套字段的值：比如給Order對(duì)象的user.phone設(shè)置脫敏后的值
     * @param obj 目標(biāo)對(duì)象（比如Order）
     * @param fieldName 嵌套字段名（比如user.phone）
     * @param value 脫敏后的值（比如138****8000）
     * @param fieldType 字段類型（比如String）
     */
    private void setNestedFieldValue(Object obj, String fieldName, String value, Class<?> fieldType) throws Exception {
        if (StrUtil.isBlank(fieldName)) {
            return;
        }
        // 分割字段名：比如"user.phone" → ["user", "phone"]
        String[] fieldNames = fieldName.split("\\.");
        Object currentObj = obj;
        // 遍歷到倒數(shù)第二個(gè)字段（比如"user"）
        for (int i = 0; i < fieldNames.length - 1; i++) {
            String name = fieldNames[i];
            Field field = getDeclaredField(currentObj.getClass(), name);
            if (field == null) {
                return;
            }
            field.setAccessible(true);
            currentObj = field.get(currentObj); // 獲取下一層對(duì)象（比如user對(duì)象）
            if (currentObj == null) {
                return;
            }
        }
        // 處理最后一個(gè)字段（比如"phone"）
        String lastFieldName = fieldNames[fieldNames.length - 1];
        Field lastField = getDeclaredField(currentObj.getClass(), lastFieldName);
        if (lastField == null) {
            return;
        }
        lastField.setAccessible(true);
        // 把脫敏后的字符串轉(zhuǎn)成字段對(duì)應(yīng)的類型（比如Long類型的phone）
        Object fieldValue = convertValue(value, fieldType);
        lastField.set(currentObj, fieldValue); // 設(shè)置脫敏后的值
    }
    /**
     * 獲取類的字段（包括父類的字段）
     * @param clazz 目標(biāo)類
     * @param fieldName 字段名
     * @return 字段對(duì)象
     */
    private Field getDeclaredField(Class<?> clazz, String fieldName) {
        // 遍歷當(dāng)前類和父類，直到找到字段或到Object類
        while (clazz != null && clazz != Object.class) {
            try {
                return clazz.getDeclaredField(fieldName);
            } catch (NoSuchFieldException e) {
                clazz = clazz.getSuperclass(); // 沒找到，找父類
            }
        }
        return null; // 沒找到字段
    }
    /**
     * 把字符串轉(zhuǎn)成目標(biāo)類型（比如String → Long）
     * @param value 字符串值
     * @param targetType 目標(biāo)類型
     * @return 轉(zhuǎn)換后的值
     */
    private Object convertValue(String value, Class<?> targetType) {
        if (targetType == String.class) {
            return value;
        }
        if (targetType == Integer.class || targetType == int.class) {
            return Integer.parseInt(value);
        }
        if (targetType == Long.class || targetType == long.class) {
            return Long.parseLong(value);
        }
        // 其他類型可以自己加，比如Double、Boolean等
        return value;
    }
}

這段代碼雖然長，但邏輯很清晰，我分幾個(gè)部分給大家解釋：

1. 初始化和緩存

用@PostConstruct注解在項(xiàng)目啟動(dòng)時(shí)初始化：加載自定義脫敏規(guī)則，把接口脫敏配置緩存到sensitiveFieldCache里（key 是path#method）。
緩存的目的是避免每次請(qǐng)求都遍歷mappings列表，提高性能，尤其是接口多的時(shí)候。

2. supports 方法：判斷是否需要脫敏

首先檢查脫敏功能是否開啟（sensitive.enabled），關(guān)閉的話直接返回false。
只處理 JSON 響應(yīng)（大部分項(xiàng)目都是 JSON），如果需要處理 XML，可以自己加判斷。

3. beforeBodyWrite 方法：攔截響應(yīng)體

獲取當(dāng)前請(qǐng)求的path和method，生成緩存 key，從緩存里拿敏感字段列表。
如果沒有敏感字段，直接返回原始響應(yīng)體；有就調(diào)用processSensitiveField方法處理。

4. processSensitiveField 方法：核心處理邏輯

處理集合：如果響應(yīng)體是List，遍歷每個(gè)元素遞歸處理。
處理 Map：如果響應(yīng)體是Map，遍歷每個(gè) entry，檢查 key 是否是敏感字段，是就脫敏，然后遞歸處理 value 里的嵌套對(duì)象。
處理普通對(duì)象：用反射處理，支持嵌套字段（比如user.phone），這里是整個(gè)方法的重點(diǎn)。

5. 嵌套字段處理

getNestedFieldValue：通過 “.” 分割字段名，逐層獲取對(duì)象的字段值，比如從Order里獲取user，再從user里獲取phone。
setNestedFieldValue：和上面相反，逐層找到最后一個(gè)字段，把脫敏后的值設(shè)回去。
getDeclaredField：獲取類的字段，包括父類的字段，解決私有字段訪問問題。

第六步：寫測(cè)試代碼，驗(yàn)證效果

咱們寫幾個(gè)測(cè)試類，看看脫敏效果到底怎么樣。

1. 定義實(shí)體類

先寫User、Order、Result三個(gè)實(shí)體類（Result是接口統(tǒng)一返回格式）：

// User.java
import lombok.Data;
@Data
public class User {
    private Long id;
    private String name;
    private String phone; // 需要脫敏的字段
    private String idCard; // 需要脫敏的字段
}
// Order.java
import lombok.Data;
@Data
public class Order {
    private Long id;
    private String orderNo;
    private String bankCard; // 需要脫敏的字段
    private User user; // 嵌套對(duì)象，里面的phone需要脫敏
}
// Result.java：接口統(tǒng)一返回格式
import lombok.Data;
@Data
public class Result<T> {
    private Integer code; // 狀態(tài)碼：200=成功，500=失敗
    private String msg; // 提示信息
    private T data; // 響應(yīng)數(shù)據(jù)
    // 成功返回
    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.setCode(200);
        result.setMsg("success");
        result.setData(data);
        return result;
    }
    // 失敗返回
    public static <T> Result<T> fail(String msg) {
        Result<T> result = new Result<>();
        result.setCode(500);
        result.setMsg(msg);
        return result;
    }
}

2. 寫測(cè)試 Controller

然后寫UserController和OrderController，提供兩個(gè)測(cè)試接口：

// UserController.java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api/user")
public class UserController {
    /**
     * 測(cè)試接口1：獲取用戶信息
     */
    @GetMapping("/get")
    public Result<User> getUser(@RequestParam Long id) {
        // 模擬從數(shù)據(jù)庫查詢用戶信息
        User user = new User();
        user.setId(id);
        user.setName("張三");
        user.setPhone("13800138000"); // 明文手機(jī)號(hào)
        user.setIdCard("110101199001011234"); // 明文身份證號(hào)
        return Result.success(user);
    }
}
// OrderController.java
import org.springframework.web.bind.annotation.PostMapping;
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/order")
public class OrderController {
    /**
     * 測(cè)試接口2：獲取訂單列表
     */
    @PostMapping("/list")
    public Result<List<Order>> getOrderList(@RequestBody OrderQuery query) {
        // 模擬從數(shù)據(jù)庫查詢訂單列表
        List<Order> orderList = new ArrayList<>();
        Order order1 = new Order();
        order1.setId(1L);
        order1.setOrderNo("20240520001");
        order1.setBankCard("6222021234567890123"); // 明文銀行卡號(hào)
        User user1 = new User();
        user1.setId(1L);
        user1.setName("李四");
        user1.setPhone("13900139000"); // 嵌套對(duì)象的明文手機(jī)號(hào)
        order1.setUser(user1);
        orderList.add(order1);
        return Result.success(orderList);
    }
    // 訂單查詢參數(shù)
    public static class OrderQuery {
        private Long userId;
        // getter/setter
        public Long getUserId() {
            return userId;
        }
        public void setUserId(Long userId) {
            this.userId = userId;
        }
    }
}

3. 啟動(dòng)項(xiàng)目，測(cè)試效果

把a(bǔ)pplication.yml里的spring.profiles.active改成prod（開啟脫敏），然后啟動(dòng)項(xiàng)目。

用 Postman 或?yàn)g覽器測(cè)試接口：

測(cè)試接口 1：GET /api/user/get?id=1

預(yù)期效果：phone脫敏成1388000，idCard脫敏成110101****1234

實(shí)際返回結(jié)果：

{
    "code": 200,
    "msg": "success",
    "data": {
        "id": 1,
        "name": "張三",
        "phone": "138****8000", // 成功脫敏
        "idCard": "110101********1234" // 成功脫敏
    }
}

測(cè)試接口 2：POST /api/order/list

請(qǐng)求參數(shù)：

{
    "userId": 1
}

預(yù)期效果：bankCard脫敏成622202**123，user.phone脫敏成139**9000實(shí)際返回結(jié)果：

{
    "code": 200,
    "msg": "success",
    "data": [
        {
            "id": 1,
            "orderNo": "20240520001",
            "bankCard": "622202********123", // 成功脫敏
            "user": {
                "id": 1,
                "name": "李四",
                "phone": "139****9000", // 嵌套字段成功脫敏
                "idCard": null
            }
        }
    ]
}

完美！和預(yù)期效果一致，而且咱們沒改任何業(yè)務(wù)代碼，只改了 YAML 配置，真正實(shí)現(xiàn)了 “零侵入”。

四、進(jìn)階優(yōu)化：讓方案更實(shí)用，應(yīng)對(duì)復(fù)雜場(chǎng)景

上面的方案已經(jīng)能滿足大部分場(chǎng)景了，但在實(shí)際項(xiàng)目中，還有一些細(xì)節(jié)需要優(yōu)化，咱們?cè)傺a(bǔ)充幾個(gè)進(jìn)階功能。

1. 支持動(dòng)態(tài)配置：不用重啟服務(wù)，實(shí)時(shí)更新脫敏規(guī)則

上面的方案有個(gè)問題：如果要新增一個(gè)脫敏接口，得改 YAML 配置，然后重啟服務(wù)，很麻煩。

解決辦法：用配置中心（比如 Nacos、Apollo）存儲(chǔ)脫敏規(guī)則，實(shí)現(xiàn)動(dòng)態(tài)更新。

以 Nacos 為例，步驟如下：

在 Nacos 里創(chuàng)建一個(gè)配置文件（比如sensitive-demo-prod.yaml），把 YAML 里的sensitive節(jié)點(diǎn)配置放進(jìn)去。
在項(xiàng)目里引入 Nacos 配置依賴：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    <version>2.2.9.RELEASE</version>
</dependency>

在bootstrap.yml里配置 Nacos 地址：

spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848 # Nacos地址
        file-extension: yaml # 配置文件格式
        group: DEFAULT_GROUP # 配置分組
  application:
    name: sensitive-demo # 服務(wù)名，對(duì)應(yīng)Nacos里的配置文件名前綴
  profiles:
    active: prod # 環(huán)境

在SensitiveProperties里加@RefreshScope注解，支持配置動(dòng)態(tài)刷新：

@Component
@ConfigurationProperties(prefix = "sensitive")
@Data
@RefreshScope // 關(guān)鍵：開啟配置動(dòng)態(tài)刷新
public class SensitiveProperties {
    // ... 原有代碼不變
}

在SensitiveResponseBodyAdvice里監(jiān)聽配置刷新事件，重新初始化緩存：

import org.springframework.cloud.context.environment.EnvironmentChangeEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
publicclass SensitiveConfigRefreshListener implements ApplicationListener<EnvironmentChangeEvent> {

    @Resource
    private SensitiveResponseBodyAdvice sensitiveResponseBodyAdvice;

    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        // 如果脫敏配置發(fā)生變化，重新初始化緩存
        if (event.getKeys().stream().anyMatch(key -> key.startsWith("sensitive."))) {
            sensitiveResponseBodyAdvice.init();
        }
    }
}

這樣一來，以后要新增或修改脫敏規(guī)則，直接在 Nacos 里改配置，不用重啟服務(wù)，配置會(huì)自動(dòng)刷新，非常方便！

2. 日志脫敏：避免日志里出現(xiàn)明文敏感信息

前面咱們解決了接口響應(yīng)脫敏，但日志里如果打印了敏感信息，還是會(huì)有風(fēng)險(xiǎn)。比如：

log.info("用戶登錄成功，手機(jī)號(hào)：{}", user.getPhone()); // 日志里會(huì)出現(xiàn)明文手機(jī)號(hào)

解決辦法：用 Logback 的自定義轉(zhuǎn)換器，對(duì)日志里的敏感字段進(jìn)行脫敏。步驟如下：

寫一個(gè)日志脫敏轉(zhuǎn)換器：

import ch.qos.logback.classic.pattern.ClassicConverter;
import ch.qos.logback.classic.spi.ILoggingEvent;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * Logback日志脫敏轉(zhuǎn)換器
 */
@Component
publicclass LogSensitiveConverter extends ClassicConverter {

    @Resource
    private SensitiveUtil sensitiveUtil;

    @Override
    publicString convert(ILoggingEvent event) {
        String message = event.getMessage();
        if (message == null) {
            return"";
        }

        // 對(duì)日志里的手機(jī)號(hào)、身份證號(hào)、銀行卡號(hào)進(jìn)行脫敏
        message = sensitiveUtil.desensitize(message, "mobile");
        message = sensitiveUtil.desensitize(message, "idCard");
        message = sensitiveUtil.desensitize(message, "bankCard");

        return message;
    }
}

在logback-spring.xml里配置轉(zhuǎn)換器：

<configuration>
    <!-- 配置脫敏轉(zhuǎn)換器 -->
    <conversionRule conversionWord="sensitive" converterClass="com.example.sensitivedemo.config.LogSensitiveConverter" />

    <!-- 控制臺(tái)輸出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 使用sensitive轉(zhuǎn)換器脫敏日志 -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %sensitive%n</pattern>
        </encoder>
    </appender>

    <!-- 全局日志級(jí)別 -->
    <root level="INFO">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

這樣一來，日志里的敏感信息會(huì)自動(dòng)脫敏，比如：

2024-05-20 15:30:00 [http-nio-8080-exec-1] INFO  com.example.sensitivedemo.controller.UserController - 用戶登錄成功，手機(jī)號(hào)：138****8000

3. 性能優(yōu)化：減少反射次數(shù)，提高接口響應(yīng)速度

前面咱們提到，反射會(huì)影響性能，尤其是高并發(fā)場(chǎng)景。咱們可以通過緩存反射獲取的字段信息，減少反射次數(shù)。

修改SensitiveResponseBodyAdvice里的processSensitiveField方法，增加字段緩存：

/**
 * 字段緩存：key=類名#字段名，value=字段對(duì)象
 */
private final Map<String, Field> fieldCache = new ConcurrentHashMap<>();

/**
 * 獲取類的字段（包括父類的字段），并緩存
 */
private Field getDeclaredField(Class<?> clazz, String fieldName) {
    String cacheKey = clazz.getName() + "#" + fieldName;
    // 先從緩存里拿
    if (fieldCache.containsKey(cacheKey)) {
        return fieldCache.get(cacheKey);
    }

    // 緩存里沒有，遍歷類和父類找字段
    Class<?> currentClazz = clazz;
    while (currentClazz != null && currentClazz != Object.class) {
        try {
            Field field = currentClazz.getDeclaredField(fieldName);
            field.setAccessible(true); // 突破私有字段訪問限制
            fieldCache.put(cacheKey, field); // 緩存字段
            return field;
        } catch (NoSuchFieldException e) {
            currentClazz = currentClazz.getSuperclass(); // 找父類
        }
    }

    returnnull;
}

這樣一來，同一個(gè)類的同一個(gè)字段，只會(huì)反射一次，后續(xù)都從緩存里拿，性能會(huì)提升很多。

五、對(duì)比 AOP：這個(gè)方案到底好在哪里？

最后咱們來總結(jié)一下，這個(gè) SpringBoot + YAML 方案，和傳統(tǒng)的 AOP 方案相比，優(yōu)勢(shì)到底在哪里：

對(duì)比維度	傳統(tǒng) AOP 方案	SpringBoot + YAML 方案
侵入性	強(qiáng)：需要加注解、改業(yè)務(wù)代碼、寫切面	零侵入：不用改業(yè)務(wù)代碼，只改配置文件
代碼復(fù)雜度	高：處理嵌套對(duì)象、集合要寫復(fù)雜邏輯	低：基于 ResponseBodyAdvice，邏輯清晰
配置靈活性	差：改規(guī)則要改代碼，重啟服務(wù)	好：配置化，支持動(dòng)態(tài)更新（配 Nacos）
性能	一般：反射次數(shù)多，切面攔截有開銷	好：字段緩存，減少反射，輕量級(jí)攔截
維護(hù)成本	高：代碼耦合度高，后續(xù)修改牽一發(fā)動(dòng)全身	低：配置集中管理，新增接口只加配置

簡單說：用 AOP 做脫敏，就像 “給每個(gè)房間裝一扇門”，每個(gè)門都要單獨(dú)設(shè)計(jì)、安裝；而用這個(gè)方案，就像 “裝一個(gè)智能門禁系統(tǒng)”，統(tǒng)一配置，所有房間都能用，還能隨時(shí)改規(guī)則。

六、總結(jié)

兄弟們，看到這里，相信你已經(jīng)明白這個(gè)零侵入脫敏方案的好處了。不用寫復(fù)雜的 AOP 切面，不用改業(yè)務(wù)代碼，只改改 YAML 配置，就能實(shí)現(xiàn)接口響應(yīng)脫敏，還支持動(dòng)態(tài)配置、日志脫敏、性能優(yōu)化，新手也能快速上手。

如果你現(xiàn)在正在做數(shù)據(jù)脫敏相關(guān)的需求，或者之前用 AOP 踩過坑，不妨試試這個(gè)方案，絕對(duì)能讓你少寫很多代碼，少踩很多坑。

責(zé)任編輯：武曉燕來源：石杉的架構(gòu)筆記