Redis总结

1
SET：添加或者修改已经存在的一个String类型的键值对
2
     如果key不存在则是新增，如果存在则是修改
3

4
GET：根据key获取String类型的value
5

6
MSET：批量添加多个String类型的键值对
7

8
MGET：根据多个key获取多个String类型的value
9

10
INCR：让一个整型的key自增1
11

12
INCRBY:让一个整型的key自增并指定步长，例如：incrby num 2 让num值自增2
13

14
SET NX：添加一个String类型的键值对，前提是这个key不存在，否则不执行
15
set name yifei nx
16

17
SET EX：添加一个String类型的键值对，并且指定有效期
18
set name liyifei ex 10
19

20
APPEND key value // 将指定的value追加到该key原来值value的末尾

1
HSET key field value：添加或者修改hash类型key的field的值
2
HSET heima:user:3 name Lucy
3

4
HGET key field：获取一个hash类型key的field的值
5
HGET heima:user:3 name
6

7
HMSET：批量添加多个hash类型key的field的值
8
HMSET heima:user:3 name LiLei age 20
9

10
HMGET：批量获取多个hash类型key的field的值
11
HMGET heima:user:3 name age
12

13
HGETALL：获取一个hash类型的key中的所有的field和value
14

15
HKEYS：获取一个hash类型的key中的所有的field
16

17
HINCRBY:让一个hash类型key的字段值自增并指定步长
18

19
HSETNX：添加一个hash类型的key的field值，前提是这个field不存在，否则不执行

1
SADD key member ：向set中添加一个或多个元素
2

3
SREM key member : 移除set中的指定元素
4

5
SCARD key： 返回set中元素的个数
6

7
SISMEMBER key member：判断一个元素是否存在于set中
8

9
SMEMBERS：获取set中的所有元素
10

11
SINTER key1 key2 ：求key1与key2的交集
12

13
SDIFF key1 key2 ：求key1与key2的差集
14

15
SUNION key1 key2 ：求key1和key2的并集

1
ZADD key score member：添加一或多个元素,如已存在则更新其score值
2

3
ZCARD key：获取sorted set中的元素个数
4

5
ZREM key member：删除sorted set中的一个指定元素
6

7
ZSCORE key member : 获取sorted set中的指定元素的score值
8

9
ZRANK key member：获取sorted set 中的指定元素的排名
10

11
ZCOUNT key min max：统计score值在给定范围内的所有元素的个数
12

13
ZINCRBY key increment member：让sorted set中的指定元素自增，步长为increment
14

15
ZRANGE key min max：按照score排序后，获取指定排名范围内的元素
16

17
ZRANGEBYSCORE key min max：按照score排序后，获取指定score范围内的元素
18

19
ZDIFF.ZINTER.ZUNION：求差集.交集.并集
20

21
注意：所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可
22

23
升序获取sorted set 中的指定元素的排名：ZRANK key member
24

25
降序获取sorted set 中的指定元素的排名：ZREVRANK key memebe

1
public class JedisConnectionFacotry {
2
     private static final JedisPool jedisPool;
3
     static {
4
         //配置连接池
5
         JedisPoolConfig poolConfig = new JedisPoolConfig();
6
         poolConfig.setMaxTotal(8);
7
         poolConfig.setMaxIdle(8);
8
         poolConfig.setMinIdle(0);
9
         poolConfig.setMaxWaitMillis(1000);
10
         //创建连接池对象
11
         jedisPool = new JedisPool(poolConfig,
12
                 "192.168.150.101",6379,1000,"123321");
13
     }
14

15
     public static Jedis getJedis(){
16
          return jedisPool.getResource();
17
     }
18
}

1
    @BeforeEach
2
    void setUp(){
3
        //建立连接
4
        /*jedis = new Jedis("127.0.0.1",6379);*/
5
        jedis = JedisConnectionFacotry.getJedis();
6
         //选择库
7
        jedis.select(0);
8
    }
9

10
   @AfterEach
11
    void tearDown() {
12
        if (jedis != null) {
13
            jedis.close();
14
        }
15
    }

1
//自定义序列化器
2
@Configuration
3
public class RedisConfig {
4
    @Bean
5
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
6
        // 创建RedisTemplate对象
7
        RedisTemplate<String, Object> template = new RedisTemplate<>();
8

9
        // 设置连接工厂
10
        template.setConnectionFactory(connectionFactory);
11

12
        // 创建JSON序列化工具
13
        GenericJackson2JsonRedisSerializer jsonRedisSerializer =
14
                          new GenericJackson2JsonRedisSerializer();
15
        // 设置Key的序列化
16
        template.setKeySerializer(RedisSerializer.string());
17
        template.setHashKeySerializer(RedisSerializer.string());
18
        // 设置Value的序列化
19
        template.setValueSerializer(jsonRedisSerializer);
20
        template.setHashValueSerializer(jsonRedisSerializer);
21
        // 返回
22
        return template;
23
    }
24
}
25
自定义RedisTemplate
26

27
修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer

1
@Autowired
2
    private StringRedisTemplate stringRedisTemplate;
3

4
    @Test
5
    void testString() {
6
        // 写入一条对象Hash数据
7
        stringRedisTemplate.opsForValue().set("verify:phone:13600527634", "124143");
8
        // 获取string数据
9
        Object name = stringRedisTemplate.opsForValue().get("name");
10
        System.out.println("name = " + name);
11
    }
12

13
    private static final ObjectMapper mapper = new ObjectMapper();
14

15
    @Test
16
    void testSaveUser() throws JsonProcessingException {
17
        // 创建对象
18
        User user = new User("虎哥", 21);
19
        // 手动序列化
20
        String json = mapper.writeValueAsString(user);
21

22
        // 写入数据
23
        stringRedisTemplate.opsForValue().set("user:200", json);
24

25
        // 获取数据
26
        String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
27
        // 手动反序列化
28
        User user1 = mapper.readValue(jsonUser, User.class);
29
        System.out.println("user1 = " + user1);
30
    }

1
// Java + Jedis/Lettuce 示例
2
@Autowired
3
private StringRedisTemplate redisTemplate;
4

5
// 1. String - 缓存用户信息
6
public void cacheUser(User user) {
7
    String key = "user:" + user.getId();
8
    // 序列化为 JSON
9
    String json = JSON.toJSONString(user);
10
    redisTemplate.opsForValue().set(key, json, 30, TimeUnit.MINUTES);
11
}
12

13
// 2. Hash - 存储商品信息
14
public void cacheGoods(Goods goods) {
15
    String key = "goods:" + goods.getId();
16
    Map<String, String> map = new HashMap<>();
17
    map.put("name", goods.getName());
18
    map.put("price", goods.getPrice().toString());
19
    map.put("stock", String.valueOf(goods.getStock()));
20

21
    redisTemplate.opsForHash().putAll(key, map);
22
    redisTemplate.expire(key, 10, TimeUnit.MINUTES);
23
}
24

25
// 3. Sorted Set - 排行榜
26
public void updateScore(Long userId, Double score) {
27
    String key = "ranking:sales";
28
    redisTemplate.opsForZSet().add(key, userId.toString(), score);
29
}
30

31
// 获取 TOP 10
32
public List<Long> getTopUsers(int limit) {
33
    String key = "ranking:sales";
34
    Set<String> result = redisTemplate.opsForZSet()
35
            .reverseRange(key, 0, limit - 1);
36

37
    return result.stream()
38
            .map(Long::parseLong)
39
            .collect(Collectors.toList());
40
}
41

42
// 4. List - 消息队列
43
public void pushMessage(String message) {
44
    redisTemplate.opsForList().leftPush("queue:message", message);
45
}
46

47
public String popMessage() {
48
    return redisTemplate.opsForList().rightPop("queue:message");
49
}
50

51
// 5. Set - 共同好友
52
public Set<String> getCommonFriends(Long userId1, Long userId2) {
53
    String key1 = "friends:" + userId1;
54
    String key2 = "friends:" + userId2;
55

56
    return redisTemplate.opsForSet().intersect(key1, key2);
57
}

1
删除缓存失败的概率远小于更新数据库失败
2
  即使删除失败，缓存有过期时间，最终会一致
3
  实现简单，性能好
4
@Service
5
public class GoodsService {
6
    @Autowired
7
    private GoodsMapper goodsMapper;
8

9
    @Autowired
10
    private StringRedisTemplate redisTemplate;
11

12
    @Transactional
13
    public void updatePrice(Long goodsId, BigDecimal newPrice) {
14
        String cacheKey = "goods:" + goodsId;
15

16
        // 1. 先更新数据库
17
        Goods goods = new Goods();
18
        goods.setId(goodsId);
19
        goods.setPrice(newPrice);
20
        goodsMapper.updateById(goods);
21

22
        // 2. 再删除缓存
23
        redisTemplate.delete(cacheKey);
24

25
        // 为什么不更新缓存？
26
        // 1. 删除操作更简单
27
        // 2. 避免并发写入导致的缓存脏数据
28
        // 3. 懒加载：下次读取时再写入最新数据
29
    }
30

31
    public Goods getGoods(Long goodsId) {
32
        String cacheKey = "goods:" + goodsId;
33

34
        // 1. 查缓存
35
        String json = redisTemplate.opsForValue().get(cacheKey);
36
        if (json != null) {
37
            return JSON.parseObject(json, Goods.class);
38
        }
39

40
        // 2. 缓存未命中，查数据库
41
        Goods goods = goodsMapper.selectById(goodsId);
42
        if (goods == null) {
43
            return null;
44
        }
45

46
        // 3. 写入缓存
47
        redisTemplate.opsForValue().set(
48
            cacheKey,
49
            JSON.toJSONString(goods),
50
            10, TimeUnit.MINUTES
51
        );
52

53
        return goods;
54
    }
55
}

1
@Service
2
public class GoodsService {
3
    @Autowired
4
    private StringRedisTemplate redisTemplate;
5

6
    @Autowired
7
    private GoodsMapper goodsMapper;
8

9
    @Transactional
10
    public void updatePrice(Long goodsId, BigDecimal newPrice) {
11
        String cacheKey = "goods:" + goodsId;
12

13
        // 1. 第一次删除缓存
14
        redisTemplate.delete(cacheKey);
15

16
        // 2. 更新数据库
17
        goodsMapper.updatePrice(goodsId, newPrice);
18

19
        // 3. 延迟双删（异步）
20
        CompletableFuture.runAsync(() -> {
21
            try {
22
                // 延迟 500ms
23
                Thread.sleep(500);
24

25
                // 第二次删除缓存
26
                redisTemplate.delete(cacheKey);
27

28
                log.info("延迟双删成功: {}", cacheKey);
29
            } catch (InterruptedException e) {
30
                log.error("延迟双删失败", e);
31
            }
32
        });
33
    }
34
}

1
// Canal 客户端监听器
2
@Component
3
public class CanalListener {
4
    @Autowired
5
    private StringRedisTemplate redisTemplate;
6

7
    @CanalListener
8
    public void onEvent(CanalEntry.Entry entry) {
9
        // 1. 解析 Binlog 事件
10
        String tableName = entry.getHeader().getTableName();
11
   CanalEntry.EventType eventType = entry.getHeader().getEventType();
12

13
        // 2. 只处理 UPDATE 和 DELETE 事件
14
        if (eventType != CanalEntry.EventType.UPDATE &&
15
            eventType != CanalEntry.EventType.DELETE) {
16
            return;
17
        }
18

19
        // 3. 解析行数据
20
        CanalEntry.RowChange rowChange = CanalEntry.RowChange.parseFrom(
21
            entry.getStoreValue()
22
        );
23

24
        for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
25
            // 获取主键 ID
26
            String id = null;
27
            for (CanalEntry.Column column : rowData.getAfterColumnsList()) {
28
                if (column.getIsKey()) {
29
                    id = column.getValue();
30
                    break;
31
                }
32
            }
33

34
            // 4. 删除对应缓存
35
            if (id != null) {
36
                String cacheKey = tableName + ":" + id;
37
                redisTemplate.delete(cacheKey);
38
                log.info("Canal删除缓存: {}", cacheKey);
39
            }
40
        }
41
    }
42
}

1
public Goods getGoods(Long goodsId) {
2
    String cacheKey = "goods:" + goodsId;
3

4
    // 1. 查缓存
5
    String json = redisTemplate.opsForValue().get(cacheKey);
6

7
    // 缓存命中
8
    if (json != null) {
9
        // 如果是空字符串，说明数据不存在
10
        if ("".equals(json)) {
11
            return null;
12
        }
13
        return JSON.parseObject(json, Goods.class);
14
    }
15

16
    // 2. 查数据库
17
    Goods goods = goodsMapper.selectById(goodsId);
18

19
    if (goods != null) {
20
        // 3.1 数据存在，缓存正常对象
21
        redisTemplate.opsForValue().set(
22
            cacheKey,
23
            JSON.toJSONString(goods),
24
            10, TimeUnit.MINUTES
25
        );
26
    } else {
27
        // 3.2 数据不存在，缓存空字符串，过期时间短一些
28
        redisTemplate.opsForValue().set(
29
            cacheKey,
30
            "",
31
            2, TimeUnit.MINUTES
32
        );
33
    }
34

35
    return goods;
36
}

1
@Configuration
2
public class BloomFilterConfig {
3
    @Bean
4
    public RBloomFilter<Long> goodsBloomFilter(RedissonClient redisson) {
5
        RBloomFilter<Long> bloomFilter = redisson.getBloomFilter("goods:bloom");
6
        // 预计元素数量 1000万，误判率 0.01
7
        bloomFilter.tryInit(10000000L, 0.01);
8
        return bloomFilter;
9
    }
10

11
    @PostConstruct
12
    public void initBloomFilter() {
13
        List<Long> allGoodsIds = goodsMapper.selectAllIds();
14
        for (Long id : allGoodsIds) {
15
            goodsBloomFilter.add(id);
16
        }
17
        log.info("布隆过滤器初始化完成，加载商品数: {}", allGoodsIds.size());
18
    }
19
}
20

21
@Service
22
public class GoodsService {
23
    @Autowired
24
    private RBloomFilter<Long> goodsBloomFilter;
25

26
    public Goods getGoods(Long goodsId) {
27
        // 1. 先用布隆过滤器判断
28
        if (!goodsBloomFilter.contains(goodsId)) {
29
            // 100% 不存在
30
            return null;
31
        }
32

33
        // 2. 可能存在，继续查缓存和DB
34
        String cacheKey = "goods:" + goodsId;
35
        String json = redisTemplate.opsForValue().get(cacheKey);
36
        if (json != null) {
37
            return JSON.parseObject(json, Goods.class);
38
        }
39

40
        Goods goods = goodsMapper.selectById(goodsId);
41
        if (goods != null) {
42
            redisTemplate.opsForValue().set(
43
                cacheKey,
44
                JSON.toJSONString(goods),
45
                10, TimeUnit.MINUTES
46
            );
47
        }
48

49
        return goods;
50
    }
51

52
    // 新增商品时添加到布隆过滤器
53
    public void addGoods(Goods goods) {
54
        goodsMapper.insert(goods);
55
        goodsBloomFilter.add(goods.getId());
56
    }
57
}

1
public Goods getGoods(Long goodsId) {
2
    String cacheKey = "goods:" + goodsId;
3

4
    // 1. 查缓存
5
    String json = redisTemplate.opsForValue().get(cacheKey);
6
    if (json != null) {
7
        return JSON.parseObject(json, Goods.class);
8
    }
9

10
    // 2. 缓存未命中，加互斥锁
11
    String lockKey = "lock:goods:" + goodsId;
12

13
    try {
14
        // 尝试获取锁，10秒超时
15
        Boolean locked = redisTemplate.opsForValue()
16
                .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
17

18
        if (Boolean.TRUE.equals(locked)) {
19
            // 3. 获取锁成功，查数据库
20
            Goods goods = goodsMapper.selectById(goodsId);
21

22
            if (goods != null) {
23
                // 4. 写入缓存
24
                redisTemplate.opsForValue().set(
25
                    cacheKey,
26
                    JSON.toJSONString(goods),
27
                    10, TimeUnit.MINUTES
28
                );
29
            }
30
            return goods;
31
        } else {
32
            // 5. 获取锁失败，等待一下再重试
33
            Thread.sleep(50);
34
            return getGoods(goodsId);  // 递归重试
35
        }
36

37
    } catch (InterruptedException e) {
38
        throw new RuntimeException(e);
39
    } finally {
40
        // 6. 释放锁
41
        redisTemplate.delete(lockKey);
42
    }
43
}

1
@Autowired
2
private RedissonClient redisson;
3

4
public Goods getGoods(Long goodsId) {
5
    String cacheKey = "goods:" + goodsId;
6

7
    // 1. 查缓存
8
    String json = redisTemplate.opsForValue().get(cacheKey);
9
    if (json != null) {
10
        return JSON.parseObject(json, Goods.class);
11
    }
12

13
    // 2. 缓存未命中，使用 Redisson 锁
14
    String lockKey = "lock:goods:" + goodsId;
15
    RLock lock = redisson.getLock(lockKey);
16

17
    try {
18
        // 尝试加锁，最多等待5秒，锁10秒后自动释放
19
        if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
20
            // 3. 双重检查：再次查缓存（可能其他线程已写入）
21
            json = redisTemplate.opsForValue().get(cacheKey);
22
            if (json != null) {
23
                return JSON.parseObject(json, Goods.class);
24
            }
25

26
            // 4. 查数据库
27
            Goods goods = goodsMapper.selectById(goodsId);
28

29
            if (goods != null) {
30
                // 5. 写入缓存
31
                redisTemplate.opsForValue().set(
32
                    cacheKey,
33
                    JSON.toJSONString(goods),
34
                    10, TimeUnit.MINUTES
35
                );
36
            }
37

38
            return goods;
39
        } else {
40
            // 获取锁失败，返回错误或默认值
41
            throw new RuntimeException("系统繁忙，请稍后重试");
42
        }
43
    } catch (InterruptedException e) {
44
        throw new RuntimeException(e);
45
    } finally {
46
        if (lock.isHeldByCurrentThread()) {
47
            lock.unlock();
48
        }
49
    }
50
}

1
public Goods getGoods(Long goodsId) {
2
    String cacheKey = "goods:" + goodsId;
3

4
    // 1. 查缓存（缓存永不过期）
5
    String json = redisTemplate.opsForValue().get(cacheKey);
6

7
    if (json == null) {
8
        // 缓存不存在，直接查DB并写入（首次访问）
9
        return loadAndCache(goodsId);
10
    }
11

12
    // 2. 从Redis里查到数据，解析缓存数据
13
    CacheData<Goods> cacheData = JSON.parseObject(json,
14
        new TypeReference<CacheData<Goods>>() {});
15

16
    // 3. 检查逻辑过期时间
17
    if (!cacheData.isExpired()) {
18
        // 未过期，直接返回
19
        return cacheData.getData();
20
    }
21

22
    // 4. 已过期，异步刷新缓存
23
    String lockKey = "lock:refresh:" + goodsId;
24
    Boolean locked = redisTemplate.opsForValue()
25
            .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
26

27
    if (Boolean.TRUE.equals(locked)) {
28
        // 获取锁成功，异步刷新
29
        CompletableFuture.runAsync(() -> {
30
            try {
31
            //查询数据库,存入新数据进入Redis
32
                loadAndCache(goodsId);
33
            } finally {
34
                redisTemplate.delete(lockKey);
35
            }
36
        });
37
    }
38

39
    // 5. 返回旧数据（用户无感知）
40
    return cacheData.getData();
41
}
42

43
private Goods loadAndCache(Long goodsId) {
44
    String cacheKey = "goods:" + goodsId;
45

46
    // 查数据库
47
    Goods goods = goodsMapper.selectById(goodsId);
48

49
    if (goods != null) {
50
        // 包装为逻辑过期对象
51
        CacheData<Goods> cacheData = new CacheData<>();
52
        cacheData.setData(goods);
53
        cacheData.setExpireTime(
54
            System.currentTimeMillis() + 10 * 60 * 1000  // 10分钟后逻辑过期
55
        );
56

57
        // 写入缓存（不设置过期时间）
58
        redisTemplate.opsForValue().set(
59
            cacheKey,
60
            JSON.toJSONString(cacheData)
61
        );
62
    }
63

64
    return goods;
65
}

1
public void cacheGoods(Goods goods) {
2
    String cacheKey = "goods:" + goods.getId();
3
    String json = JSON.toJSONString(goods);
4

5
    // 基础过期时间 10 分钟
6
    long baseExpire = 10 * 60;
7

8
    // 加上随机时间 0-5 分钟
9
    long randomExpire = ThreadLocalRandom.current().nextLong(0, 5 * 60);
10

11
    // 实际过期时间 = 10~15 分钟随机
12
    redisTemplate.opsForValue().set(
13
        cacheKey,
14
        json,
15
        baseExpire + randomExpire,
16
        TimeUnit.SECONDS
17
    );
18
}

1
// 项目启动时预热热点数据
2
@Component
3
public class CacheWarmer {
4
    @Autowired
5
    private GoodsMapper goodsMapper;
6

7
    @Autowired
8
    private StringRedisTemplate redisTemplate;
9

10
    @PostConstruct
11
    public void warmUpCache() {
12
        // 1. 查询热门商品（如销量TOP 1000）
13
        List<Goods> hotGoods = goodsMapper.selectHotGoods(1000);
14

15
        // 2. 写入缓存，过期时间随机
16
        for (Goods goods : hotGoods) {
17
            String cacheKey = "goods:" + goods.getId();
18
            String json = JSON.toJSONString(goods);
19

20
            // 过期时间：30分钟 + 0~10分钟随机
21
            long expireTime = 30 * 60 + ThreadLocalRandom.current().nextLong(0, 10 * 60);
22

23
            redisTemplate.opsForValue().set(
24
                cacheKey,
25
                json,
26
                expireTime,
27
                TimeUnit.SECONDS
28
            );
29
        }
30

31
        log.info("缓存预热完成，加载商品数: {}", hotGoods.size());
32
    }
33
}

1
@Configuration
2
public class CacheConfig {
3
    @Bean
4
    public Cache<String, String> localCache() {
5
        return Caffeine.newBuilder()
6
                .maximumSize(10000)  // 最多缓存10000个
7
                .expireAfterWrite(5, TimeUnit.MINUTES)  // 5分钟过期
8
                .recordStats()  // 启用统计
9
                .build();
10
    }
11
}
12

13
@Service
14
public class GoodsService {
15
    @Autowired
16
    private Cache<String, String> localCache;
17

18
    @Autowired
19
    private StringRedisTemplate redisTemplate;
20

21
    @Autowired
22
    private GoodsMapper goodsMapper;
23

24
    public Goods getGoods(Long goodsId) {
25
        String cacheKey = "goods:" + goodsId;
26

27
        // 1. 查本地缓存
28
        String json = localCache.getIfPresent(cacheKey);
29
        if (json != null) {
30
            return JSON.parseObject(json, Goods.class);
31
        }
32

33
        // 2. 查 Redis 缓存
34
        json = redisTemplate.opsForValue().get(cacheKey);
35
        if (json != null) {
36
            // 写入本地缓存
37
            localCache.put(cacheKey, json);
38
            return JSON.parseObject(json, Goods.class);
39
        }
40

41
        // 3. 查数据库
42
        Goods goods = goodsMapper.selectById(goodsId);
43
        if (goods != null) {
44
            json = JSON.toJSONString(goods);
45

46
            // 写入 Redis
47
            redisTemplate.opsForValue().set(
48
                cacheKey,
49
                json,
50
                10, TimeUnit.MINUTES
51
            );
52

53
            // 写入本地缓存
54
            localCache.put(cacheKey, json);
55
        }
56

57
        return goods;
58
    }
59
}

1
// 1. 创建 epoll 实例
2
int epfd = epoll_create(1024);
3

4
// 2. 注册监听的文件描述符
5
struct epoll_event ev;
6
ev.events = EPOLLIN;  // 监听可读事件
7
ev.data.fd = client_fd;
8
epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);
9

10
// 3. 等待事件就绪
11
struct epoll_event events[MAX_EVENTS];
12
int nfds = epoll_wait(epfd, events, MAX_EVENTS, timeout);
13

14
// 4. 处理就绪事件
15
for (int i = 0; i < nfds; i++) {
16
    if (events[i].events & EPOLLIN) {
17
        // 读取数据
18
        read(events[i].data.fd, buffer, sizeof(buffer));
19
        // 处理命令
20
        process_command(buffer);
21
    }
22
}

1
def redis_event_loop():
2
    # 创建 epoll 实例
3
    epoll_fd = epoll_create()
4

5
    # 监听服务端口
6
    listen_fd = socket.socket()
7
    listen_fd.bind(('0.0.0.0', 6379))
8
    listen_fd.listen(128)
9

10
    # 注册监听 socket
11
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, EPOLLIN)
12

13
    # 事件循环
14
    while True:
15
        # 等待事件就绪（超时时间很短，避免阻塞过期key清理等任务）
16
        ready_events = epoll_wait(epoll_fd, timeout=10ms)
17

18
        for event in ready_events:
19
            if event.fd == listen_fd:
20
                # 新连接到达
21
                client_fd = accept(listen_fd)
22
                # 注册客户端 socket
23
                epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, EPOLLIN)
24

25
            else:
26
                # 客户端数据就绪
27
                command = read(event.fd)
28

29
                # 执行 Redis 命令（单线程执行）
30
                result = execute_command(command)
31

32
                # 写回响应
33
                write(event.fd, result)
34

35
        # 处理其他定时任务
36
        handle_expired_keys()  # 清理过期key
37
        handle_aof_rewrite()   # AOF重写

1
-- KEYS[1]: 库存key
2
-- ARGV[1]: 扣减数量
3

4
local stock_key = KEYS[1]
5
local quantity = tonumber(ARGV[1])
6

7
-- 获取当前库存
8
local stock = tonumber(redis.call('GET', stock_key) or '0')
9

10
-- 判断库存是否充足
11
if stock >= quantity then
12
    -- 扣减库存
13
    redis.call('DECRBY', stock_key, quantity)
14
    return stock - quantity  -- 返回剩余库存
15
else
16
    return -1  -- 库存不足
17
end

1
@Service
2
public class GoodsService {
3
    @Autowired
4
    private StringRedisTemplate redisTemplate;
5

6
    // Lua 脚本内容
7
    private static final String STOCK_DEDUCT_SCRIPT =
8
        "local stock_key = KEYS[1]\n" +
9
        "local quantity = tonumber(ARGV[1])\n" +
10
        "local stock = tonumber(redis.call('GET', stock_key) or '0')\n" +
11
        "if stock >= quantity then\n" +
12
        "    redis.call('DECRBY', stock_key, quantity)\n" +
13
        "    return stock - quantity\n" +
14
        "else\n" +
15
        "    return -1\n" +
16
        "end";
17

18
    public Result<Order> createOrder(Long goodsId, Integer quantity) {
19
        String stockKey = "goods:stock:" + goodsId;
20
         //创建 Spring Redis 的 Lua 脚本对象
21
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
22

23
        /Lua脚本放置的位置
24
        script.setScriptText(STOCK_DEDUCT_SCRIPT);
25
        script.setResultType(Long.class);
26
        // 执行 Lua 脚本
27
        Long remainStock = redisTemplate.execute(
28
            script,
29
            //Collections.singletonList 创建一个只包含一个元素的 List
30
            Collections.singletonList(stockKey),  // KEYS
31
            quantity.toString()                    // ARGV
32
        );
33

34
        if (remainStock < 0) {
35
            return Result.fail("库存不足");
36
        }
37

38
        // 创建订单
39
        Order order = createOrderRecord(goodsId, quantity);
40

41
        return Result.success(order);
42
    }
43
}

1
-- 滑动窗口限流
2
-- KEYS[1]: 限流key
3
-- ARGV[1]: 窗口大小（秒）
4
-- ARGV[2]: 最大请求数
5
-- ARGV[3]: 当前时间戳
6

7
local key = KEYS[1]
8
local window = tonumber(ARGV[1])
9
local max_requests = tonumber(ARGV[2])
10
local now = tonumber(ARGV[3])
11

12
//现在是第 20 秒，窗口是 10 秒，就删除时间不晚于第 10 秒的记录。剩下的就是最近 10 秒内的请求。
13
-- 移除窗口之外的请求
14
redis.call('ZREMRANGEBYSCORE', key, 0, now - window * 1000)
15

16
-- 统计窗口内的请求数
17
local current = redis.call('ZCARD', key)
18

19
if current < max_requests then
20
    -- 允许请求，记录时间戳
21
    redis.call('ZADD', key, now, now)
22
    redis.call('EXPIRE', key, window)
23
    --每次成功请求都会重新设置
24
    return 1  -- 允许通过
25
else
26
    return 0  -- 限流
27
end

1
@Component
2
public class RateLimiter {
3
    @Autowired
4
    private StringRedisTemplate redisTemplate;
5

6
    private static final String RATE_LIMIT_SCRIPT = "..."; // Lua脚本
7

8
    /**
9
     * 限流检查
10
     * @param key 限流key（如：rate:limit:user:1001）
11
     * @param window 时间窗口（秒）
12
     * @param maxRequests 最大请求数
13
     * @return true-允许，false-限流
14
     */
15
    public boolean tryAcquire(String key, int window, int maxRequests) {
16
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
17
        script.setScriptText(RATE_LIMIT_SCRIPT);
18
        script.setResultType(Long.class);
19

20
        Long result = redisTemplate.execute(
21
            script,
22
            Collections.singletonList(key),  KEYS[1]
23
            String.valueOf(window),     ARGV[1]: 窗口大小（秒）
24
            String.valueOf(maxRequests),   最大请求数
25
            String.valueOf(System.currentTimeMillis())  当前时间戳
26
        );
27

28
        return result != null && result == 1;
29
    }
30
}
31

32
// 使用示例
33
@RestController
34
public class ApiController {
35
    @Autowired
36
    private RateLimiter rateLimiter;
37

38
    @GetMapping("/api/data")
39
    public Result getData(@RequestHeader("userId") Long userId) {
40
        String limitKey = "rate:limit:user:" + userId;
41

42
        // 限流：10秒内最多100次请求
43
        if (!rateLimiter.tryAcquire(limitKey, 10, 100)) {
44
            return Result.fail("请求过于频繁，请稍后重试");
45
        }
46

47
        // 正常业务逻辑
48
        return Result.success(dataService.getData());
49
    }
50
}

1
@Configuration
2
public class LuaScriptConfig {
3
    @Bean
4
    public DefaultRedisScript<Long> stockDeductScript() {
5
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
6

7
        // 从文件加载脚本
8
        script.setLocation(new ClassPathResource("lua/stock_deduct.lua"));
9
        script.setResultType(Long.class);
10

11
        return script;
12
    }
13
}
14

15
@Service
16
public class GoodsService {
17
    @Autowired
18
    @Qualifier("stockDeductScript")
19
    private DefaultRedisScript<Long> stockDeductScript;
20

21
    public Result<Order> createOrder(Long goodsId, Integer quantity) {
22
        String stockKey = "goods:stock:" + goodsId;
23

24
        // 直接使用预加载的脚本
25
        Long remainStock = redisTemplate.execute(
26
            stockDeductScript,
27
            Collections.singletonList(stockKey),
28
            quantity.toString()
29
        );
30

31
        if (remainStock < 0) {
32
            return Result.fail("库存不足");
33
        }
34

35
        return Result.success(createOrderRecord(goodsId, quantity));
36
    }
37
}

1
@Service
2
public class DistributedLockService {
3
    @Autowired
4
    private StringRedisTemplate redisTemplate;
5

6
    /**
7
     * 尝试加锁
8
     * @param lockKey 锁的key
9
     * @param value 锁的值（通常用UUID，防止误删）
10
     * @param expireTime 过期时间（秒）
11
     * @return true-加锁成功，false-加锁失败
12
     */
13
    public boolean tryLock(String lockKey, String value, long expireTime) {
14
        Boolean result = redisTemplate.opsForValue()
15
                .setIfAbsent(lockKey, value, expireTime, TimeUnit.SECONDS);
16

17
        return Boolean.TRUE.equals(result);
18
    }
19

20
    /**
21
     * 释放锁
22
     */
23
    public void unlock(String lockKey, String value) {
24
        String currentValue = redisTemplate.opsForValue().get(lockKey);
25

26
        // 只能删除自己加的锁
27
        if (value.equals(currentValue)) {
28
            redisTemplate.delete(lockKey);
29
        }
30
    }
31
}
32

33
// 使用示例
34
public Result<Order> createOrder(Long goodsId) {
35
    String lockKey = "lock:order:" + goodsId;
36
    String lockValue = UUID.randomUUID().toString();
37

38
    // 尝试加锁，10秒过期
39
    boolean locked = lockService.tryLock(lockKey, lockValue, 10);
40

41
    if (!locked) {
42
        return Result.fail("系统繁忙，请稍后重试");
43
    }
44

45
    try {
46
        // 执行业务逻辑
47
        return orderService.create(goodsId);
48
    } finally {
49
        // 释放锁
50
        lockService.unlock(lockKey, lockValue);
51
    }
52
}

1
public class DistributedLockService {
2
    // Lua 脚本：先判断再删除
3
    private static final String UNLOCK_SCRIPT =
4
        "if redis.call('GET', KEYS[1]) == ARGV[1] then\n" +
5
        "    return redis.call('DEL', KEYS[1])\n" +
6
        "else\n" +
7
        "    return 0\n" +
8
        "end";
9

10
    public void unlock(String lockKey, String value) {
11
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
12
        script.setScriptText(UNLOCK_SCRIPT);
13
        script.setResultType(Long.class);
14

15
        redisTemplate.execute(
16
            script,
17
            Collections.singletonList(lockKey),
18
            value
19
        );
20
    }
21
}