Redis（Remote Dictionary Server）是一款开源的、高性能的键值对（KV）内存数据库，同时支持数据持久化、多种数据结构、分布式部署等特性，常被用于缓存、会话存储、消息队列、限流削峰等场景。

1. Redis 核心特性

• 内存存储：数据默认存储在内存中，读写速度极快（QPS 可达 10 万 +）。
• 数据持久化：支持 RDB（快照）和 AOF（日志追加）两种方式，避免内存数据丢失。
• 丰富的数据结构：核心支持 String、Hash、List、Set、ZSet（有序集合），还扩展了 Bitmap、HyperLogLog、Geo 等。
• 原子操作：所有单个命令都是原子性的，支持事务（弱事务）、Lua 脚本实现复杂原子逻辑。
• 高可用：支持主从复制、哨兵（Sentinel）、集群（Cluster），保证服务高可用和水平扩展。

2. Redis 典型应用场景

• 缓存：热点数据缓存（如商品信息、用户信息），减轻数据库压力。
• 会话存储：分布式系统中存储用户会话（替代 Session）。
• 计数器：点赞数、阅读量、限流计数（INCR/DECR 原子操作）。
• 排行榜：ZSet 实现实时排名（如游戏积分、商品销量）。
• 消息队列：List 的 LPUSH/RPOP 实现简单队列，结合 BRPOP 实现阻塞队列。

3、Spring boot中体现的高级特性

1. 存储 Java 对象

        通过 GenericJackson2JsonRedisSerializer 序列化，可直接存储 / 读取对象：

// 定义实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
}

// Service 层添加方法
public void setUser(String key, User user) {
    redisTemplate.opsForValue().set(key, user, 1, TimeUnit.HOURS);
}

public User getUser(String key) {
    return (User) redisTemplate.opsForValue().get(key);
}

// 测试
@Test
public void testObject() {
    User user = new User(1002L, "王五", 30);
    redisService.setUser("user:1002", user);
    User result = redisService.getUser("user:1002");
    System.out.println(result); // 输出：User(id=1002, name=王五, age=30)
}

2. 分布式锁（基于 Redis）

        Spring Boot 中可通过 Redis 实现分布式锁（主要代码）：

/**
 * 分布式锁（加锁）
 */
public boolean lock(String lockKey, String requestId, long timeout, TimeUnit unit) {
    return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, timeout, unit));
}

/**
 * 分布式锁（解锁，防止误删）
 */
public boolean unlock(String lockKey, String requestId) {
    // 使用 Lua 脚本保证原子性
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    Long result = (Long) redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(lockKey),
            requestId
    );
    return result != null && result > 0;
}

Spring Boot 整合 Redis的相关实现

在 Spring Boot 中使用 Redis 是企业开发的主流方式，核心依赖 spring-boot-starter-data-redis 封装了 Lettuce（默认客户端），提供了极简的配置和易用的 RedisTemplate/StringRedisTemplate 操作 API。

1、引入依赖

在 Spring Boot 项目中配置 Redis 连接是使用 Redis 的基础。首先在pom.xml中添加 Redis 核心依赖和连接池依赖（连接池是性能关键，必须加）：

<!-- Spring Data Redis 核心依赖（自动适配Spring Boot版本） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- 连接池依赖（Lettuce默认依赖，但需显式引入pool2） -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

<!-- 可选：Redisson（分布式锁/高级功能，AI售后高频） -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.3</version>
</dependency>

2、基础连接配置（application.yml/application.properties）

Spring Boot 支持yml和properties两种配置格式，推荐用yml（更简洁），下面以application.yml为例：

1. 单机 Redis 配置（开发 / 测试 / 中小规模生产）

spring:
  # Redis核心配置
  redis:
    # Redis服务地址（默认127.0.0.1，生产填实际IP）
    host: 127.0.0.1
    # 端口（默认6379，若修改过需对应调整）
    port: 6379
    # 密码（无密码则注释该行，生产环境必须设置密码）
    password: your_redis_password
    # 数据库索引（Redis默认16个库，0-15，建议按业务分库）
    database: 0
    # 超时配置（连接/读取/写入超时，避免无限等待）
    timeout: 5000ms
    # Lettuce客户端配置（Spring Boot 2.x+默认，替代Jedis）
    lettuce:
      # 关闭超时时间（默认100ms，避免连接池关闭异常）
      shutdown-timeout: 100ms
      # 连接池配置（核心，解决连接泄露/性能问题）
      pool:
        # 最大活跃连接数（默认8，生产建议10-20）
        max-active: 16
        # 最大空闲连接数（默认8，建议等于max-active）
        max-idle: 16
        # 最小空闲连接数（默认0，建议2-5，快速响应请求）
        min-idle: 4
        # 最大等待时间（-1表示无限制，生产建议5000ms，避免阻塞）
        max-wait: 5000ms

2. 集群 Redis 配置（大规模生产环境）

一般生产环境采用 Redis Cluster 集群，配置如下：

spring:
  redis:
    # 集群节点（多个节点用逗号分隔）
    cluster:
      nodes:
        - 192.168.1.10:6379
        - 192.168.1.11:6379
        - 192.168.1.12:6379
      # 最大重定向次数（默认5，避免集群跳转过多）
      max-redirects: 3
    # 密码（集群所有节点密码需一致）
    password: your_redis_password
    # 数据库索引（集群模式下仅0库生效）
    database: 0
    timeout: 5000ms
    lettuce:
      pool:
        max-active: 32
        max-idle: 32
        min-idle: 8
        max-wait: 5000ms

3. 哨兵模式配置（高可用单机集群）

spring:
  redis:
    # 哨兵配置
    sentinel:
      # 主节点名称（与Redis哨兵配置的master-name一致）
      master: mymaster
      # 哨兵节点（多个用逗号分隔）
      nodes: 192.168.1.20:26379,192.168.1.21:26379
    password: your_redis_password
    database: 0
    timeout: 5000ms
    lettuce:
      pool:
        max-active: 16
        max-idle: 16
        min-idle: 4
        max-wait: 5000ms

3、序列化配置（解决 Redis Key/Value 乱码）

Spring Boot 默认用 JDK 序列化，会导致 Redis 中 Key 显示为\xAC\xED\x00\x05t\x00\x10 :token这种乱码，必须自定义序列化配置：

核心配置代码

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

/**
 * Redis序列化配置（解决乱码问题）
 */
@Configuration
public class RedisConfig {

    /**
     * 自定义RedisTemplate（通用型，支持Object类型Value）
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // ========== Key序列化（必须为String，避免乱码） ==========
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);

        // ========== Value序列化（JSON格式，兼容对象/基本类型） ==========
        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();
        redisTemplate.setValueSerializer(jsonSerializer);
        redisTemplate.setHashValueSerializer(jsonSerializer);

        // 初始化配置
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 字符串专用RedisTemplate（轻量，无需序列化，AI售后高频用）
     */
    @Bean
    public RedisTemplate<String, String> stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, String> stringRedisTemplate = new RedisTemplate<>();
        stringRedisTemplate.setConnectionFactory(redisConnectionFactory);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        stringRedisTemplate.setKeySerializer(stringRedisSerializer);
        stringRedisTemplate.setValueSerializer(stringRedisSerializer);
        stringRedisTemplate.setHashKeySerializer(stringRedisSerializer);
        stringRedisTemplate.setHashValueSerializer(stringRedisSerializer);
        stringRedisTemplate.afterPropertiesSet();
        return stringRedisTemplate;
    }
}

总结

1. 核心配置：Spring Boot 中 Redis 配置分基础连接（host/port/password）、连接池（lettuce.pool）、序列化（解决乱码） 三部分，缺一不可；
2. Redis连接如何选择：单机配置用于开发 / 中小规模，集群 / 哨兵用于大规模生产；
3. 核心场景：String 用于缓存 / 计数、Hash 用于存储对象、ZSet 用于排行榜、List 用于消息队列，结合过期时间和分布式锁可满足大部分业务需求。