使用Spring和Redis创建处理敏感数据的服务的示例代码

梁曼婉

许多公司（如：金融科技公司）处理的用户敏感数据由于法律限制不能永久存储。根据规定，这些数据的存储时间不能超过预设期限，并且最好在用于服务目的之后就将其删除。解决这个问题有多种可能的方案。在本文中，我想展示一个利用 Spring 和 Redis 处理敏感数据的应用程序的简化示例。

Redis 是一种高性能的 NoSQL 数据库。通常，它被用作内存缓存解决方案，因为它的速度非常快。然而，在这个示例中，我们将把它用作主要的数据存储。它完美地符合我们问题的需求，并且与 Spring Data 有很好的集成。

我们将创建一个管理用户全名和卡详细信息（作为敏感数据的示例）的应用程序。卡详细信息将以加密字符串的形式通过 POST 请求传递给应用程序。数据将仅在数据库中存储五分钟。在通过 GET 请求读取数据之后，数据将被自动删除。

该应用程序被设计为公司内部的微服务，不提供公共访问权限。用户的数据可以从面向用户的服务传递过来。然后，其他内部微服务可以请求卡详细信息，确保敏感数据保持安全，且无法从外部服务访问。

初始化 Spring Boot 项目

让我们开始使用 Spring Initializr 创建项目。我们需要 Spring Web、Spring Data Redis 和 Lombok。我还添加了 Spring Boot Actuator，因为在真实微服务中它肯定会很有用。

在初始化服务之后，我们应该添加其他依赖项。为了能够在读取数据后自动删除数据，我们将使用 AspectJ。我还添加了一些其他对服务有帮助的依赖项，使它看起来更接近真实的服务。

最终的

1. build.gradle

复制代码

文件如下所示：

1. plugins {
2. id 'java'
3. id 'org.springframework.boot' version '3.3.3'
4. id 'io.spring.dependency-management' version '1.1.6'
5. id "io.freefair.lombok" version "8.10.2"
6. }
8. java {
9. toolchain {
10. languageVersion = JavaLanguageVersion.of(22)
11. }
12. }
14. repositories {
15. mavenCentral()
16. }
18. ext {
19. springBootVersion = '3.3.3'
20. springCloudVersion = '2023.0.3'
21. dependencyManagementVersion = '1.1.6'
22. aopVersion = "1.9.19"
23. hibernateValidatorVersion = '8.0.1.Final'
24. testcontainersVersion = '1.20.2'
25. jacksonVersion = '2.18.0'
26. javaxValidationVersion = '3.1.0'
27. }
29. dependencyManagement {
30. imports {
31. mavenBom "org.springframework.boot:spring-boot-dependencies:${springBootVersion}"
32. mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
33. }
34. }
36. dependencies {
37. implementation 'org.springframework.boot:spring-boot-starter-data-redis'
38. implementation 'org.springframework.boot:spring-boot-starter-web'
39. implementation 'org.springframework.boot:spring-boot-starter-actuator'
40. implementation "org.aspectj:aspectjweaver:${aopVersion}"
41. implementation "com.fasterxml.jackson.core:jackson-core:${jacksonVersion}"
42. implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
43. implementation "com.fasterxml.jackson.core:jackson-annotations:${jacksonVersion}"
44. implementation "jakarta.validation:jakarta.validation-api:${javaxValidationVersion}"
45. implementation "org.hibernate:hibernate-validator:${hibernateValidatorVersion}"
46. testImplementation('org.springframework.boot:spring-boot-starter-test') {
47. exclude group: 'org.junit.vintage'
48. }
49. testImplementation "org.testcontainers:testcontainers:${testcontainersVersion}"
50. testImplementation 'org.junit.jupiter:junit-jupiter'
51. }
53. tasks.named('test') {
54. useJUnitPlatform()
55. }

复制代码

我们需要设置与 Redis 的连接。

1. application.yml

复制代码

 中的 Spring Data Redis 属性如下：

1. spring:
2. data:
3. redis:
4. host: localhost
5. port: 6379

复制代码

领域模型

1. CardInfo

复制代码

是我们将要处理的数据对象。为了使其更加真实，我们让卡详细信息作为加密数据传递到服务中。我们需要解密、验证，然后存储传入的数据。领域模型将有三个层次：

• DTO：请求级别，用于控制器
• Model：服务级别，用于业务逻辑
• Entity：持久化级别，用于仓库

DTO 和 Model 之间的转换在

1. CardInfoConverter

复制代码

中完成。Model 和 Entity 之间的转换在

1. CardInfoEntityMapper

复制代码

中完成。我们使用 Lombok 以方便开发。

DTO

1. @Builder
2. @Getter
3. @ToString(exclude = "cardDetails")
4. @NoArgsConstructor
5. @AllArgsConstructor
6. @JsonIgnoreProperties(ignoreUnknown = true)
7. public class CardInfoRequestDto {
8. @NotBlank
9. private String id;
10. @Valid
11. private UserNameDto fullName;
12. @NotNull
13. private String cardDetails;
14. }

复制代码

其中 UserNameDto

1. @Builder
2. @Getter
3. @ToString
4. @NoArgsConstructor
5. @AllArgsConstructor
6. @JsonIgnoreProperties(ignoreUnknown = true)
7. public class UserNameDto {
8. @NotBlank
9. private String firstName;
10. @NotBlank
11. private String lastName;
12. }

复制代码

这里的卡详细信息表示一个加密字符串，而 

1. fullName

复制代码

 是作为一个单独的对象传递的。注意 

1. cardDetails

复制代码

 字段是如何从 

1. toString()

复制代码

 方法中排除的。由于数据是敏感的，不应意外记录。

Model

1. @Data
2. @Builder
3. public class CardInfo {
4. @NotBlank
5. private String id;
6. @Valid
7. private UserName userName;
8. @Valid
9. private CardDetails cardDetails;
10. }

复制代码

1. @Data
2. @Builder
3. public class UserName {
4. private String firstName;
5. private String lastName;
6. }

复制代码

1. CardInfo

复制代码

与

1. CardInfoRequestDto

复制代码

相同，只是

1. cardDetails

复制代码

已经被转换（在

1. CardInfoEntityMapper

复制代码

中完成）。

1. CardDetails

复制代码

现在是一个解密后的对象，它有两个敏感字段：pan（卡号）和 CVV（安全码）：

1. @Data
2. @Builder
3. @NoArgsConstructor
4. @AllArgsConstructor
5. @ToString(exclude = {"pan", "cvv"})
6. public class CardDetails {
7. @NotBlank
8. private String pan;
9. private String cvv;
10. }

复制代码

再次看到，我们从 

1. toString()

复制代码

 方法中排除了敏感的 pan 和 CVV 字段。

Entity

1. @Getter
2. @Setter
3. @ToString(exclude = "cardDetails")
4. @NoArgsConstructor
5. @AllArgsConstructor
6. @Builder
7. @RedisHash
8. public class CardInfoEntity {
9. @Id
10. private String id;
11. private String cardDetails;
12. private String firstName;
13. private String lastName;
14. }

复制代码

为了让 Redis 为实体创建哈希键，需要添加 

1. @RedisHash

复制代码

 注解以及 

1. @Id

复制代码

 注解。

以下是 DTO 转换为 Model 的方式：

1. public CardInfo toModel(@NonNull CardInfoRequestDto dto) {
2. final UserNameDto userName = dto.getFullName();
3. return CardInfo.builder()
4. .id(dto.getId())
5. .userName(UserName.builder()
6. .firstName(ofNullable(userName).map(UserNameDto::getFirstName).orElse(null))
7. .lastName(ofNullable(userName).map(UserNameDto::getLastName).orElse(null))
8. .build())
9. .cardDetails(getDecryptedCardDetails(dto.getCardDetails()))
10. .build();
11. }
13. private CardDetails getDecryptedCardDetails(@NonNull String cardDetails) {
14. try {
15. return objectMapper.readValue(cardDetails, CardDetails.class);
16. } catch (IOException e) {
17. throw new IllegalArgumentException("Card details string cannot be transformed to Json object", e);
18. }
19. }

复制代码

在这个例子中，

1. getDecryptedCardDetails

复制代码

方法只是将字符串映射到

1. CardDetails

复制代码

对象。在真实的应用程序中，解密逻辑将在这个方法中实现。

仓库

使用 Spring Data 创建仓库。服务中的

1. CardInfo

复制代码

通过其 ID 检索，因此不需要定义自定义方法，代码如下所示：

1. @Repository
2. public interface CardInfoRepository extends CrudRepository<CardInfoEntity, String> {
3. }

复制代码

Redis 配置

我们需要实体只存储五分钟。为了实现这一点，我们需要设置 TTL（生存时间）。我们可以通过在

1. CardInfoEntity

复制代码

中引入一个字段并添加

1. @TimeToLive

复制代码

注解来实现。也可以通过在

1. @RedisHash

复制代码

上添加值来实现：

1. @RedisHash(timeToLive = 5*60)

复制代码

。

这两种方法都有些缺点。在第一种情况下，我们需要引入一个与业务逻辑无关的字段。在第二种情况下，值是硬编码的。还有另一种选择：实现

1. KeyspaceConfiguration

复制代码

。通过这种方法，我们可以使用

1. application.yml

复制代码

中的属性来设置 TTL，如果需要的话，还可以设置其他 Redis 属性。

1. @Configuration
2. @RequiredArgsConstructor
3. @EnableRedisRepositories(enableKeyspaceEvents = RedisKeyValueAdapter.EnableKeyspaceEvents.ON_STARTUP)
4. public class RedisConfiguration {
5. private final RedisKeysProperties properties;
7. @Bean
8. public RedisMappingContext keyValueMappingContext() {
9. return new RedisMappingContext(
10. new MappingConfiguration(new IndexConfiguration(), new CustomKeyspaceConfiguration()));
11. }
13. public class CustomKeyspaceConfiguration extends KeyspaceConfiguration {
15. @Override
16. protected Iterable<KeyspaceSettings> initialConfiguration() {
17. return Collections.singleton(customKeyspaceSettings(CardInfoEntity.class, CacheName.CARD_INFO));
18. }
20. private <T> KeyspaceSettings customKeyspaceSettings(Class<T> type, String keyspace) {
21. final KeyspaceSettings keyspaceSettings = new KeyspaceSettings(type, keyspace);
22. keyspaceSettings.setTimeToLive(properties.getCardInfo().getTimeToLive().toSeconds());
23. return keyspaceSettings;
24. }
25. }
27. @NoArgsConstructor(access = AccessLevel.PRIVATE)
28. public static class CacheName {
29. public static final String CARD_INFO = "cardInfo";
30. }
31. }

复制代码

为了使 Redis 能够根据 TTL 删除实体，需要在

1. @EnableRedisRepositories

复制代码

注解中添加

1. enableKeyspaceEvents = RedisKeyValueAdapter.EnableKeyspaceEvents.ON_STARTUP

复制代码

。我引入了

1. CacheName

复制代码

类，以便使用常量作为实体名称，并反映如果需要的话可以对多个实体进行不同的配置。

TTL 的值是从

1. RedisKeysProperties

复制代码

对象中获取的。

1. @Data
2. @Component
3. @ConfigurationProperties("redis.keys")
4. @Validated
5. public class RedisKeysProperties {
6. @NotNull
7. private KeyParameters cardInfo;
8. @Data
9. @Validated
10. public static class KeyParameters {
11. @NotNull
12. private Duration timeToLive;
13. }
14. }

复制代码

这里只有 cardInfo 这个实体，但可能还有其他实体存在。 应用.yml 中的 TTL 属性：

1. redis:
2. keys:
3. cardInfo:
4. timeToLive: PT5M

复制代码

Controller

让我们为该服务添加 API，以便能够通过 HTTP 存储和访问数据。

1. @RestController
2. @RequiredArgsConstructor
3. @RequestMapping( "/api/cards")
4. public class CardController {
5. private final CardService cardService;
6. private final CardInfoConverter cardInfoConverter;
8. @PostMapping
9. @ResponseStatus(CREATED)
10. public void createCard(@Valid @RequestBody CardInfoRequestDto cardInfoRequest) {
11. cardService.createCard(cardInfoConverter.toModel(cardInfoRequest));
12. }
14. @GetMapping("/{id}")
15. public ResponseEntity<CardInfoResponseDto> getCard(@PathVariable("id") String id) {
16. return ResponseEntity.ok(cardInfoConverter.toDto(cardService.getCard(id)));
17. }
18. }

复制代码

基于 AOP 的自动删除功能

我们希望在通过 GET 请求成功读取该实体之后立即对其进行删除。这可以通过 AOP 和 AspectJ 来实现。我们需要创建一个 Spring Bean 并用 

1. @Aspect

复制代码

 进行注解。

1. @Aspect
2. @Component
3. @RequiredArgsConstructor
4. @ConditionalOnExpression("${aspect.cardRemove.enabled:false}")
5. public class CardRemoveAspect {
6. private final CardInfoRepository repository;
8. @Pointcut("execution(* com.cards.manager.controllers.CardController.getCard(..)) && args(id)")
9. public void cardController(String id) {
10. }
12. @AfterReturning(value = "cardController(id)", argNames = "id")
13. public void deleteCard(String id) {
14. repository.deleteById(id);
15. }
16. }

复制代码

1. @Pointcut

复制代码

定义了逻辑应用的切入点。换句话说，它决定了触发逻辑执行的时机。

1. deleteCard

复制代码

方法定义了具体的逻辑，它通过

1. CardInfoRepository

复制代码

按照 ID 删除

1. cardInfo

复制代码

实体。

1. @AfterReturning

复制代码

注解表明该方法会在

1. value

复制代码

属性中定义的方法成功返回后执行。

此外，我还使用了

1. @ConditionalOnExpression

复制代码

注解来根据配置属性开启或关闭这一功能。

测试

我们将使用 MockMvc 和 Testcontainers 来编写 test case。

1. public abstract class RedisContainerInitializer {
2. private static final int PORT = 6379;
3. private static final String DOCKER_IMAGE = "redis:6.2.6";
5. private static final GenericContainer REDIS_CONTAINER = new GenericContainer(DockerImageName.parse(DOCKER_IMAGE))
6. .withExposedPorts(PORT)
7. .withReuse(true);
9. static {
10. REDIS_CONTAINER.start();
11. }
13. @DynamicPropertySource
14. static void properties(DynamicPropertyRegistry registry) {
15. registry.add("spring.data.redis.host", REDIS_CONTAINER::getHost);
16. registry.add("spring.data.redis.port", () -> REDIS_CONTAINER.getMappedPort(PORT));
17. }
18. }

复制代码

通过 

1. @DynamicPropertySource

复制代码

，我们可以从启动的 Redis Docker 容器中设置属性。随后，这些属性将被应用程序读取，以建立与 Redis 的连接。

以下是针对 POST 和 GET 请求的基本测试:

1. public class CardControllerTest extends BaseTest {
2. private static final String CARDS_URL = "/api/cards";
3. private static final String CARDS_ID_URL = CARDS_URL + "/{id}";
5. @Autowired
6. private CardInfoRepository repository;
8. @BeforeEach
9. public void setUp() {
10. repository.deleteAll();
11. }
13. @Test
14. public void createCard_success() throws Exception {
15. final CardInfoRequestDto request = aCardInfoRequestDto().build();
17. mockMvc.perform(post(CARDS_URL)
18. .contentType(APPLICATION_JSON)
19. .content(objectMapper.writeValueAsBytes(request)))
20. .andExpect(status().isCreated())
21. ;
22. assertCardInfoEntitySaved(request);
23. }
25. @Test
26. public void getCard_success() throws Exception {
27. final CardInfoEntity entity = aCardInfoEntityBuilder().build();
28. prepareCardInfoEntity(entity);
30. mockMvc.perform(get(CARDS_ID_URL, entity.getId()))
31. .andExpect(status().isOk())
32. .andExpect(jsonPath("$.id", is(entity.getId())))
33. .andExpect(jsonPath("$.cardDetails", notNullValue()))
34. .andExpect(jsonPath("$.cardDetails.cvv", is(CVV)))
35. ;
36. }
37. }

复制代码

通过 AOP 进行自动删除功能测试：

1. @Test
2. @EnabledIf(
3. expression = "${aspect.cardRemove.enabled}",
4. loadContext = true
5. )
7. public void getCard_deletedAfterRead() throws Exception {
8. final CardInfoEntity entity = aCardInfoEntityBuilder().build();
9. prepareCardInfoEntity(entity);
11. mockMvc.perform(get(CARDS_ID_URL, entity.getId()))
12. .andExpect(status().isOk());
13. mockMvc.perform(get(CARDS_ID_URL, entity.getId()))
14. .andExpect(status().isNotFound())
15. ;
16. }

复制代码

我为这个测试添加了 

1. @EnabledIf

复制代码

 注解，因为 AOP 逻辑可以在配置文件中关闭，而该注解则用于决定是否要运行该测试。

以上就是使用Spring和Redis创建处理敏感数据的服务的示例代码的详细内容，更多关于Spring Redis处理敏感数据的资料请关注晓枫资讯其它相关文章！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！