Redis基础用法详解：数据类型、常用命令与Spring Boot实战

1
@Service
2
public class UserService {
3

4
    private final StringRedisTemplate redis;
5
    private final ObjectMapper objectMapper = new ObjectMapper();
6

7
    public UserService(StringRedisTemplate redis) {
8
        this.redis = redis;
9
    }
10

11
    /** 查询用户：先缓存后数据库 */
12
    public User getUser(Long id) {
13
        String key = "user:" + id;
14
        String json = redis.opsForValue().get(key);
15
        if (json != null) {
16
            // 缓存命中，反序列化返回
17
            try {
18
                return objectMapper.readValue(json, User.class);
19
            } catch (Exception e) {
20
                log.error("缓存反序列化失败", e);
21
            }
22
        }
23
        // 缓存未命中，查数据库
24
        User user = userMapper.selectById(id);
25
        if (user != null) {
26
            try {
27
                // 回写缓存，30 分钟过期
28
                redis.opsForValue().set(key,
29
                        objectMapper.writeValueAsString(user), 30, TimeUnit.MINUTES);
30
            } catch (Exception e) {
31
                log.error("缓存序列化失败", e);
32
            }
33
        }
34
        return user;
35
    }
36

37
    /** 更新用户：更新数据库 + 删除缓存（下次查询自动重建） */
38
    public void updateUser(User user) {
39
        userMapper.updateById(user);
40
        redis.delete("user:" + user.getId()); // 删缓存比更新缓存更简单可靠
41
    }
42
}

1
/** 文章浏览量 +1，返回最新值 */
2
public Long incrView(Long articleId) {
3
    String key = "view:article:" + articleId;
4
    return redis.opsForValue().increment(key);
5
}
6

7
/** 简单接口限流：同一个 key 每秒最多 10 次 */
8
public boolean tryAcquire(String clientIp) {
9
    String key = "rate:limit:" + clientIp;
10
    Long count = redis.opsForValue().increment(key);
11
    if (count == 1L) {
12
        // 第一次访问，设置 1 秒过期，实现"滑动窗口"近似效果
13
        redis.expire(key, 1, TimeUnit.SECONDS);
14
    }
15
    return count <= 10;
16
}

1
public class RedisLock {
2

3
    private final StringRedisTemplate redis;
4
    private final ThreadLocal<String> requestId = new ThreadLocal<>();
5

6
    public RedisLock(StringRedisTemplate redis) {
7
        this.redis = redis;
8
    }
9

10
    /**
11
     * 尝试加锁
12
     * @param key      锁的 key
13
     * @param expireMs 锁自动过期时间（毫秒），防止持有者宕机导致死锁
14
     */
15
    public boolean tryLock(String key, long expireMs) {
16
        String requestId = UUID.randomUUID().toString();
17
        Boolean ok = redis.opsForValue().setIfAbsent(key, requestId, expireMs, TimeUnit.MILLISECONDS);
18
        if (Boolean.TRUE.equals(ok)) {
19
            // 保存 requestId，释放锁时校验，防止误删别人的锁
20
            this.requestId.set(requestId);
21
            return true;
22
        }
23
        return false;
24
    }
25

26
    /** 释放锁：必须用 Lua 脚本保证"判断+删除"原子性 */
27
    public void unlock(String key) {
28
        String requestId = this.requestId.get();
29
        if (requestId == null) {
30
            return;
31
        }
32
        // Lua：只有 value 匹配才删除，避免锁过期后误删他人锁
33
        String script =
34
            "if redis.call('get', KEYS[1]) == ARGV[1] " +
35
            "then return redis.call('del', KEYS[1]) " +
36
            "else return 0 end";
37
        redis.execute(new DefaultRedisScript<>(script, Long.class),
38
                List.of(key), requestId);
39
    }
40
}

1
@Autowired
2
private RedisLock redisLock;
3

4
public void createOrder(Long userId, Long orderId) {
5
    String lockKey = "lock:order:" + userId;
6
    if (!redisLock.tryLock(lockKey, 10_000)) {
7
        throw new BizException("操作太频繁，请稍后再试");
8
    }
9
    try {
10
        // 业务：防止重复下单
11
        doCreateOrder(userId, orderId);
12
    } finally {
13
        redisLock.unlock(lockKey);
14
    }
15
}

1
/** 玩家分数 +5 */
2
public void addScore(String gameId, String userId, int score) {
3
    String key = "rank:game:" + gameId;
4
    redis.opsForZSet().incrementScore(key, userId, score);
5
}
6

7
/** 获取前 10 名（带分数） */
8
public List<RankItem> top10(String gameId) {
9
    String key = "rank:game:" + gameId;
10
    // 分数从高到低取前 10，value 是 userId，score 是分数
11
    Set<ZSetOperations.TypedTuple<String>> tuples =
12
            redis.opsForZSet().reverseRangeWithScores(key, 0, 9);
13
    List<RankItem> list = new ArrayList<>();
14
    if (tuples != null) {
15
        int rank = 1;
16
        for (ZSetOperations.TypedTuple<String> tuple : tuples) {
17
            list.add(new RankItem(rank++,
18
                    tuple.getValue(), tuple.getScore().longValue()));
19
        }
20
    }
21
    return list;
22
}
23

24
/** 查询某玩家排名（第几名，从 1 开始） */
25
public Long getRank(String gameId, String userId) {
26
    Long rank = redis.opsForZSet().reverseRank(keyOf(gameId), userId);
27
    return rank == null ? null : rank + 1;
28
}
29

30
private String keyOf(String gameId) {
31
    return "rank:game:" + gameId;
32
}

1
@Component
2
public class DelayQueue {
3

4
    private static final String QUEUE_KEY = "delay:queue:order";
5
    private final StringRedisTemplate redis;
6

7
    /** 延迟 30 分钟后执行：score = 当前时间 + 30 分钟 */
8
    public void addDelayTask(String orderId, long delayMs) {
9
        redis.opsForZSet().add(QUEUE_KEY, orderId,
10
                System.currentTimeMillis() + delayMs);
11
    }
12

13
    /** 拉取到期的任务（订单超时未支付则取消） */
14
    @Scheduled(fixedDelay = 1000)
15
    public void poll() {
16
        long now = System.currentTimeMillis();
17
        // 取出 score <= now 的所有元素（最多 100 个）
18
        Set<String> ready = redis.opsForZSet().rangeByScore(QUEUE_KEY, 0, now, 0, 100);
19
        if (ready == null || ready.isEmpty()) {
20
            return;
21
        }
22
        for (String orderId : ready) {
23
            // 从队列移除（Redis 没有原子"取走"命令，先移除再处理，防止重复）
24
            Long removed = redis.opsForZSet().remove(QUEUE_KEY, orderId);
25
            if (removed != null && removed > 0) {
26
                cancelExpiredOrder(orderId); // 业务处理
27
            }
28
        }
29
    }
30

31
    private void cancelExpiredOrder(String orderId) {
32
        // 检查订单状态，超时未支付则取消
33
        System.out.println("取消超时订单: " + orderId);
34
    }
35
}

1
/** 判断用户是否已点赞 + 点赞 */
2
public boolean like(Long userId, Long targetId) {
3
    String key = "like:target:" + targetId;
4
    Boolean added = redis.opsForSet().add(key, String.valueOf(userId));
5
    return Boolean.TRUE.equals(added); // 返回 false 说明之前已点赞
6
}
7

8
/** 点赞数 */
9
public Long likeCount(Long targetId) {
10
    return redis.opsForSet().size("like:target:" + targetId);
11
}
12

13
/** 判断是否已点赞（O(1)） */
14
public boolean hasLiked(Long userId, Long targetId) {
15
    return Boolean.TRUE.equals(
16
            redis.opsForSet().isMember("like:target:" + targetId,
17
                    String.valueOf(userId)));
18
}
19

20
/** 共同好友：交集 */
21
public Set<String> commonFollows(Long userId1, Long userId2) {
22
    return redis.opsForSet().intersect("follow:" + userId1, "follow:" + userId2);
23
}

1
/** 消息监听器 */
2
@Component
3
public class MessageListener implements MessageListener {
4
    @Override
5
    public void onMessage(Message message, byte[] pattern) {
6
        String channel = new String(message.getChannel());
7
        String body = new String(message.getBody());
8
        System.out.println("收到消息 channel=" + channel + ", body=" + body);
9
    }
10
}
11

12
@Configuration
13
public class RedisPubSubConfig {
14
    @Bean
15
    public RedisMessageListenerContainer container(RedisConnectionFactory factory,
16
                                                   MessageListener listener) {
17
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
18
        container.setConnectionFactory(factory);
19
        // 订阅频道 news:notify
20
        container.addMessageListener(listener, new ChannelTopic("news:notify"));
21
        return container;
22
    }
23
}
24

25
/** 发布消息 */
26
@RestController
27
public class NotifyController {
28
    private final StringRedisTemplate redis;
29

30
    @PostMapping("/notify")
31
    public void notify(@RequestBody String content) {
32
        // 发布到频道，所有订阅者都能收到
33
        redis.convertAndSend("news:notify", content);
34
    }
35
}

1
@Service
2
public class DriverService {
3

4
    private static final String KEY = "geo:drivers:city";
5
    private final StringRedisTemplate redis;
6

7
    /** 司机上报位置（经度 lng、纬度 lat） */
8
    public void uploadLocation(String driverId, double lng, double lat) {
9
        redis.opsForGeo().add(KEY, new Point(lng, lat), driverId);
10
    }
11

12
    /** 查找附近司机：以用户为中心 radiusKm 公里内，按距离从近到远 */
13
    public List<NearDriver> nearbyDrivers(double lng, double lat, double radiusKm) {
14
        Circle circle = new Circle(new Point(lng, lat), new Distance(radiusKm, Metrics.KILOMETERS));
15
        GeoResults<RedisGeoCommands.GeoLocation<String>> results =
16
                redis.opsForGeo().radius(KEY, circle,
17
                        RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
18
                                .includeDistance()   // 结果带距离
19
                                .sortAscending());   // 按距离升序
20
        List<NearDriver> list = new ArrayList<>();
21
        if (results != null) {
22
            for (GeoResult<RedisGeoCommands.GeoLocation<String>> result : results) {
23
                String driverId = result.getContent().getName();
24
                double distKm = result.getDistance() == null
25
                        ? 0 : result.getDistance().getValue();
26
                list.add(new NearDriver(driverId, distKm));
27
            }
28
        }
29
        return list;
30
    }
31

32
    /** 计算两个司机之间的直线距离（单位 km） */
33
    public Double distance(String driverId1, String driverId2) {
34
        Distance d = redis.opsForGeo().distance(KEY, driverId1, driverId2, Metrics.KILOMETERS);
35
        return d == null ? null : d.getValue();
36
    }
37
}

1
@Service
2
public class SignService {
3

4
    private final StringRedisTemplate redis;
5

6
    /** 用户签到：偏移量直接用用户 id */
7
    public boolean signIn(Long userId) {
8
        String key = "sign:" + LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
9
        return Boolean.TRUE.equals(redis.opsForValue().setBit(key, userId, true));
10
    }
11

12
    /** 查询今天是否已签到 */
13
    public boolean hasSigned(Long userId) {
14
        String key = "sign:" + LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
15
        return Boolean.TRUE.equals(redis.opsForValue().getBit(key, userId));
16
    }
17

18
    /** 今天签到的总人数 */
19
    public Long todaySignCount() {
20
        String key = "sign:" + LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
21
        return redis.execute((RedisCallback<Long>) connection ->
22
                connection.stringCommands()
23
                        .bitCount(key.getBytes(StandardCharsets.UTF_8)));
24
    }
25
}