当前位置：首页 > article >正文

学习文章：Spring Boot 中 Redis 配置与序列化管理

article 2025/3/12 19:56:41

文章目录

学习文章：Spring Boot 中 Redis 配置与序列化管理
- - 引言
  - 1. Redis 的序列化方式
  - 2. 在 Spring Boot 中配置 Redis 序列化
  - - 2.1 创建 Redis 配置类
    - 2.2 解析配置
  - 3. 集中管理 Redis 配置的好处
  - - 3.1 代码简洁
    - 3.2 统一管理
    - 3.3 可复用性
  - 4. 使用 RedisTemplate 进行操作
  - - 4.1 RedisService 实现
    - 4.2 Redis 操作方法
  - 5. 总结

学习文章：Spring Boot 中 Redis 配置与序列化管理

引言

在分布式应用中，缓存系统是不可或缺的一部分，Redis 作为一个高性能的键值存储数据库，被广泛应用于缓存、会话存储、消息队列等场景。在 Spring Boot 中，使用 Spring Data Redis 可以非常方便地与 Redis 进行交互。然而，在实际使用中，我们常常需要对存储的数据进行序列化，而不同的数据类型和应用场景会要求不同的序列化方式。在本文中，我们将探讨如何在 Spring Boot 中配置 Redis 序列化，并通过配置类将序列化逻辑集中管理，避免在每个服务中重复配置。

1. Redis 的序列化方式

Redis 是一个键值数据库，它存储的数据通常以二进制流的形式保存在内存中。为了与 Java 对象进行交互，Spring Data Redis 提供了几种序列化方式，以确保我们可以将 Java 对象正确地转换为 Redis 可以存储的格式，并且可以将从 Redis 中获取的数据反序列化为 Java 对象。

常用的序列化方式有以下几种：

StringRedisSerializer：用于序列化字符串类型的数据，通常用于存储纯文本的键和值。
JdkSerializationRedisSerializer：通过 Java 内建的序列化机制对对象进行序列化。虽然简单，但序列化后的数据不可读且占用较多空间。
Jackson2JsonRedisSerializer：通过 Jackson 库将对象转换为 JSON 格式，具有较好的跨语言兼容性，存储数据时以 JSON 字符串的形式存在。

在实际项目中，Jackson2JsonRedisSerializer 是最常见的选择，因为它能够将对象序列化为人类可读的 JSON 格式，同时也能处理复杂的对象结构。

2. 在 Spring Boot 中配置 Redis 序列化

为了避免在每个服务中都重复配置 Redis 的序列化方式，我们可以将序列化配置集中管理，放在一个单独的配置类中，这样可以更好地分离关注点，提高代码的可维护性。

2.1 创建 Redis 配置类

首先，我们创建一个配置类，用来配置 Redis 的连接工厂、序列化方式、以及 RedisTemplate 的初始化。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.connection.RedisConnectionFactory;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);

        // 使用 Jackson2JsonRedisSerializer 来序列化和反序列化对象
        Jackson2JsonRedisSerializer<Object> jacksonSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

        // 设置 key 和 value 的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer()); // key 使用 String 序列化
        redisTemplate.setValueSerializer(jacksonSerializer); // value 使用 Jackson2Json 序列化

        // 设置 hash 的 key 和 value 序列化方式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jacksonSerializer);

        return redisTemplate;
    }
}

2.2 解析配置

在上面的代码中，我们做了如下配置：

RedisConnectionFactory：这是 Redis 与 Spring Boot 连接的基础工厂，它会自动从 Spring 配置文件中读取 Redis 连接的相关信息。
Jackson2JsonRedisSerializer：我们使用 Jackson2JsonRedisSerializer 来序列化 Redis 中的对象。它能够将 Java 对象转换为 JSON 格式存储，且可以将从 Redis 中获取的 JSON 数据反序列化为 Java 对象。
StringRedisSerializer：Redis 的键（key）通常是字符串类型，使用 StringRedisSerializer 进行序列化，以保证键能够被正确地处理。

3. 集中管理 Redis 配置的好处

将 Redis 的序列化配置集中在一个配置类中，具有以下几个显著的优点：

3.1 代码简洁

集中配置 Redis 的序列化方式，避免了在每个业务类中重复配置 RedisTemplate 和序列化器，使得代码更加简洁明了。

3.2 统一管理

当需要修改 Redis 的序列化策略（比如从 JdkSerializationRedisSerializer 改为 Jackson2JsonRedisSerializer）时，只需要修改配置类，不需要去遍历项目中的每一个 RedisTemplate 使用点，从而减少了代码修改的成本。

3.3 可复用性

通过集中配置，RedisTemplate 和相关的序列化器可以在项目中多个服务间复用。只需注入 RedisTemplate 或 HashOperations，即可在不同的类中进行 Redis 操作，而无需重新配置序列化方式。

4. 使用 RedisTemplate 进行操作

配置完成后，我们可以在业务逻辑中直接注入 RedisTemplate 或者 HashOperations 来进行数据操作。

4.1 RedisService 实现

假设我们需要实现一个 RedisService 来操作 Redis 中的哈希表数据，可以如下进行操作：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.Map;

@Service
public class RedisServiceImpl implements RedisService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final HashOperations<String, String, Object> hashOperations;

    @Autowired
    public RedisServiceImpl(RedisTemplate<String, Object> redisTemplate, HashOperations<String, String, Object> hashOperations) {
        this.redisTemplate = redisTemplate;
        this.hashOperations = hashOperations;
    }

    @Override
    public void putHash(String key, Map<String, Object> value) {
        hashOperations.putAll(key, value);
    }

    @Override
    public Map<String, Object> getHash(String key) {
        return hashOperations.entries(key);
    }

    @Override
    public Object getHashField(String key, String field) {
        return hashOperations.get(key, field);
    }

    @Override
    public void deleteHashField(String key, String field) {
        hashOperations.delete(key, field);
    }

    @Override
    public void deleteHash(String key) {
        redisTemplate.delete(key);
    }

    @Override
    public boolean hasHash(String key) {
        return redisTemplate.hasKey(key);
    }

    @Override
    public List<String> getAllHashKeys(String pattern) {
        Set<String> keys = redisTemplate.keys(pattern);
        return new ArrayList<>(Optional.ofNullable(keys).orElse(Collections.emptySet()));
    }
}