Redis 教程

redis/
├── redis-server.exe    # 服务端程序
├── redis-cli.exe       # 客户端程序
├── redis.windows.conf  # 配置文件
└── ...

# 方式1: 使用默认配置
redis-server.exe

# 方式2: 指定配置文件（推荐）
redis-server.exe redis.windows.conf

[*****] # Server initialized
[*****] * Ready to accept connections

# 连接本地默认端口
redis-cli.exe

# 连接指定主机和端口
redis-cli.exe -h localhost -p 6379

# 连接带密码的Redis
redis-cli.exe -h localhost -p 6379 -a password

# 拉取官方镜像
docker pull redis:7.2-alpine

# 启动 Redis 容器
docker run -d \
  --name redis-demo \
  -p 6379:6379 \
  -v /docker/redis-data:/data \
  redis:7.2-alpine \
  redis-server --appendonly yes

# 查看容器状态
docker ps

# 进入 Redis 命令行
docker exec -it redis-demo redis-cli

# 测试连接
PING

# 停止容器
docker stop redis-demo

# 启动已存在的容器
docker start redis-demo

# 删除容器（删除前先停止）
docker rm -f redis-demo

# 是否以守护进程方式运行（Linux）
daemonize no

# 客户端超时时间（0表示不超时）
timeout 0

# 端口号（默认6379）
port 6379

# 绑定地址
bind 127.0.0.1
# bind 0.0.0.0  # 允许所有IP连接（生产环境慎用）

# 日志级别: debug | verbose | notice | warning
loglevel notice

# 数据库数量（默认16个）
databases 16

# 设置密码
requirepass your_password

# 快照保存目录
dir /var/lib/redis

# 快照文件名
dbfilename dump.rdb

# 触发策略: save <秒> <变化次数>
save 900 1      # 900秒内至少1次修改
save 300 10     # 300秒内至少10次修改
save 60 10000   # 60秒内至少10000次修改

# 开启AOF
appendonly yes

# AOF文件路径（与RDB共用dir配置）
dir /var/lib/redis

# AOF文件名
appendfilename "appendonly.aof"

# 同步策略
# appendfsync always    # 每条命令都同步（最安全，最慢）
appendfsync everysec    # 每秒同步（推荐）
# appendfsync no        # 由操作系统决定

user:1001:name
user:1001:cart
order:20240501:10001
article:1001:view

# 切换数据库（0-15，默认0）
SELECT index

# 密码认证
AUTH password

# 查找key（支持通配符: * ? []）
KEYS pattern
KEYS *          # 查看所有key
KEYS user:*     # 查看前缀为user:的key

# 清空所有数据库（危险操作！）
FLUSHALL

# 清空当前数据库
FLUSHDB

# 删除key
DEL key

# 查看key类型
TYPE key

# 设置key过期时间（秒）
EXPIRE key seconds

# 查看key剩余生存时间
TTL key

# 设置key-value（key存在则覆盖）
SET key value

# 获取value
GET key

# 批量设置
MSET key1 value1 key2 value2 ...

# 批量获取
MGET key1 key2 ...

# 数值+1
INCR key

# 数值+指定步长
INCRBY key increment

# 数值-1
DECR key

# 数值-指定步长
DECRBY key decrement

# 设置key并指定过期时间（秒）
SETEX key seconds value

# 仅当key不存在时才设置
SETNX key value

# 从左侧插入
LPUSH key value1 value2 ...

# 从左侧弹出
LPOP key

# 从右侧插入
RPUSH key value1 value2 ...

# 从右侧弹出
RPOP key

# 获取列表长度
LLEN key

# 获取指定范围元素（0表示第一个，-1表示最后一个）
LRANGE key start stop

# 获取指定索引元素
LINDEX key index

# 在指定元素前/后插入
LINSERT key BEFORE|AFTER pivot value

# 修改指定索引元素
LSET key index value

# 删除指定元素（count>0从头删，count<0从尾删，count=0全删）
LREM key count value

# 添加成员
SADD key member1 member2 ...

# 获取成员数量
SCARD key

# 获取所有成员
SMEMBERS key

# 判断成员是否存在
SISMEMBER key member

# 随机弹出指定数量成员
SPOP key [count]

# 随机获取指定数量成员（不删除）
SRANDMEMBER key [count]

# 求交集
SINTER key1 key2 ...

# 求交集并保存
SINTERSTORE destination key1 key2 ...

# 求并集
SUNION key1 key2 ...

# 求并集并保存
SUNIONSTORE destination key1 key2 ...

# 求差集
SDIFF key1 key2 ...

# 求差集并保存
SDIFFSTORE destination key1 key2 ...

# 移动成员到另一个集合
SMOVE source destination member

# 删除成员
SREM key member1 member2 ...

# 设置字段
HSET key field value

# 获取字段值
HGET key field

# 批量设置
HMSET key field1 value1 field2 value2 ...

# 批量获取
HMGET key field1 field2 ...

# 判断字段是否存在
HEXISTS key field

# 获取所有字段和值
HGETALL key

# 获取所有字段
HKEYS key

# 获取所有值
HVALS key

# 获取字段数量
HLEN key

# 字段值增加指定数值
HINCRBY key field increment

# 仅当字段不存在时才设置
HSETNX key field value

# 删除字段
HDEL key field1 field2 ...

# 添加成员（分数在前）
ZADD key score1 member1 score2 member2 ...

# 获取成员数量
ZCARD key

# 获取指定分数区间成员数量
ZCOUNT key min max

# 获取成员分数
ZSCORE key member

# 增加成员分数
ZINCRBY key increment member

# 按排名升序获取（0表示第一名）
ZRANGE key start stop [WITHSCORES]

# 按排名降序获取
ZREVRANGE key start stop [WITHSCORES]

# 按分数升序获取
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

# 按分数降序获取
ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

# 获取成员升序排名
ZRANK key member

# 获取成员降序排名
ZREVRANK key member

# 删除成员
ZREM key member1 member2 ...

# 删除指定排名区间成员
ZREMRANGEBYRANK key start stop

# 删除指定分数区间成员
ZREMRANGEBYSCORE key min max

# 配置最大内存
maxmemory 256mb

# 配置淘汰策略
maxmemory-policy allkeys-lru

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.4.3</version>
</dependency>

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisDemo {
    
    // 单连接（不推荐生产使用）
    public void basicUsage() {
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.auth("password");  // 如果有密码
        
        jedis.set("key", "value");
        String value = jedis.get("key");
        System.out.println(value);
        
        jedis.close();
    }
    
    // 连接池（推荐）
    public void poolUsage() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(100);      // 最大连接数
        config.setMaxIdle(50);        // 最大空闲连接
        config.setMinIdle(10);        // 最小空闲连接
        
        try (JedisPool pool = new JedisPool(config, "localhost", 6379, 3000, "password");
             Jedis jedis = pool.getResource()) {
            
            jedis.set("pool:key", "value");
            String value = jedis.get("pool:key");
            System.out.println(value);
        }
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
import redis.clients.jedis.Jedis;

public class JedisJsonDemo {

    private static final ObjectMapper MAPPER = new ObjectMapper();

    public void saveUser() throws Exception {
        try (Jedis jedis = new Jedis("localhost", 6379)) {
            jedis.auth("password");

            User user = new User(1L, "zhangsan", "zhangsan@example.com");
            String json = MAPPER.writeValueAsString(user);

            jedis.set("user:1", json);
        }
    }

    public User getUser() throws Exception {
        try (Jedis jedis = new Jedis("localhost", 6379)) {
            jedis.auth("password");

            String json = jedis.get("user:1");
            return json == null ? null : MAPPER.readValue(json, User.class);
        }
    }
}

public void dataTypeOperations(Jedis jedis) {
    // String
    jedis.set("user:1:name", "张三");
    jedis.expire("user:1:name", 3600);
    
    // Hash
    jedis.hset("user:1", "name", "张三");
    jedis.hset("user:1", "age", "25");
    Map<String, String> user = jedis.hgetAll("user:1");
    
    // List
    jedis.lpush("queue:tasks", "task1", "task2");
    String task = jedis.rpop("queue:tasks");
    
    // Set
    jedis.sadd("tags:article:1", "java", "redis");
    Set<String> tags = jedis.smembers("tags:article:1");
    
    // Sorted Set
    jedis.zadd("rank:score", 100, "player1");
    jedis.zadd("rank:score", 95, "player2");
    Set<Tuple> topPlayers = jedis.zrevrangeWithScores("rank:score", 0, 9);
}

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

<!-- 连接池 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

spring:
  data:
    redis:
      host: localhost
      port: 6379
      password:
      database: 0
      timeout: 3000ms
      lettuce:
        pool:
          max-active: 8      # 最大连接数
          max-idle: 8        # 最大空闲连接
          min-idle: 0        # 最小空闲连接
          max-wait: 1000ms   # 最大等待时间

@Service
public class RedisService {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    // String操作
    public void stringOps() {
        redisTemplate.opsForValue().set("key", "value");
        redisTemplate.opsForValue().set("key", "value", 30, TimeUnit.SECONDS);
        String value = redisTemplate.opsForValue().get("key");
    }
    
    // Hash操作
    public void hashOps() {
        redisTemplate.opsForHash().put("user:profile:1", "name", "张三");
        redisTemplate.opsForHash().put("user:profile:1", "age", "25");
        Map<Object, Object> entries = redisTemplate.opsForHash().entries("user:profile:1");
    }
    
    // List操作
    public void listOps() {
        redisTemplate.opsForList().leftPush("queue", "task1");
        String task = redisTemplate.opsForList().rightPop("queue");
    }
    
    // Set操作
    public void setOps() {
        redisTemplate.opsForSet().add("tags", "java", "redis");
        Set<String> tags = redisTemplate.opsForSet().members("tags");
    }
    
    // Sorted Set操作
    public void zsetOps() {
        redisTemplate.opsForZSet().add("rank", "player1", 100);
        Set<ZSetOperations.TypedTuple<String>> top = 
            redisTemplate.opsForZSet().reverseRangeWithScores("rank", 0, 9);
    }
}

@Configuration
public class RedisConfig {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        
        // 使用JSON序列化，避免 Jackson 版本差异带来的编译问题
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();
        
        // 设置key和value的序列化方式
        template.setKeySerializer(stringSerializer);
        template.setValueSerializer(jsonSerializer);
        template.setHashKeySerializer(stringSerializer);
        template.setHashValueSerializer(jsonSerializer);
        
        template.afterPropertiesSet();
        return template;
    }
}

public class User {
    private Integer id;
    private String name;
    private Integer age;

    public User() {
    }

    public User(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

@Service
public class UserRedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void saveUser() {
        User user = new User(1, "张三", 25);
        redisTemplate.opsForValue().set("user:object:1", user);
        redisTemplate.expire("user:object:1", 30, TimeUnit.MINUTES);
    }

    public User getUser() {
        Object obj = redisTemplate.opsForValue().get("user:object:1");
        return obj == null ? null : (User) obj;
    }
}

@RestController
@RequestMapping("/redis/user")
public class UserRedisController {

    @Autowired
    private UserRedisService userRedisService;

    @GetMapping("/save")
    public String saveUser() {
        userRedisService.saveUser();
        return "保存成功";
    }

    @GetMapping
    public User getUser() {
        return userRedisService.getUser();
    }
}