SpringBoot连接Redis且解决乱码

一、前言

连接 Redis 到 Spring Boot 可以通过以下步骤完成：

1. 添加 Redis 相关依赖

在 pom.xml 文件中添加 Redis 相关的依赖项，如果你使用 Maven，可以添加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

这个依赖包含了 Spring Boot 对 Redis 的自动配置和必要的依赖项。

2. 配置 Redis 连接信息

在 application.properties 或 application.yml 中配置 Redis 的连接信息。以下是一个简单的示例：

使用 application.properties 配置文件：

# Redis connection configuration
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=your_redis_password

使用 application.yml 配置文件：

# Redis connection configuration
spring:
  redis:
    host: localhost
    port: 6379
    password: your_redis_password

根据你的实际情况修改 host（主机名或 IP 地址）、port（端口号）和 password（如果有密码的话）。如果 Redis 在本地运行，并且没有设置密码，可以省略 spring.redis.password。

3. 使用 RedisTemplate 进行操作

在 Spring Boot 中，可以使用 RedisTemplate 来执行 Redis 操作。在你的服务类或控制器中注入 RedisTemplate，然后使用它来操作 Redis 数据。

例如，创建一个 Redis 服务类：

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

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    // 设置键值对
    public void setValue(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    // 设置键值对，并指定过期时间
    public void setValueWithExpire(String key, String value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    // 获取键对应的值
    public String getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    // 删除指定的键
    public Boolean deleteKey(String key) {
        return redisTemplate.delete(key);
    }

    // 检查键是否存在
    public Boolean keyExists(String key) {
        return redisTemplate.hasKey(key);
    }

    // 设置键的过期时间
    public Boolean expireKey(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    // 获取键的剩余过期时间（单位：秒）
    public Long getKeyExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    // 自增操作
    public Long increment(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    // 自减操作
    public Long decrement(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // 如果键不存在则设置值，返回是否设置成功
    public Boolean setValueIfAbsent(String key, String value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    // 获取指定范围内的字符串
    public String getRange(String key, long start, long end) {
        return redisTemplate.opsForValue().get(key, start, end);
    }

    // 追加字符串到键上的已有值的末尾
    public Integer append(String key, String value) {
        return redisTemplate.opsForValue().append(key, value);
    }

    // 删除指定键的指定范围内的值
    public Boolean deleteRange(String key, long start, long end) {
        redisTemplate.opsForValue().set(key, "", start, end);
        return true;
    }

    // 获取并设置指定键的值
    public String getAndSet(String key, String value) {
        return redisTemplate.opsForValue().getAndSet(key, value);
    }

    // 在列表头部插入值
    public Long leftPush(String key, String value) {
        return redisTemplate.opsForList().leftPush(key, value);
    }

    // 在列表尾部插入值
    public Long rightPush(String key, String value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    // 获取列表范围内的值
    public java.util.List<String> getList(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    // 在集合中添加成员
    public Long addToSet(String key, String... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    // 获取集合中的所有成员
    public java.util.Set<String> getSet(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    // 在有序集合中添加成员
    public Boolean addToZSet(String key, String value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    // 获取有序集合中指定范围内的成员
    public java.util.Set<String> getRangeByScore(String key, double min, double max) {
        return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    }

    // 删除有序集合中的成员
    public Long removeFromZSet(String key, String... values) {
        return redisTemplate.opsForZSet().remove(key, values);
    }
}

在上面的示例中，我们注入了 RedisTemplate，并定义了 setValue 和 getValue 方法来设置和获取 Redis 中的键值对。

4. 使用 RedisRepository 进行操作（可选）

如果你喜欢使用 Repository 接口来操作 Redis，可以创建一个继承自 RedisRepository 的接口。例如：

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface MyRedisRepository extends CrudRepository<MyObject, String> {
    // 可以添加自定义的操作方法
}

在这个接口中，MyObject 是你的 Redis 对象类型，它必须包含一个标识字段（通常是 String 类型的 id）。

5. 启动应用程序

启动你的 Spring Boot 应用程序，Spring Boot 将根据你的配置连接到 Redis，并使用 RedisTemplate 或 RedisRepository 进行操作。

通过以上步骤，你可以在 Spring Boot 应用程序中成功连接并操作 Redis 数据库。

6. 测试

    @Autowired
    private RedisService redisService;
    
    @Test
    void contextLoads35(){
        redisService.setValueWithExpire("name","测试", 5,TimeUnit.SECONDS);
        String name = redisService.getValue("name");
        System.out.println(name);
    }

二、Springboot 存储 Redis 在Another Redis Desktop Manager查看中乱码

这段代码的目的是配置 Spring Boot 项目中的 Redis 客户端，具体来说，是设置 RedisTemplate 的序列化方式。让我们详细分析代码的每一部分及其意义：

更新后：

1. 解决代码

@Configuration
public class RedisConfig {
    @Autowired
    private RedisTemplate redisTemplate;

    @Bean
    public RedisTemplate redisTemplateInit() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
}

1. @Configuration

• @Configuration 注解表示这个类是一个配置类，用于定义 Spring 容器的 Bean。Spring 会处理这个类中的 @Bean 注解的方法，将它们的返回值注册为 Spring 容器中的 Bean。

2. @Autowired private RedisTemplate redisTemplate;

• @Autowired 注解用于自动注入 RedisTemplate 实例。在这种情况下，redisTemplate 变量会被 Spring 自动填充一个 RedisTemplate 实例。注意，这种用法有一定的风险，因为 redisTemplate 实际上可能是未初始化的，或者初始化之前会有其他问题。

3. @Bean public RedisTemplate redisTemplateInit()

• @Bean 注解表示这个方法返回的对象会被注册为 Spring 容器中的一个 Bean。在这个方法中，返回了一个 RedisTemplate 实例。

4. redisTemplate.setKeySerializer(new StringRedisSerializer());

• 这行代码设置 Redis 键的序列化方式为 StringRedisSerializer。它将 Redis 键序列化为字符串。StringRedisSerializer 是专门用于将键序列化为字符串的序列化器。

5. redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

• 这行代码设置 Redis 值的序列化方式为 GenericJackson2JsonRedisSerializer。它将 Redis 值序列化为 JSON 格式。GenericJackson2JsonRedisSerializer 允许你将对象序列化为 JSON，使得复杂的数据结构可以存储到 Redis 中。

6. return redisTemplate;

• 返回配置好的 RedisTemplate 实例，以供 Spring 容器使用。