Spring Boot 数据脱敏实现

项目开发中，在处理敏感信息时，数据脱敏是一项重要的安全措施。数据脱敏可以防止敏感信息在非授权情况下被泄露，同时在数据共享和分析时保护用户隐私。

一、数据脱敏的必要性

• 保护隐私：防止敏感信息（如身份证号、手机号等）被泄露。
• 合规要求：遵循数据保护法规（如 GDPR、CCPA 等）。
• 增强安全性：降低数据被滥用的风险。

二、常用的数据脱敏策略

1. 替换脱敏：用特定字符替换敏感信息的一部分，如用 * 替换手机号中间部分。
2. 哈希脱敏：使用哈希算法对敏感信息进行处理，无法恢复原值。
3. 模糊化：对数据进行模糊处理，使其不易识别，但保留一定的可用性。
4. 加密脱敏：对敏感信息进行加密存储，只在授权情况下解密。

三、实现步骤

3.1 创建脱敏注解

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 Sensitive {
    String type(); // 脱敏类型
    String pattern() default ""; // 可选的模式参数
}

3.2 策略接口设计

首先，定义一个脱敏策略接口，所有的脱敏策略都将实现这个接口：

public interface MaskingStrategy {
    String mask(String value, String pattern);
}

3.3 具体脱敏策略实现

接下来，为每种脱敏类型创建具体的实现类：

public class PhoneMaskingStrategy implements MaskingStrategy {
    @Override
    public String mask(String value, String pattern) {
        return value.replaceAll("(\d{3})\d{4}(\d{4})", "$1****$2");
    }
}

public class IdCardMaskingStrategy implements MaskingStrategy {
    @Override
    public String mask(String value, String pattern) {
        return value.replaceAll("(\d{6})\d{8}(\d{4})", "$1****$2");
    }
}

public class CustomMaskingStrategy implements MaskingStrategy {
    @Override
    public String mask(String value, String pattern) {
        return value.replaceAll(pattern, "****");
    }
}

3.4 策略工厂

创建一个策略工厂，根据脱敏类型返回相应的策略实例：

import java.util.HashMap;
import java.util.Map;

public class MaskingStrategyFactory {
    private static final Map<String, MaskingStrategy> strategies = new HashMap<>();

    static {
        strategies.put("phone", new PhoneMaskingStrategy());
        strategies.put("idCard", new IdCardMaskingStrategy());
        strategies.put("custom", new CustomMaskingStrategy());
    }

    public static MaskingStrategy getStrategy(String type) {
        return strategies.getOrDefault(type, (value, pattern) -> value.replaceAll(".", "*")); // 默认脱敏
    }
}

3.5 通用脱敏处理器

import org.springframework.stereotype.Component;
import java.lang.reflect.Field;

@Component
public class GeneralDataMaskingProcessor {

    public void maskSensitiveData(Object obj) throws IllegalAccessException {
        Class<?> clazz = obj.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(Sensitive.class)) {
                field.setAccessible(true);
                Object value = field.get(obj);
                if (value != null) {
                    String maskedValue = maskValue(value.toString(), field.getAnnotation(Sensitive.class));
                    field.set(obj, maskedValue);
                }
            }
        }
    }

    private String maskValue(String value, Sensitive sensitive) {
        String type = sensitive.type();
        String pattern = sensitive.pattern();
        
        MaskingStrategy strategy = MaskingStrategyFactory.getStrategy(type);
        return strategy.mask(value, pattern);
    }
}

3.6 使用示例

1. 创建用户实体类

public class User {

    private Long id;

    @Sensitive(type = "phone")
    private String phoneNumber;

    @Sensitive(type = "idCard")
    private String idCard;

    @Sensitive(type = "custom", pattern = "\d{3}-\d{4}") // 自定义模式
    private String customField;

    private String name;

    // Getters and Setters
}

2. 在服务层调用脱敏处理器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private GeneralDataMaskingProcessor dataMaskingProcessor;

    public User getUser(Long id) {
        User user = findUserById(id); // 假设这是从数据库获取用户信息
        try {
            dataMaskingProcessor.maskSensitiveData(user);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return user;
    }

    private User findUserById(Long id) {
        // 模拟从数据库获取用户
        return new User(id, "13812345678", "123456789012345678", "123-4567", "John Doe");
    }
}

3. 测试脱敏功能

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void testGetUser() {
        User user = userService.getUser(1L);
        assertThat(user.getPhoneNumber()).isEqualTo("138****5678");
        assertThat(user.getIdCard()).isEqualTo("123456****5678");
        assertThat(user.getCustomField()).isEqualTo("123-****"); // 自定义脱敏
    }
}

四、总结

通过以上步骤，在Spring Boot 项目中实现了数据脱敏功能。使用自定义注解和处理器并结合策略模式，可以灵活地对敏感信息进行脱敏处理。