Columbina

Redis 实战笔记：短信登录、缓存、秒杀、分布式锁与社交功能

Tue, 12 Aug 2025 00:00:00 GMT

Redis 实战笔记：短信登录、缓存、秒杀、分布式锁与社交功能#

阅读提示

本文是 Redis 实战项目「黑马点评」的学习笔记，内容覆盖： 短信登录 → 商户缓存 → 优惠券秒杀 → 分布式锁 → 异步秒杀 → 达人探店 → 好友关注 → 附近商户 → 签到统计 → UV 统计。建议先掌握 Redis 五大数据结构、SpringDataRedis 基本用法，再阅读本文。

内容概述#

本项目围绕一个本地生活服务平台展开，主要使用 Redis 解决以下业务问题：

模块	Redis 技术点
短信登录	Redis 共享 Session、Token
商户查询缓存	缓存穿透、缓存雪崩、缓存击穿
优惠券秒杀	计数器、Lua 脚本、分布式锁、消息队列
附近的商户	Redis GEO
UV 统计	HyperLogLog
用户签到	BitMap
好友关注	Set 集合交并差
达人探店	List、SortedSet

一、短信登录#

1.1 导入项目#

项目采用前后端分离模式，整体请求链路如下：

1
手机/App → Nginx → Tomcat → MySQL / Redis

Nginx 可以作为静态资源服务器、反向代理和负载均衡器；Tomcat 负责业务逻辑；MySQL 存储核心数据；Redis 提供高性能缓存与共享数据。

项目中涉及的主要数据表：

表	说明
`tb_user`	用户表
`tb_user_info`	用户详情表
`tb_shop`	商户信息表
`tb_shop_type`	商户类型表
`tb_blog`	用户日记表（达人探店日记）
`tb_follow`	用户关注表
`tb_voucher`	优惠券表
`tb_voucher_order`	优惠券订单表

导入后端项目后，修改 MySQL 和 Redis 连接信息并启动。访问：

1
http://localhost:8081/shop-type/list

如果能看到 JSON 数据，说明后端导入成功。

前端项目解压后，在 Nginx 目录执行：

Terminal window

1
start nginx.exe

访问：

1
http://localhost:8080/

1.2 基于 Session 实现登录流程#

发送验证码#

用户提交手机号/邮箱。
后端校验格式是否合法。
合法则生成验证码并保存。
通过短信或邮件发送验证码。

登录/注册#

用户输入账号和验证码。
后端从 Session 中取出验证码进行校验。
校验通过后根据账号查询用户。
用户不存在则创建用户。
将用户信息保存到 Session。

校验登录状态#

用户请求时携带 Cookie 中的 JsessionId。
后端通过 JsessionId 从 Session 中获取用户信息。
没有用户信息则拦截。
有用户信息则保存到 ThreadLocal 并放行。

1.3 发送邮箱验证码#

黑马点评默认使用短信验证码，但为了实际部署方便，可以改为邮箱验证码。需要导入依赖：

1
<dependency>
2
    <groupId>javax.activation</groupId>
3
    <artifactId>activation</artifactId>
4
    <version>1.1.1</version>
5
</dependency>
6
<dependency>
7
    <groupId>javax.mail</groupId>
8
    <artifactId>mail</artifactId>
9
    <version>1.4.7</version>
10
</dependency>
11
<dependency>
12
    <groupId>org.apache.commons</groupId>
13
    <artifactId>commons-email</artifactId>
14
    <version>1.4</version>
15
</dependency>

展开收起

邮件工具类核心逻辑：

1
public class MailUtils {
2

3
    public static void sendTestMail(String email, String code) throws MessagingException {
4
        Properties props = new Properties();
5
        props.put("mail.smtp.auth", "true");
6
        props.put("mail.smtp.host", "smtp.qq.com");
7
        props.put("mail.smtp.port", "587");
8
        props.put("mail.user", "你的邮箱@qq.com");
9
        props.put("mail.password", "你的SMTP授权码");
10

11
        Authenticator authenticator = new Authenticator() {
12
            @Override
13
            protected PasswordAuthentication getPasswordAuthentication() {
14
                String userName = props.getProperty("mail.user");
15
                String password = props.getProperty("mail.password");
16
                return new PasswordAuthentication(userName, password);
17
            }
18
        };
19

20
        Session mailSession = Session.getInstance(props, authenticator);
21
        MimeMessage message = new MimeMessage(mailSession);
22
        message.setFrom(new InternetAddress(props.getProperty("mail.user")));
23
        message.setRecipient(Message.RecipientType.TO, new InternetAddress(email));
24
        message.setSubject("登录验证码");
25
        message.setContent("验证码为：" + code + "（有效期一分钟）", "text/html;charset=UTF-8");
26
        Transport.send(message);
27
    }
28

29
    public static String achieveCode() {
30
        String[] beforeShuffle = new String[]{
31
                "2", "3", "4", "5", "6", "7", "8", "9",
32
                "A", "B", "C", "D", "E", "F", "G", "H",
33
                "I", "J", "K", "L", "M", "N", "O", "P",
34
                "Q", "R", "S", "T", "U", "V", "W", "X",
35
                "Y", "Z", "a", "b", "c", "d", "e", "f",
36
                "g", "h", "i", "j", "k", "l", "m", "n",
37
                "o", "p", "q", "r", "s", "t", "u", "v",
38
                "w", "x", "y", "z"
39
        };
40
        List<String> list = Arrays.asList(beforeShuffle);
41
        Collections.shuffle(list);
42
        StringBuilder sb = new StringBuilder();
43
        for (String s : list) {
44
            sb.append(s);
45
        }
46
        return sb.substring(3, 8);
47
    }
48
}

展开收起

修改 sendCode 方法：

1
@PostMapping("/code")
2
public Result sendCode(@RequestParam("phone") String phone, HttpSession session) throws MessagingException {
3
    if (RegexUtils.isEmailInvalid(phone)) {
4
        return Result.fail("邮箱格式不正确");
5
    }
6
    String code = MailUtils.achieveCode();
7
    session.setAttribute(phone, code);
8
    log.info("发送登录验证码：{}", code);
9
    MailUtils.sendTestMail(phone, code);
10
    return Result.ok();
11
}

修改 login 方法：

1
@PostMapping("/login")
2
public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session) {
3
    String phone = loginForm.getPhone();
4
    String code = loginForm.getCode();
5
    Object cacheCode = session.getAttribute(phone);
6

7
    if (RegexUtils.isEmailInvalid(phone)) {
8
        return Result.fail("邮箱格式不正确！！");
9
    }
10

11
    if (code == null || cacheCode == null || !cacheCode.toString().equals(code)) {
12
        return Result.fail("验证码不一致！！");
13
    }
14

15
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
16
    queryWrapper.eq(User::getPhone, phone);
17
    User user = userService.getOne(queryWrapper);
18

19
    if (user == null) {
20
        user = createUserWithPhone(phone);
21
    }
22

23
    session.setAttribute("user", user);
24
    return Result.ok();
25
}

展开收起

1.4 登录拦截与隐藏敏感信息#

创建 LoginInterceptor：

1
public class LoginInterceptor implements HandlerInterceptor {
2

3
    @Override
4
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
5
        HttpSession session = request.getSession();
6
        User user = (User) session.getAttribute("user");
7
        if (user == null) {
8
            response.setStatus(401);
9
            return false;
10
        }
11
        UserHolder.saveUser(user);
12
        return true;
13
    }
14

15
    @Override
16
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
17
        UserHolder.removeUser();
18
    }
19
}

展开收起

为了避免返回用户密码等敏感信息，创建 UserDTO：

1
@Data
2
public class UserDTO {
3
    private Long id;
4
    private String nickName;
5
    private String icon;
6
}

修改登录逻辑，将 User 转为 UserDTO：

1
UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
2
session.setAttribute("user", userDTO);

修改拦截器：

1
UserDTO user = (UserDTO) session.getAttribute("user");

1.5 Session 共享问题#

每个 Tomcat 都有自己独立的 Session。如果用户第一次访问 Tomcat1，第二次被负载均衡到 Tomcat2，Tomcat2 上没有 Session，就会导致登录状态失效。

早期解决方案是 Session 拷贝，但存在两个问题：

每台服务器都有完整 Session 数据，服务器压力大。
Session 拷贝可能存在延迟。

因此，使用 Redis 替代 Session。Redis 数据本身是共享的。

1.6 基于 Redis 实现短信登录#

设计 Key 时需要注意：

Key 要有唯一性。
Key 要方便携带。
不要直接使用手机号等敏感信息作为 Key。

整体流程：

用户提交账号和验证码。
校验验证码。
根据账号查询用户，不存在则创建。
生成随机 Token。
将用户信息以 Hash 结构存入 Redis。
返回 Token 给前端。
后续请求携带 Token，从 Redis 获取用户信息。

修改 sendCode：

1
@PostMapping("/code")
2
public Result sendCode(@RequestParam("phone") String phone) throws MessagingException {
3
    if (RegexUtils.isEmailInvalid(phone)) {
4
        return Result.fail("邮箱格式不正确");
5
    }
6
    String code = MailUtils.achieveCode();
7
    stringRedisTemplate.opsForValue().set(
8
            LOGIN_CODE_KEY + phone,
9
            code,
10
            LOGIN_CODE_TTL,
11
            TimeUnit.MINUTES
12
    );
13
    log.info("发送登录验证码：{}", code);
14
    return Result.ok();
15
}

展开收起

修改 login：

1
@PostMapping("/login")
2
public Result login(@RequestBody LoginFormDTO loginForm) {
3
    String phone = loginForm.getPhone();
4
    String code = loginForm.getCode();
5

6
    String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
7

8
    if (RegexUtils.isEmailInvalid(phone)) {
9
        return Result.fail("邮箱格式不正确！！");
10
    }
11

12
    if (code == null || cacheCode == null || !cacheCode.equals(code)) {
13
        return Result.fail("验证码不一致！！");
14
    }
15

16
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
17
    queryWrapper.eq(User::getPhone, phone);
18
    User user = userService.getOne(queryWrapper);
19

20
    if (user == null) {
21
        user = createUserWithPhone(phone);
22
    }
23

24
    String token = UUID.randomUUID().toString();
25
    UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
26

27
    Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
28
            CopyOptions.create()
29
                    .setIgnoreNullValue(true)
30
                    .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
31

32
    String tokenKey = LOGIN_USER_KEY + token;
33
    stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
34
    stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);
35
    stringRedisTemplate.delete(LOGIN_CODE_KEY + phone);
36

37
    return Result.ok(token);
38
}

展开收起

1.7 登录状态刷新#

如果只在需要拦截的路径上刷新 Token TTL，那么用户访问不需要拦截的路径时，Token 不会续期。因此需要两个拦截器：

RefreshTokenInterceptor：拦截所有路径，刷新 Token TTL。
LoginInterceptor：只负责判断用户是否登录。

RefreshTokenInterceptor：

1
public class RefreshTokenInterceptor implements HandlerInterceptor {
2

3
    private final StringRedisTemplate stringRedisTemplate;
4

5
    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
6
        this.stringRedisTemplate = stringRedisTemplate;
7
    }
8

9
    @Override
10
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
11
        String token = request.getHeader("authorization");
12
        if (StrUtil.isBlank(token)) {
13
            return true;
14
        }
15

16
        String key = RedisConstants.LOGIN_USER_KEY + token;
17
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
18
        if (userMap.isEmpty()) {
19
            return true;
20
        }
21

22
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
23
        UserHolder.saveUser(userDTO);
24
        stringRedisTemplate.expire(key, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
25
        return true;
26
    }
27

28
    @Override
29
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
30
        UserHolder.removeUser();
31
    }
32
}

展开收起

LoginInterceptor：

1
public class LoginInterceptor implements HandlerInterceptor {
2

3
    @Override
4
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
5
        if (UserHolder.getUser() == null) {
6
            response.setStatus(401);
7
            return false;
8
        }
9
        return true;
10
    }
11

12
    @Override
13
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
14
        UserHolder.removeUser();
15
    }
16
}

展开收起

配置类：

1
@Configuration
2
public class MvcConfig implements WebMvcConfigurer {
3

4
    @Autowired
5
    private StringRedisTemplate stringRedisTemplate;
6

7
    @Override
8
    public void addInterceptors(InterceptorRegistry registry) {
9
        registry.addInterceptor(new LoginInterceptor())
10
                .excludePathPatterns(
11
                        "/user/code",
12
                        "/user/login",
13
                        "/blog/hot",
14
                        "/shop/**",
15
                        "/shop-type/**",
16
                        "/upload/**",
17
                        "/voucher/**"
18
                ).order(1);
19

20
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).order(0);
21
    }
22
}

展开收起

二、商户查询缓存#

2.1 什么是缓存#

缓存是数据交换的缓冲区，通常用于降低数据库访问压力、提高读写效率、降低响应时间。

缓存的作用：

降低后端负载。
提高读写效率，降低响应时间。

缓存的成本：

数据一致性成本。
代码维护成本。
运维成本。

2.2 添加商户缓存#

查询商户时，先从 Redis 查询，未命中再查数据库，并将结果写入 Redis。

1
@GetMapping("/{id}")
2
public Result queryShopById(@PathVariable("id") Long id) {
3
    return shopService.queryById(id);
4
}

Service 实现：

1
@Override
2
public Result queryById(Long id) {
3
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
4

5
    if (StrUtil.isNotBlank(shopJson)) {
6
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
7
        return Result.ok(shop);
8
    }
9

10
    Shop shop = getById(id);
11
    if (shop == null) {
12
        return Result.fail("店铺不存在！！");
13
    }
14

15
    String jsonStr = JSONUtil.toJsonStr(shop);
16
    stringRedisTemplate.opsForValue().set(
17
            CACHE_SHOP_KEY + id,
18
            jsonStr,
19
            CACHE_SHOP_TTL,
20
            TimeUnit.MINUTES
21
    );
22

23
    return Result.ok(shop);
24
}

展开收起

2.3 缓存更新策略#

策略	说明	一致性	维护成本
内存淘汰	Redis 内存不足时自动淘汰	差	无
超时剔除	设置 TTL，到期删除	一般	低
主动更新	修改数据库时更新或删除缓存	好	高

业务建议：

低一致性需求：使用内存淘汰或超时剔除。
高一致性需求：主动更新，并以超时剔除兜底。

2.4 数据库与缓存一致性#

常见方案：

Cache Aside Pattern：人工编码，更新数据库后删除缓存。
Read/Write Through Pattern：缓存与数据库整合为一个服务。
Write Behind Caching Pattern：只操作缓存，异步写数据库。

实际项目中推荐 Cache Aside Pattern：先操作数据库，再删除缓存。

实现商户缓存双写一致：

1
@PutMapping
2
public Result updateShop(@RequestBody Shop shop) {
3
    return shopService.update(shop);
4
}

Service：

1
@Override
2
@Transactional
3
public Result update(Shop shop) {
4
    Long id = shop.getId();
5
    if (id == null) {
6
        return Result.fail("店铺id不能为空");
7
    }
8
    updateById(shop);
9
    stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
10
    return Result.ok();
11
}

2.5 缓存穿透#

缓存穿透：请求的数据在缓存和数据库中都不存在，请求会频繁打到数据库。

解决方案：

缓存空对象。
布隆过滤。
增强 id 复杂度。
做好数据格式校验。
加强用户权限校验。
热点参数限流。

缓存空对象实现：

1
@Override
2
public Result queryById(Long id) {
3
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
4

5
    if (StrUtil.isNotBlank(shopJson)) {
6
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
7
        return Result.ok(shop);
8
    }
9

10
    if (shopJson != null) {
11
        return Result.fail("店铺不存在！！");
12
    }
13

14
    Shop shop = getById(id);
15

16
    if (shop == null) {
17
        stringRedisTemplate.opsForValue().set(
18
                CACHE_SHOP_KEY + id,
19
                "",
20
                CACHE_NULL_TTL,
21
                TimeUnit.MINUTES
22
        );
23
        return Result.fail("店铺不存在！！");
24
    }
25

26
    String jsonStr = JSONUtil.toJsonStr(shop);
27
    stringRedisTemplate.opsForValue().set(
28
            CACHE_SHOP_KEY + id,
29
            jsonStr,
30
            CACHE_SHOP_TTL,
31
            TimeUnit.MINUTES
32
    );
33

34
    return Result.ok(shop);
35
}

展开收起

2.6 缓存雪崩#

缓存雪崩：同一时间段大量缓存 Key 同时失效，或 Redis 服务宕机，导致大量请求到达数据库。

解决方案：

给不同 Key 的 TTL 添加随机值。
利用 Redis 集群提高可用性。
给缓存业务添加降级限流策略。
给业务添加多级缓存。

2.7 缓存击穿#

缓存击穿：高并发访问且缓存重建业务复杂的 Key 突然失效，大量请求瞬间打到数据库。

解决方案：

方案	优点	缺点
互斥锁	没有额外内存消耗、保证一致性、实现简单	线程需要等待、性能受影响、可能死锁
逻辑过期	线程无需等待、性能较好	不保证一致性、有额外内存消耗、实现复杂

互斥锁解决缓存击穿#

1
private boolean tryLock(String key) {
2
    Boolean flag = stringRedisTemplate.opsForValue()
3
            .setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
4
    return BooleanUtil.isTrue(flag);
5
}
6

7
private void unlock(String key) {
8
    stringRedisTemplate.delete(key);
9
}

查询逻辑：

1
@Override
2
public Shop queryWithMutex(Long id) {
3
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
4

5
    if (StrUtil.isNotBlank(shopJson)) {
6
        return JSONUtil.toBean(shopJson, Shop.class);
7
    }
8

9
    if (shopJson != null) {
10
        return null;
11
    }
12

13
    String lockKey = LOCK_SHOP_KEY + id;
14
    Shop shop = null;
15

16
    try {
17
        boolean flag = tryLock(lockKey);
18
        if (!flag) {
19
            Thread.sleep(50);
20
            return queryWithMutex(id);
21
        }
22

23
        shop = getById(id);
24

25
        if (shop == null) {
26
            stringRedisTemplate.opsForValue().set(
27
                    CACHE_SHOP_KEY + id,
28
                    "",
29
                    CACHE_NULL_TTL,
30
                    TimeUnit.MINUTES
31
            );
32
            return null;
33
        }
34

35
        String jsonStr = JSONUtil.toJsonStr(shop);
36
        stringRedisTemplate.opsForValue().set(
37
                CACHE_SHOP_KEY + id,
38
                jsonStr,
39
                CACHE_SHOP_TTL,
40
                TimeUnit.MINUTES
41
        );
42
    } catch (InterruptedException e) {
43
        throw new RuntimeException(e);
44
    } finally {
45
        unlock(lockKey);
46
    }
47

48
    return shop;
49
}

展开收起

逻辑过期解决缓存击穿#

封装逻辑过期数据：

1
@Data
2
public class RedisData<T> {
3
    private LocalDateTime expireTime;
4
    private T data;
5
}

写入逻辑过期数据：

1
public void saveShop2Redis(Long id, Long expireSeconds) {
2
    Shop shop = getById(id);
3
    RedisData<Shop> redisData = new RedisData<>();
4
    redisData.setData(shop);
5
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
6
    stringRedisTemplate.opsForValue().set(
7
            CACHE_SHOP_KEY + id,
8
            JSONUtil.toJsonStr(redisData)
9
    );
10
}

查询逻辑：

1
private static final ExecutorService CACHE_REBUILD_EXECUTOR =
2
        Executors.newFixedThreadPool(10);
3

4
@Override
5
public Shop queryWithLogicalExpire(Long id) {
6
    String json = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
7

8
    if (StrUtil.isBlank(json)) {
9
        return null;
10
    }
11

12
    RedisData redisData = JSONUtil.toBean(json, RedisData.class);
13
    JSONObject shopJson = (JSONObject) redisData.getData();
14
    Shop shop = JSONUtil.toBean(shopJson, Shop.class);
15
    LocalDateTime expireTime = redisData.getExpireTime();
16

17
    if (expireTime.isAfter(LocalDateTime.now())) {
18
        return shop;
19
    }
20

21
    String lockKey = LOCK_SHOP_KEY + id;
22
    boolean flag = tryLock(lockKey);
23

24
    if (flag) {
25
        CACHE_REBUILD_EXECUTOR.submit(() -> {
26
            try {
27
                saveShop2Redis(id, 20L);
28
            } catch (Exception e) {
29
                throw new RuntimeException(e);
30
            } finally {
31
                unlock(lockKey);
32
            }
33
        });
34
    }
35

36
    return shop;
37
}

展开收起

2.8 封装缓存工具类#

创建 CacheClient：

1
@Slf4j
2
@Component
3
public class CacheClient {
4

5
    private final StringRedisTemplate stringRedisTemplate;
6
    private static final ExecutorService CACHE_REBUILD_EXECUTOR =
7
            Executors.newFixedThreadPool(10);
8

9
    public CacheClient(StringRedisTemplate stringRedisTemplate) {
10
        this.stringRedisTemplate = stringRedisTemplate;
11
    }
12

13
    public void set(String key, Object value, Long time, TimeUnit timeUnit) {
14
        stringRedisTemplate.opsForValue().set(
15
                key,
16
                JSONUtil.toJsonStr(value),
17
                time,
18
                timeUnit
19
        );
20
    }
21

22
    public void setWithLogicExpire(String key, Object value, Long time, TimeUnit timeUnit) {
23
        RedisData<Object> redisData = new RedisData<>();
24
        redisData.setData(value);
25
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
26
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
27
    }
28

29
    public <R, ID> R queryWithPassThrough(
30
            String keyPrefix,
31
            ID id,
32
            Class<R> type,
33
            Function<ID, R> dbFallback,
34
            Long time,
35
            TimeUnit timeUnit
36
    ) {
37
        String key = keyPrefix + id;
38
        String json = stringRedisTemplate.opsForValue().get(key);
39

40
        if (StrUtil.isNotBlank(json)) {
41
            return JSONUtil.toBean(json, type);
42
        }
43

44
        if (json != null) {
45
            return null;
46
        }
47

48
        R r = dbFallback.apply(id);
49

50
        if (r == null) {
51
            stringRedisTemplate.opsForValue().set(
52
                    key,
53
                    "",
54
                    CACHE_NULL_TTL,
55
                    TimeUnit.MINUTES
56
            );
57
            return null;
58
        }
59

60
        this.set(key, r, time, timeUnit);
61
        return r;
62
    }
63

64
    public <R, ID> R queryWithMutex(
65
            String keyPrefix,
66
            ID id,
67
            Class<R> type,
68
            Function<ID, R> dbFallback,
69
            Long time,
70
            TimeUnit timeUnit
71
    ) {
72
        String key = keyPrefix + id;
73
        String json = stringRedisTemplate.opsForValue().get(key);
74

75
        if (StrUtil.isNotBlank(json)) {
76
            return JSONUtil.toBean(json, type);
77
        }
78

79
        if (json != null) {
80
            return null;
81
        }
82

83
        R r = null;
84
        String lockKey = LOCK_SHOP_KEY + id;
85

86
        try {
87
            boolean flag = tryLock(lockKey);
88
            if (!flag) {
89
                Thread.sleep(50);
90
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, timeUnit);
91
            }
92

93
            r = dbFallback.apply(id);
94

95
            if (r == null) {
96
                stringRedisTemplate.opsForValue().set(
97
                        key,
98
                        "",
99
                        CACHE_NULL_TTL,
100
                        TimeUnit.MINUTES
101
                );
102
                return null;
103
            }
104

105
            this.set(key, r, time, timeUnit);
106
        } catch (InterruptedException e) {
107
            throw new RuntimeException(e);
108
        } finally {
109
            unlock(lockKey);
110
        }
111

112
        return r;
113
    }
114

115
    public <R, ID> R queryWithLogicalExpire(
116
            String keyPrefix,
117
            ID id,
118
            Class<R> type,
119
            Function<ID, R> dbFallback,
120
            Long time,
121
            TimeUnit timeUnit
122
    ) {
123
        String key = keyPrefix + id;
124
        String json = stringRedisTemplate.opsForValue().get(key);
125

126
        if (StrUtil.isBlank(json)) {
127
            return null;
128
        }
129

130
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
131
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
132
        LocalDateTime expireTime = redisData.getExpireTime();
133

134
        if (expireTime.isAfter(LocalDateTime.now())) {
135
            return r;
136
        }
137

138
        String lockKey = LOCK_SHOP_KEY + id;
139
        boolean flag = tryLock(lockKey);
140

141
        if (flag) {
142
            CACHE_REBUILD_EXECUTOR.submit(() -> {
143
                try {
144
                    R tmp = dbFallback.apply(id);
145
                    this.setWithLogicExpire(key, tmp, time, timeUnit);
146
                } catch (Exception e) {
147
                    throw new RuntimeException(e);
148
                } finally {
149
                    unlock(lockKey);
150
                }
151
            });
152
        }
153

154
        return r;
155
    }
156

157
    private boolean tryLock(String key) {
158
        Boolean flag = stringRedisTemplate.opsForValue()
159
                .setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
160
        return BooleanUtil.isTrue(flag);
161
    }
162

163
    private void unlock(String key) {
164
        stringRedisTemplate.delete(key);
165
    }
166
}

展开收起

三、优惠券秒杀#

3.1 Redis 实现全局唯一 ID#

数据库自增 ID 存在两个问题：

ID 规律太明显，容易泄露业务信息。
单表数据量受限，分库分表后 ID 不能重复。

全局 ID 生成器需要满足：

唯一性
高可用
高性能
递增性
安全性

ID 结构：

部分	位数	说明
符号位	1 bit	永远为 0
时间戳	31 bit	以秒为单位，可用约 69 年
序列号	32 bit	秒内计数器

实现：

1
@Component
2
public class RedisIdWorker {
3

4
    @Autowired
5
    private StringRedisTemplate stringRedisTemplate;
6

7
    public static final Long BEGIN_TIMESTAMP = 1640995200L;
8
    public static final Long COUNT_BIT = 32L;
9

10
    public long nextId(String keyPrefix) {
11
        LocalDateTime now = LocalDateTime.now();
12
        long currentSecond = now.toEpochSecond(ZoneOffset.UTC);
13
        long timeStamp = currentSecond - BEGIN_TIMESTAMP;
14

15
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
16
        long count = stringRedisTemplate.opsForValue()
17
                .increment("inc:" + keyPrefix + ":" + date);
18

19
        return timeStamp << COUNT_BIT | count;
20
    }
21
}

展开收起

3.2 添加优惠券#

优惠券分为平价券和特价券。特价券需要记录库存、开始时间、结束时间。

新增秒杀券：

1
@PostMapping("/seckill")
2
public Result addSeckillVoucher(@RequestBody Voucher voucher) {
3
    voucherService.addSeckillVoucher(voucher);
4
    return Result.ok(voucher.getId());
5
}

Service：

1
@Override
2
@Transactional
3
public void addSeckillVoucher(Voucher voucher) {
4
    save(voucher);
5

6
    SeckillVoucher seckillVoucher = new SeckillVoucher();
7
    seckillVoucher.setVoucherId(voucher.getId());
8
    seckillVoucher.setStock(voucher.getStock());
9
    seckillVoucher.setBeginTime(voucher.getBeginTime());
10
    seckillVoucher.setEndTime(voucher.getEndTime());
11
    seckillVoucherService.save(seckillVoucher);
12

13
    stringRedisTemplate.opsForValue().set(
14
            SECKILL_STOCK_KEY + voucher.getId(),
15
            voucher.getStock().toString()
16
    );
17
}

展开收起

3.3 实现秒杀下单#

基础流程：

查询优惠券。
判断秒杀是否开始。
判断秒杀是否结束。
判断库存是否充足。
扣减库存。
创建订单。
返回订单 ID。

基础代码：

1
@Override
2
public Result seckillVoucher(Long voucherId) {
3
    LambdaQueryWrapper<SeckillVoucher> queryWrapper = new LambdaQueryWrapper<>();
4
    queryWrapper.eq(SeckillVoucher::getVoucherId, voucherId);
5
    SeckillVoucher seckillVoucher = seckillVoucherService.getOne(queryWrapper);
6

7
    if (LocalDateTime.now().isBefore(seckillVoucher.getBeginTime())) {
8
        return Result.fail("秒杀还未开始，请耐心等待");
9
    }
10

11
    if (LocalDateTime.now().isAfter(seckillVoucher.getEndTime())) {
12
        return Result.fail("秒杀已经结束！");
13
    }
14

15
    if (seckillVoucher.getStock() < 1) {
16
        return Result.fail("优惠券已被抢光了哦");
17
    }
18

19
    boolean success = seckillVoucherService.update()
20
            .setSql("stock = stock - 1")
21
            .eq("voucher_id", voucherId)
22
            .gt("stock", 0)
23
            .update();
24

25
    if (!success) {
26
        return Result.fail("库存不足");
27
    }
28

29
    VoucherOrder voucherOrder = new VoucherOrder();
30
    long orderId = redisIdWorker.nextId("order");
31
    Long userId = UserHolder.getUser().getId();
32

33
    voucherOrder.setId(orderId);
34
    voucherOrder.setUserId(userId);
35
    voucherOrder.setVoucherId(voucherId);
36

37
    save(voucherOrder);
38

39
    return Result.ok(orderId);
40
}

展开收起

3.4 超卖问题#

超卖问题属于多线程安全问题。常见解决方案：

悲观锁：认为线程安全问题一定会发生，操作前加锁。
乐观锁：认为线程安全问题不一定发生，更新时判断数据是否被修改。

本项目可以使用库存作为版本号：

1
boolean success = seckillVoucherService.update()
2
        .setSql("stock = stock - 1")
3
        .eq("voucher_id", voucherId)
4
        .gt("stock", 0)
5
        .update();

只要库存大于 0，就允许扣减，可以避免大量失败。

3.5 一人一单#

需求：同一个优惠券，一个用户只能抢一张。

初步实现：

1
Long userId = UserHolder.getUser().getId();
2
int count = query()
3
        .eq("voucher_id", voucherId)
4
        .eq("user_id", userId)
5
        .count();
6

7
if (count > 0) {
8
    return Result.fail("你已经抢过优惠券了哦");
9
}

由于并发情况下仍然可能重复下单，需要使用锁。

将一人一单逻辑抽取为 createVoucherOrder：

1
@Transactional
2
public Result createVoucherOrder(Long voucherId) {
3
    Long userId = UserHolder.getUser().getId();
4

5
    synchronized (userId.toString().intern()) {
6
        int count = query()
7
                .eq("voucher_id", voucherId)
8
                .eq("user_id", userId)
9
                .count();
10

11
        if (count > 0) {
12
            return Result.fail("你已经抢过优惠券了哦");
13
        }
14

15
        boolean success = seckillVoucherService.update()
16
                .setSql("stock = stock - 1")
17
                .eq("voucher_id", voucherId)
18
                .gt("stock", 0)
19
                .update();
20

21
        if (!success) {
22
            return Result.fail("库存不足");
23
        }
24

25
        VoucherOrder voucherOrder = new VoucherOrder();
26
        long orderId = redisIdWorker.nextId("order");
27

28
        voucherOrder.setId(orderId);
29
        voucherOrder.setUserId(userId);
30
        voucherOrder.setVoucherId(voucherId);
31

32
        save(voucherOrder);
33

34
        return Result.ok(orderId);
35
    }
36
}

展开收起

调用时需要通过代理对象调用，确保事务生效：

1
Long userId = UserHolder.getUser().getId();
2

3
synchronized (userId.toString().intern()) {
4
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
5
    return proxy.createVoucherOrder(voucherId);
6
}

启动类开启：

1
@EnableAspectJAutoProxy(exposeProxy = true)

3.6 集群环境下的并发问题#

单机 synchronized 只能锁住当前 JVM。集群部署时，不同 Tomcat 有不同 JVM，锁对象不是同一个，因此会失效。

解决方案：使用分布式锁。

四、分布式锁#

4.1 分布式锁基本要求#

可见性：多个线程都能看到相同结果。
互斥：程序串行执行。
高可用：程序不易崩溃。
高性能：加锁和释放锁性能要好。
安全性：异常时能自动释放锁。

常见实现：

方案	互斥	高可用	高性能	安全性
MySQL	数据库锁	好	一般	断开连接自动释放
Redis	`SETNX`	好	好	超时释放
Zookeeper	节点唯一性	好	一般	临时节点自动释放

4.2 Redis 分布式锁核心思路#

获取锁：

Terminal window

1
SET lock thread01 NX EX 10

释放锁：

Terminal window

1
DEL lock

实现接口：

1
public interface ILock {
2
    boolean tryLock(long timeoutSec);
3
    void unlock();
4
}

实现类：

1
public class SimpleRedisLock implements ILock {
2

3
    private static final String KEY_PREFIX = "lock:";
4
    private final String name;
5
    private final StringRedisTemplate stringRedisTemplate;
6

7
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
8
        this.name = name;
9
        this.stringRedisTemplate = stringRedisTemplate;
10
    }
11

12
    @Override
13
    public boolean tryLock(long timeoutSec) {
14
        long threadId = Thread.currentThread().getId();
15
        Boolean success = stringRedisTemplate.opsForValue()
16
                .setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
17
        return Boolean.TRUE.equals(success);
18
    }
19

20
    @Override
21
    public void unlock() {
22
        stringRedisTemplate.delete(KEY_PREFIX + name);
23
    }
24
}

展开收起

业务使用：

1
SimpleRedisLock redisLock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
2
boolean isLock = redisLock.tryLock(120);
3

4
if (!isLock) {
5
    return Result.fail("不允许抢多张优惠券");
6
}
7

8
try {
9
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
10
    return proxy.createVoucherOrder(voucherId);
11
} finally {
12
    redisLock.unlock();
13
}

4.3 分布式锁误删问题#

如果线程 1 阻塞导致锁 TTL 到期，线程 2 获取锁；线程 1 恢复后直接删除锁，就会误删线程 2 的锁。

解决方案：锁中存入线程标识，释放时判断是否属于自己。

1
private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
2

3
@Override
4
public boolean tryLock(long timeoutSec) {
5
    String threadId = ID_PREFIX + Thread.currentThread().getId();
6
    Boolean success = stringRedisTemplate.opsForValue()
7
            .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
8
    return Boolean.TRUE.equals(success);
9
}
10

11
@Override
12
public void unlock() {
13
    String threadId = ID_PREFIX + Thread.currentThread().getId();
14
    String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
15

16
    if (threadId.equals(id)) {
17
        stringRedisTemplate.delete(KEY_PREFIX + name);
18
    }
19
}

展开收起

4.4 Lua 脚本保证原子性#

判断锁标识和删除锁必须是原子操作，否则仍可能误删。

Lua 脚本 unlock.lua：

1
local key = KEYS[1]
2
local threadId = ARGV[1]
3

4
if (redis.call('get', key) == threadId) then
5
    return redis.call('del', key)
6
end
7
return 0

Java 调用：

1
private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
2

3
static {
4
    UNLOCK_SCRIPT = new DefaultRedisScript<>();
5
    UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
6
    UNLOCK_SCRIPT.setResultType(Long.class);
7
}
8

9
@Override
10
public void unlock() {
11
    stringRedisTemplate.execute(
12
            UNLOCK_SCRIPT,
13
            Collections.singletonList(KEY_PREFIX + name),
14
            ID_PREFIX + Thread.currentThread().getId()
15
    );
16
}

展开收起

4.5 Redisson#

基于 SETNX 的分布式锁存在以下问题：

不可重入。
不可重试。
超时释放可能导致锁失效。
主从一致性存在问题。

Redisson 提供了完整解决方案。

导入依赖：

1
<dependency>
2
    <groupId>org.redisson</groupId>
3
    <artifactId>redisson</artifactId>
4
    <version>3.13.6</version>
5
</dependency>

配置：

1
@Configuration
2
public class RedissonConfig {
3

4
    @Bean
5
    public RedissonClient redissonClient() {
6
        Config config = new Config();
7
        config.useSingleServer()
8
                .setAddress("redis://127.0.0.1:6379")
9
                .setPassword("root");
10
        return Redisson.create(config);
11
    }
12
}

使用：

1
@Resource
2
private RedissonClient redissonClient;
3

4
@Test
5
void testRedisson() throws InterruptedException {
6
    RLock lock = redissonClient.getLock("anyLock");
7
    boolean success = lock.tryLock(1, 10, TimeUnit.SECONDS);
8

9
    if (success) {
10
        try {
11
            System.out.println("执行业务");
12
        } finally {
13
            lock.unlock();
14
        }
15
    }
16
}

展开收起

替换秒杀业务中的锁：

1
@Resource
2
private RedissonClient redissonClient;
3

4
RLock redisLock = redissonClient.getLock("order:" + userId);
5
boolean isLock = redisLock.tryLock();
6

7
if (!isLock) {
8
    return Result.fail("不允许抢多张优惠券");
9
}
10

11
try {
12
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
13
    return proxy.createVoucherOrder(voucherId);
14
} finally {
15
    redisLock.unlock();
16
}

展开收起

Redisson 可重入锁使用 Hash 结构记录线程标识与重入次数，并通过 WatchDog 机制自动续期。

Redisson MultiLock 用于主从一致性场景：多个独立 Redis 节点都加锁成功，才算加锁成功。

五、秒杀优化#

5.1 异步秒杀思路#

原始下单流程中，很多步骤需要访问数据库，并且串行执行，性能较差。

优化思路：

将库存判断、一人一单判断放到 Redis 中完成。
使用 Lua 脚本保证判断与扣减库存的原子性。
判断成功后，将下单信息放入消息队列。
后台线程异步消费消息，完成数据库下单。

5.2 Redis 完成秒杀资格判断#

Lua 脚本 seckill.lua：

1
local voucherId = ARGV[1]
2
local userId = ARGV[2]
3
local id = ARGV[3]
4

5
local stockKey = 'seckill:stock:' .. voucherId
6
local orderKey = 'seckill:order:' .. voucherId
7

8
if (tonumber(redis.call('get', stockKey)) <= 0) then
9
    return 1
10
end
11

12
if (redis.call('sismember', orderKey, userId) == 1) then
13
    return 2
14
end
15

16
redis.call('incrby', stockKey, -1)
17
redis.call('sadd', orderKey, userId)
18
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', id)
19

20
return 0

展开收起

业务逻辑：

1
@Override
2
public Result seckillVoucher(Long voucherId) {
3
    long orderId = redisIdWorker.nextId("order");
4

5
    Long result = stringRedisTemplate.execute(
6
            SECKILL_SCRIPT,
7
            Collections.emptyList(),
8
            voucherId.toString(),
9
            UserHolder.getUser().getId().toString(),
10
            String.valueOf(orderId)
11
    );
12

13
    if (result.intValue() != 0) {
14
        return Result.fail(result.intValue() == 1 ? "库存不足" : "不能重复下单");
15
    }
16

17
    proxy = (IVoucherOrderService) AopContext.currentProxy();
18
    return Result.ok(orderId);
19
}

展开收起

5.3 基于阻塞队列实现异步秒杀#

创建阻塞队列：

1
private final BlockingQueue<VoucherOrder> orderTasks =
2
        new ArrayBlockingQueue<>(1024 * 1024);

将订单加入队列：

1
VoucherOrder voucherOrder = new VoucherOrder();
2
voucherOrder.setVoucherId(voucherId);
3
voucherOrder.setUserId(UserHolder.getUser().getId());
4
voucherOrder.setId(orderId);
5
orderTasks.add(voucherOrder);

线程池消费：

1
private static final ExecutorService SECKILL_ORDER_EXECUTOR =
2
        Executors.newSingleThreadExecutor();
3

4
@PostConstruct
5
private void init() {
6
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
7
}
8

9
private class VoucherOrderHandler implements Runnable {
10
    @Override
11
    public void run() {
12
        while (true) {
13
            try {
14
                VoucherOrder voucherOrder = orderTasks.take();
15
                handleVoucherOrder(voucherOrder);
16
            } catch (Exception e) {
17
                log.error("订单处理异常", e);
18
            }
19
        }
20
    }
21
}
22

23
private void handleVoucherOrder(VoucherOrder voucherOrder) {
24
    Long userId = voucherOrder.getUserId();
25
    RLock redisLock = redissonClient.getLock("order:" + userId);
26
    boolean isLock = redisLock.tryLock();
27

28
    if (!isLock) {
29
        log.error("不允许重复下单!");
30
        return;
31
    }
32

33
    try {
34
        proxy.createVoucherOrder(voucherOrder);
35
    } finally {
36
        redisLock.unlock();
37
    }
38
}

展开收起

阻塞队列的问题

受 JVM 内存限制，高并发时可能内存溢出。
服务宕机时，队列中的订单可能丢失。

5.4 Redis 消息队列#

方案	消息持久化	阻塞读取	消息确认	消息回溯
List	支持	支持	不支持	不支持
PubSub	不支持	支持	不支持	不支持
Stream	支持	支持	支持	支持

基于 List#

Terminal window

1
LPUSH queue msg
2
BRPOP queue

优点：

利用 Redis 存储，不受 JVM 内存上限限制。
基于 Redis 持久化机制，数据安全性有保障。
可以满足消息有序性。

缺点：

无法避免消息丢失。
只支持单消费者。

基于 PubSub#

Terminal window

1
SUBSCRIBE channel
2
PUBLISH channel msg
3
PSUBSCRIBE pattern

优点：支持多生产、多消费。

缺点：不支持持久化、可能丢消息、消息堆积有上限。

基于 Stream#

发送消息：

Terminal window

1
XADD users * name jack age 21

读取消息：

Terminal window

1
XREAD COUNT 1 BLOCK 2000 STREAMS users $

创建消费者组：

Terminal window

1
XGROUP CREATE stream.orders g1 0 MKSTREAM

消费者组读取：

Terminal window

1
XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS stream.orders >

确认消息：

Terminal window

1
XACK stream.orders g1 消息ID

Stream 特点：

消息可回溯。
多消费者争抢消息。
可阻塞读取。
无消息漏读风险。
有消息确认机制。

5.5 基于 Stream 实现异步秒杀#

Lua 脚本中直接写入 Stream：

1
redis.call('xadd', 'stream.orders', '*',
2
        'userId', userId,
3
        'voucherId', voucherId,
4
        'id', id)

消费者处理：

1
private class VoucherOrderHandler implements Runnable {
2
    @Override
3
    public void run() {
4
        while (true) {
5
            try {
6
                List<MapRecord<String, Object, Object>> list =
7
                        stringRedisTemplate.opsForStream().read(
8
                                Consumer.from("g1", "c1"),
9
                                StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
10
                                StreamOffset.create("stream.orders", ReadOffset.lastConsumed())
11
                        );
12

13
                if (list == null || list.isEmpty()) {
14
                    continue;
15
                }
16

17
                MapRecord<String, Object, Object> record = list.get(0);
18
                Map<Object, Object> value = record.getValue();
19
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(
20
                        value,
21
                        new VoucherOrder(),
22
                        true
23
                );
24

25
                handleVoucherOrder(voucherOrder);
26

27
                stringRedisTemplate.opsForStream().acknowledge(
28
                        "stream.orders",
29
                        "g1",
30
                        record.getId()
31
                );
32
            } catch (Exception e) {
33
                log.error("处理订单异常", e);
34
                handlePendingList();
35
            }
36
        }
37
    }
38

39
    private void handlePendingList() {
40
        while (true) {
41
            try {
42
                List<MapRecord<String, Object, Object>> list =
43
                        stringRedisTemplate.opsForStream().read(
44
                                Consumer.from("g1", "c1"),
45
                                StreamReadOptions.empty().count(1),
46
                                StreamOffset.create("stream.orders", ReadOffset.from("0"))
47
                        );
48

49
                if (list == null || list.isEmpty()) {
50
                    break;
51
                }
52

53
                MapRecord<String, Object, Object> record = list.get(0);
54
                Map<Object, Object> value = record.getValue();
55
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(
56
                        value,
57
                        new VoucherOrder(),
58
                        true
59
                );
60

61
                handleVoucherOrder(voucherOrder);
62

63
                stringRedisTemplate.opsForStream().acknowledge(
64
                        "stream.orders",
65
                        "g1",
66
                        record.getId()
67
                );
68
            } catch (Exception e) {
69
                log.error("处理 pending-list 异常", e);
70
            }
71
        }
72
    }
73
}

展开收起

六、达人探店#

6.1 发布探店笔记#

保存探店笔记：

1
@PostMapping
2
public Result saveBlog(@RequestBody Blog blog) {
3
    UserDTO user = UserHolder.getUser();
4
    blog.setUserId(user.getId());
5
    blogService.save(blog);
6
    return Result.ok(blog.getId());
7
}

上传图片：

1
@PostMapping("blog")
2
public Result uploadImage(@RequestParam("file") MultipartFile image) {
3
    try {
4
        String originalFilename = image.getOriginalFilename();
5
        String fileName = createNewFileName(originalFilename);
6
        image.transferTo(new File(SystemConstants.IMAGE_UPLOAD_DIR, fileName));
7
        return Result.ok(fileName);
8
    } catch (IOException e) {
9
        throw new RuntimeException("文件上传失败", e);
10
    }
11
}

6.2 查看探店笔记#

1
@GetMapping("/{id}")
2
public Result queryById(@PathVariable Integer id) {
3
    return blogService.queryById(id);
4
}

Service：

1
@Override
2
public Result queryById(Integer id) {
3
    Blog blog = getById(id);
4
    if (blog == null) {
5
        return Result.fail("评价不存在或已被删除");
6
    }
7
    queryBlogUser(blog);
8
    isBlogLiked(blog);
9
    return Result.ok(blog);
10
}

6.3 点赞功能#

最初实现只是简单给点赞数 +1，会导致用户无限点赞。

使用 Redis Set 或 SortedSet 判断是否已点赞。

1
@Override
2
public Result likeBlog(Long id) {
3
    Long userId = UserHolder.getUser().getId();
4
    String key = BLOG_LIKED_KEY + id;
5

6
    Double score = stringRedisTemplate.opsForZSet().score(key, userId.toString());
7

8
    if (score == null) {
9
        boolean success = update()
10
                .setSql("liked = liked + 1")
11
                .eq("id", id)
12
                .update();
13

14
        if (success) {
15
            stringRedisTemplate.opsForZSet().add(
16
                    key,
17
                    userId.toString(),
18
                    System.currentTimeMillis()
19
            );
20
        }
21
    } else {
22
        boolean success = update()
23
                .setSql("liked = liked - 1")
24
                .eq("id", id)
25
                .update();
26

27
        if (success) {
28
            stringRedisTemplate.opsForZSet().remove(key, userId.toString());
29
        }
30
    }
31

32
    return Result.ok();
33
}

展开收起

判断当前用户是否点赞：

1
private void isBlogLiked(Blog blog) {
2
    UserDTO userDTO = UserHolder.getUser();
3
    if (userDTO == null) {
4
        return;
5
    }
6
    String key = BLOG_LIKED_KEY + blog.getId();
7
    Double score = stringRedisTemplate.opsForZSet()
8
            .score(key, userDTO.getId().toString());
9
    blog.setIsLike(score != null);
10
}

6.4 点赞排行榜#

查询点赞 Top5：

1
@GetMapping("/likes/{id}")
2
public Result queryBlogLikes(@PathVariable Integer id) {
3
    return blogService.queryBlogLikes(id);
4
}

Service：

1
@Override
2
public Result queryBlogLikes(Integer id) {
3
    String key = BLOG_LIKED_KEY + id;
4
    Set<String> top5 = stringRedisTemplate.opsForZSet().range(key, 0, 4);
5

6
    if (top5 == null || top5.isEmpty()) {
7
        return Result.ok(Collections.emptyList());
8
    }
9

10
    List<Long> ids = top5.stream().map(Long::valueOf).collect(Collectors.toList());
11
    String idsStr = StrUtil.join(",", ids);
12

13
    List<UserDTO> userDTOS = userService.query()
14
            .in("id", ids)
15
            .last("order by field(id," + idsStr + ")")
16
            .list()
17
            .stream()
18
            .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
19
            .collect(Collectors.toList());
20

21
    return Result.ok(userDTOS);
22
}

展开收起

七、好友关注与 Feed 流#

7.1 关注与取消关注#

判断是否关注：

1
@GetMapping("/or/not/{id}")
2
public Result isFollow(@PathVariable("id") Long followUserId) {
3
    return followService.isFollow(followUserId);
4
}

关注/取关：

1
@PutMapping("/{id}/{isFollow}")
2
public Result follow(
3
        @PathVariable("id") Long followUserId,
4
        @PathVariable("isFollow") Boolean isFollow
5
) {
6
    return followService.follow(followUserId, isFollow);
7
}

Service：

1
@Override
2
public Result isFollow(Long followUserId) {
3
    Long userId = UserHolder.getUser().getId();
4
    LambdaQueryWrapper<Follow> queryWrapper = new LambdaQueryWrapper<>();
5
    queryWrapper.eq(Follow::getUserId, userId)
6
            .eq(Follow::getFollowUserId, followUserId);
7
    int count = count(queryWrapper);
8
    return Result.ok(count > 0);
9
}
10

11
@Override
12
public Result follow(Long followUserId, Boolean isFollow) {
13
    Long userId = UserHolder.getUser().getId();
14
    String key = "follows:" + userId;
15

16
    if (isFollow) {
17
        Follow follow = new Follow();
18
        follow.setUserId(userId);
19
        follow.setFollowUserId(followUserId);
20
        boolean success = save(follow);
21

22
        if (success) {
23
            stringRedisTemplate.opsForSet().add(key, followUserId.toString());
24
        }
25
    } else {
26
        LambdaQueryWrapper<Follow> queryWrapper = new LambdaQueryWrapper<>();
27
        queryWrapper.eq(Follow::getUserId, userId)
28
                .eq(Follow::getFollowUserId, followUserId);
29
        boolean success = remove(queryWrapper);
30

31
        if (success) {
32
            stringRedisTemplate.opsForSet().remove(key, followUserId.toString());
33
        }
34
    }
35

36
    return Result.ok();
37
}

展开收起

7.2 共同关注#

利用 Redis Set 求交集：

1
@GetMapping("/common/{id}")
2
public Result followCommons(@PathVariable Long id) {
3
    return followService.followCommons(id);
4
}

Service：

1
@Override
2
public Result followCommons(Long id) {
3
    Long userId = UserHolder.getUser().getId();
4
    String key1 = "follows:" + userId;
5
    String key2 = "follows:" + id;
6

7
    Set<String> intersect = stringRedisTemplate.opsForSet().intersect(key1, key2);
8

9
    if (intersect == null || intersect.isEmpty()) {
10
        return Result.ok(Collections.emptyList());
11
    }
12

13
    List<Long> ids = intersect.stream().map(Long::valueOf).collect(Collectors.toList());
14

15
    List<UserDTO> users = userService.listByIds(ids)
16
            .stream()
17
            .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
18
            .collect(Collectors.toList());
19

20
    return Result.ok(users);
21
}

展开收起

7.3 Feed 流#

Feed 流有两种模式：

Timeline：按发布时间排序，适合好友/关注场景。
智能排序：根据算法推荐用户感兴趣的内容。

Timeline 三种实现方案：

方案	说明	优点	缺点
拉模式	读时拉取关注人的发件箱	节约空间	有延迟，关注多时压力大
推模式	写时推送到粉丝收件箱	时效快	内存压力大
推拉结合	普通人推、大V拉	折中	实现复杂

7.4 推送到粉丝收件箱#

保存笔记后，推送到粉丝的 SortedSet：

1
@Override
2
public Result saveBlog(Blog blog) {
3
    UserDTO user = UserHolder.getUser();
4
    blog.setUserId(user.getId());
5
    save(blog);
6

7
    LambdaQueryWrapper<Follow> queryWrapper = new LambdaQueryWrapper<>();
8
    queryWrapper.eq(Follow::getFollowUserId, user.getId());
9
    List<Follow> follows = followService.list(queryWrapper);
10

11
    for (Follow follow : follows) {
12
        Long userId = follow.getUserId();
13
        String key = FEED_KEY + userId;
14
        stringRedisTemplate.opsForZSet().add(
15
                key,
16
                blog.getId().toString(),
17
                System.currentTimeMillis()
18
        );
19
    }
20

21
    return Result.ok(blog.getId());
22
}

展开收起

7.5 滚动分页查询收件箱#

Feed 流数据不断更新，不能使用传统分页，需要使用滚动分页。

请求参数：

lastId：上一次查询的最小时间戳。
offset：偏移量。

通用结果类：

1
@Data
2
public class ScrollResult {
3
    private List<?> list;
4
    private Long minTime;
5
    private Integer offset;
6
}

Controller：

1
@GetMapping("/of/follow")
2
public Result queryBlogOfFollow(
3
        @RequestParam("lastId") Long max,
4
        @RequestParam(value = "offset", defaultValue = "0") Integer offset
5
) {
6
    return blogService.queryBlogOfFollow(max, offset);
7
}

Service：

1
@Override
2
public Result queryBlogOfFollow(Long max, Integer offset) {
3
    Long userId = UserHolder.getUser().getId();
4
    String key = FEED_KEY + userId;
5

6
    Set<ZSetOperations.TypedTuple<String>> typedTuples =
7
            stringRedisTemplate.opsForZSet()
8
                    .reverseRangeByScoreWithScores(key, 0, max, offset, 2);
9

10
    if (typedTuples == null || typedTuples.isEmpty()) {
11
        return Result.ok(Collections.emptyList());
12
    }
13

14
    List<Long> ids = new ArrayList<>(typedTuples.size());
15
    long minTime = 0;
16
    int os = 1;
17

18
    for (ZSetOperations.TypedTuple<String> tuple : typedTuples) {
19
        ids.add(Long.valueOf(tuple.getValue()));
20
        long time = tuple.getScore().longValue();
21

22
        if (time == minTime) {
23
            os++;
24
        } else {
25
            minTime = time;
26
            os = 1;
27
        }
28
    }
29

30
    String idStr = StrUtil.join(",", ids);
31
    List<Blog> blogs = query()
32
            .in("id", ids)
33
            .last("order by field(id," + idStr + ")")
34
            .list();
35

36
    for (Blog blog : blogs) {
37
        queryBlogUser(blog);
38
        isBlogLiked(blog);
39
    }
40

41
    ScrollResult r = new ScrollResult();
42
    r.setList(blogs);
43
    r.setOffset(os);
44
    r.setMinTime(minTime);
45

46
    return Result.ok(r);
47
}

展开收起

八、附近商户#

8.1 GEO 基本用法#

命令	说明
`GEOADD`	添加地理坐标
`GEODIST`	计算两点距离
`GEOHASH`	返回 Geohash 字符串
`GEOPOS`	返回坐标
`GEORADIUS`	根据圆心和半径查询（6.2 后废弃）
`GEOSEARCH`	在指定范围内搜索（6.2 新功能）
`GEOSEARCHSTORE`	搜索并存储结果

示例：

Terminal window

1
GEOADD china 13.361389 38.115556 "shanghai" 15.087269 37.502669 "beijing"
2
GEODIST china beijing shanghai km
3
GEOSEARCH china FROMLONLAT 15 37 BYRADIUS 200 km ASC WITHCOORD WITHDIST

8.2 导入店铺数据到 GEO#

1
@Test
2
public void loadShopData() {
3
    List<Shop> shopList = shopService.list();
4
    Map<Long, List<Shop>> map = shopList.stream()
5
            .collect(Collectors.groupingBy(Shop::getTypeId));
6

7
    for (Map.Entry<Long, List<Shop>> entry : map.entrySet()) {
8
        Long typeId = entry.getKey();
9
        List<Shop> shops = entry.getValue();
10
        String key = SHOP_GEO_KEY + typeId;
11

12
        List<RedisGeoCommands.GeoLocation<String>> locations =
13
                new ArrayList<>(shops.size());
14

15
        for (Shop shop : shops) {
16
            locations.add(new RedisGeoCommands.GeoLocation<>(
17
                    shop.getId().toString(),
18
                    new Point(shop.getX(), shop.getY())
19
            ));
20
        }
21

22
        stringRedisTemplate.opsForGeo().add(key, locations);
23
    }
24
}

展开收起

8.3 实现附近商户功能#

SpringDataRedis 2.3.9 不支持 Redis 6.2 的 GEOSEARCH，需要升级：

1
<dependency>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-data-redis</artifactId>
4
    <exclusions>
5
        <exclusion>
6
            <artifactId>spring-data-redis</artifactId>
7
            <groupId>org.springframework.data</groupId>
8
        </exclusion>
9
        <exclusion>
10
            <artifactId>lettuce-core</artifactId>
11
            <groupId>io.lettuce</groupId>
12
        </exclusion>
13
    </exclusions>
14
</dependency>
15
<dependency>
16
    <groupId>org.springframework.data</groupId>
17
    <artifactId>spring-data-redis</artifactId>
18
    <version>2.6.2</version>
19
</dependency>
20
<dependency>
21
    <groupId>io.lettuce</groupId>
22
    <artifactId>lettuce-core</artifactId>
23
    <version>6.1.6.RELEASE</version>
24
</dependency>

展开收起

Controller：

1
@GetMapping("/of/type")
2
public Result queryShopByType(
3
        @RequestParam("typeId") Integer typeId,
4
        @RequestParam(value = "current", defaultValue = "1") Integer current,
5
        @RequestParam(value = "x", required = false) Double x,
6
        @RequestParam(value = "y", required = false) Double y
7
) {
8
    return shopService.queryShopByType(typeId, current, x, y);
9
}

Service：

1
@Override
2
public Result queryShopByType(Integer typeId, Integer current, Double x, Double y) {
3
    if (x == null || y == null) {
4
        Page<Shop> page = query()
5
                .eq("type_id", typeId)
6
                .page(new Page<>(current, SystemConstants.DEFAULT_PAGE_SIZE));
7
        return Result.ok(page.getRecords());
8
    }
9

10
    int from = (current - 1) * SystemConstants.MAX_PAGE_SIZE;
11
    int end = current * SystemConstants.MAX_PAGE_SIZE;
12
    String key = SHOP_GEO_KEY + typeId;
13

14
    GeoResults<RedisGeoCommands.GeoLocation<String>> results =
15
            stringRedisTemplate.opsForGeo().search(
16
                    key,
17
                    GeoReference.fromCoordinate(x, y),
18
                    new Distance(5000),
19
                    RedisGeoCommands.GeoSearchCommandArgs.newGeoSearchArgs()
20
                            .includeDistance()
21
                            .limit(end)
22
            );
23

24
    if (results == null) {
25
        return Result.ok(Collections.emptyList());
26
    }
27

28
    List<GeoResult<RedisGeoCommands.GeoLocation<String>>> list = results.getContent();
29

30
    if (list.size() < from) {
31
        return Result.ok(Collections.emptyList());
32
    }
33

34
    List<Long> ids = new ArrayList<>(list.size());
35
    Map<String, Distance> distanceMap = new HashMap<>(list.size());
36

37
    list.stream().skip(from).forEach(result -> {
38
        String shopIdStr = result.getContent().getName();
39
        ids.add(Long.valueOf(shopIdStr));
40
        distanceMap.put(shopIdStr, result.getDistance());
41
    });
42

43
    String idsStr = StrUtil.join(",", ids);
44
    List<Shop> shops = query()
45
            .in("id", ids)
46
            .last("ORDER BY FIELD(id," + idsStr + ")")
47
            .list();
48

49
    for (Shop shop : shops) {
50
        shop.setDistance(distanceMap.get(shop.getId().toString()).getValue());
51
    }
52

53
    return Result.ok(shops);
54
}

展开收起

九、用户签到#

9.1 BitMap 介绍#

BitMap 使用二进制位记录业务状态，签到为 1，未签到为 0。

Redis 中 BitMap 基于 String 实现，最大 512M，即 2^32 个 bit。

常用命令：

命令	说明
`SETBIT`	向指定位置存入 0 或 1
`GETBIT`	获取指定位置的 bit 值
`BITCOUNT`	统计值为 1 的 bit 数量
`BITFIELD`	操作 bit 数组指定位置
`BITOP`	多个 BitMap 位运算
`BITPOS`	查找第一个 0 或 1

9.2 实现签到功能#

1
@PostMapping("/sign")
2
public Result sign() {
3
    return userService.sign();
4
}

Service：

1
@Override
2
public Result sign() {
3
    Long userId = UserHolder.getUser().getId();
4
    LocalDateTime now = LocalDateTime.now();
5

6
    String keySuffix = now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
7
    String key = USER_SIGN_KEY + userId + keySuffix;
8

9
    int dayOfMonth = now.getDayOfMonth();
10
    stringRedisTemplate.opsForValue().setBit(key, dayOfMonth - 1, true);
11

12
    return Result.ok();
13
}

9.3 签到统计#

统计截止当前时间的连续签到天数：

1
@GetMapping("/sign/count")
2
public Result signCount() {
3
    return userService.signCount();
4
}

Service：

1
@Override
2
public Result signCount() {
3
    Long userId = UserHolder.getUser().getId();
4
    LocalDateTime now = LocalDateTime.now();
5

6
    String keySuffix = now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
7
    String key = USER_SIGN_KEY + userId + keySuffix;
8

9
    int dayOfMonth = now.getDayOfMonth();
10

11
    List<Long> result = stringRedisTemplate.opsForValue().bitField(
12
            key,
13
            BitFieldSubCommands.create()
14
                    .get(BitFieldSubCommands.BitFieldType.unsigned(dayOfMonth))
15
                    .valueAt(0)
16
    );
17

18
    if (result == null || result.isEmpty()) {
19
        return Result.ok(0);
20
    }
21

22
    int count = 0;
23
    Long num = result.get(0);
24

25
    while (true) {
26
        if ((num & 1) == 0) {
27
            break;
28
        }
29
        count++;
30
        num >>>= 1;
31
    }
32

33
    return Result.ok(count);
34
}

展开收起

十、UV 统计#

10.1 HyperLogLog#

UV：Unique Visitor，独立访客量，同一用户一天内多次访问只记录一次。
PV：Page View，页面访问量，每访问一次记录一次。

HyperLogLog 是概率算法，用于统计大规模集合基数，内存占用极低，单个 HLL 小于 16KB，误差约 0.81%。

常用命令：

命令	说明
`PFADD key element ...`	添加元素
`PFCOUNT key ...`	统计基数
`PFMERGE destkey sourcekey ...`	合并多个 HLL

测试百万数据：

1
@Test
2
public void testHyperLogLog() {
3
    String[] users = new String[1000];
4
    int j = 0;
5

6
    for (int i = 0; i < 1000000; i++) {
7
        j = i % 1000;
8
        users[j] = "user_" + i;
9

10
        if (j == 999) {
11
            stringRedisTemplate.opsForHyperLogLog().add("HLL", users);
12
        }
13
    }
14

15
    Long count = stringRedisTemplate.opsForHyperLogLog().size("HLL");
16
    System.out.println("count = " + count);
17
}

展开收起

百万数据测试结果误差很小，内存占用仅约 12KB，非常适合 UV 统计场景。

总结#

本文围绕黑马点评项目，串联了 Redis 在实际业务中的典型用法：

使用 Redis 替代 Session，实现 Token 登录。
使用缓存解决商户查询性能问题，并处理缓存穿透、雪崩、击穿。
使用 Redis 全局 ID、Lua 脚本、分布式锁、消息队列优化优惠券秒杀。
使用 Set、SortedSet 实现点赞、关注、共同关注和 Feed 流。
使用 GEO 实现附近商户查询。
使用 BitMap 实现签到统计。
使用 HyperLogLog 实现 UV 统计。

下一步建议

可以继续深入学习 Redis 持久化、主从复制、哨兵、分片集群，以及 Redisson 在生产环境中的锁续期、联锁、读写锁等高级特性。

Redis 入门不迷路：从 NoSQL 到 Spring Data Redis 实战笔记

Thu, 07 Aug 2025 00:00:00 GMT

Redis 入门不迷路：从 NoSQL 到 Spring Data Redis 实战笔记#

阅读姿势

这不是一份“命令流水账”，而是一张从概念到项目落地的学习地图。建议打开 redis-cli 边看边敲；命令别死背，先想清楚它解决什么问题。

先把学习路线铺开#

NoSQL 是什么

Redis 核心特征

redis-cli 与桌面客户端

五大数据结构

Jedis 直连/连接池

Spring Data Redis

序列化选型

NoSQL 是什么

Redis 核心特征

redis-cli 与桌面客户端

五大数据结构

Jedis 直连/连接池

Spring Data Redis

序列化选型

初识 Redis：先别急着背命令#

Redis 是一个键值型 NoSQL 数据库。这里有两个关键词：

键值型：数据以 Key-Value 形式存储，Value 可以是字符串、数值、JSON 等。
NoSQL：它和传统关系型数据库的思路差别很大。

你可以先把 Redis 理解成“内存里一个特别能打的数据结构服务器”。但它不只是大号 Map，后面会看到 String、Hash、List、Set、SortedSet 各有各的脾气。

NoSQL 和 SQL 到底差在哪#

NoSQL 常被解释为 Not Only SQL，也可以理解为“非关系型数据库”。它不是来完全替代 SQL 的，而是解决另一类问题。

结构化 vs 非结构化#

关系型数据库是结构化的：建表时字段名、类型、约束都定好了，插入数据必须守规矩。

NoSQL 通常没有严格约束，可以是键值型、文档型，甚至图结构。

关联 vs 非关联#

关系型数据库表与表之间常有外键关联。NoSQL 往往不靠数据库维护关联，要么靠业务代码，要么靠数据冗余。

比如要维护“张三和两个手机订单”的关系，可能得把订单信息塞进用户文档里：

1
{
2
  "id": 1,
3
  "name": "张三",
4
  "orders": [
5
    {
6
      "id": 1,
7
      "item": { "id": 10, "title": "荣耀6", "price": 4999 }
8
    },
9
    {
10
      "id": 2,
11
      "item": { "id": 20, "title": "小米11", "price": 3999 }
12
    }
13
  ]
14
}

这种冗余不够优雅，所以实际项目更推荐用业务逻辑维护关联关系。

查询方式不一样#

SQL 有统一语法：

1
SELECT id, age FROM tb_user WHERE id = 1;

NoSQL 则是“各家有各家的方言”：

1
Redis:         get user:1
2
MongoDB:       db.user.find({_id: 1})
3
elasticsearch: GET http://localhost:9200/users/1

事务能力不一样#

关系型数据库通常满足事务 ACID：原子性、一致性、隔离性、持久性。

NoSQL 往往不支持完整事务，或者只能保证基本一致性，更偏向 BASE。

一张表快速对比#

特性	SQL	NoSQL
数据结构	结构化（Structured）	非结构化
数据关联	关联的（Relational）	无关联或弱关联
查询方式	SQL 查询	非 SQL，方言差异大
事务特性	ACID	BASE
存储方式	磁盘为主	内存为主
扩展性	垂直扩展为主	水平扩展更常见
使用场景	数据结构固定、一致性/安全性要求高、关系复杂	数据结构不固定、性能要求高、可水平扩展、最终一致

存储方式与扩展性#

关系型数据库基于磁盘，磁盘 IO 多，性能会受影响。

NoSQL 更依赖内存，读写速度很快，性能自然更猛。

扩展性上：

垂直扩展：关系型数据库常见主从集群，主从数据一致，主要用于备份和读扩展。
水平扩展：NoSQL 可以把数据拆分到不同机器，存海量数据，解决单机内存有限的问题。

别忽略关联的代价

关系型数据库表之间有关联，如果硬做水平扩展，查询会变得很麻烦。选型时别只看“能扩”，也要看“扩完好不好查”。

认识 Redis：它到底强在哪#

Redis 诞生于 2009 年，全称 Remote Dictionary Server（远程词典服务器），是一个基于内存的键值型 NoSQL 数据库。

核心特征：

Key-Value 型，Value 支持多种数据结构，功能丰富
单线程模型，每个命令具有原子性
低延迟、速度快：基于内存、IO 多路复用、编码优化
支持数据持久化
支持主从集群、分片集群
支持多语言客户端

作者：Antirez
官网：https://redis.io/

安装与客户端：工具先备齐#

Redis 安装可以参考之前整理的文章：

Redis 入门

安装完成后，操作 Redis 常见有三类客户端：

命令行客户端
图形化桌面客户端
编程客户端

redis-cli 命令行客户端#

Redis 自带 redis-cli，基本用法：

Terminal window

1
redis-cli [options] [commands]

常见 options：

参数	说明
`-h 127.0.0.1`	指定 Redis 节点 IP，默认 127.0.0.1
`-p 6379`	指定 Redis 节点端口，默认 6379
`-a 123321`	指定访问密码

commands 就是 Redis 操作命令，比如：

Terminal window

1
ping

服务端正常会返回 pong。

图形化桌面客户端#

下载地址：https://github.com/lework/RedisDesktopManager-Windows/releases

Redis 默认有 16 个数据库，编号从 0 到 15。数据库数量可以通过配置文件调整，但数据库名称不能自定义。

使用 redis-cli 时，可以通过 select 选择数据库：

Terminal window

1
# 选择 0 号数据库
2
select 0

五大数据结构速通#

Redis 是典型 key-value 数据库，key 一般是字符串，value 则有很多类型。先把通用命令拿下，再逐个击破。

通用命令：先学会“看家本领”#

命令	描述
`KEYS pattern`	查找所有符合给定模式的 key
`EXISTS key`	检查给定 key 是否存在
`TYPE key`	返回 key 所储存值的类型
`TTL key`	返回 key 剩余生存时间，单位秒
`EXPIRE key seconds`	给 key 设置有效期
`DEL key`	key 存在时删除 key

补充说明：

DEL name age 可以一次删除多个 key。
EXISTS name 存在返回 1，不存在返回 0。
EXPIRE name 20 给 name 设置 20 秒有效期。
TTL name 未设置有效期通常返回 -1。

生产环境慎用 KEYS

Redis 是单线程的，KEYS 做模糊查询时可能阻塞其他命令。数据量大时效率极差，生产环境不建议乱用。

String：最基础，也最常用#

String 是 Redis 中最简单的存储类型。Value 是字符串，但根据格式又可以分为：

类型	说明
`string`	普通字符串
`int`	整数，可自增自减
`float`	浮点数，可自增自减

不管哪种格式，底层都是字节数组存储，只是编码方式不同。String 类型最大空间不能超过 512M。

常用命令：

命令	描述
`SET`	添加或修改 String 类型键值对
`GET`	根据 key 获取 String 类型 value
`MSET`	批量添加多个 String 类型键值对
`MGET`	根据多个 key 获取多个 value
`INCR`	整型 key 自增 1
`INCRBY`	整型 key 自增并指定步长，如 `INCRBY num 2`
`INCRBYFLOAT`	浮点类型数字自增并指定步长
`SETNX`	key 不存在时才添加
`SETEX`	添加键值对并指定有效期

Key 结构：别让 id 打架#

Redis 没有 MySQL 中 Table 的概念，那怎么区分不同类型的数据？

场景举例

用户 id 是 1，商品 id 也是 1。如果都用 1 当 key，就会冲突。

解决办法是给 key 加前缀，用 : 分隔形成层级结构：

1
项目名:业务名:类型:id

这个格式不固定，可以按需求增删词条。假设项目名叫 reggie：

1
user 相关 key: reggie:user:1
2
dish 相关 key: reggie:dish:1

如果 Value 是 Java 对象，可以序列化为 JSON 字符串：

KEY	VALUE
`reggie:user:1`	`{"id":1, "name": "Jack", "age": 21}`
`reggie:dish:1`	`{"id":1, "name": "鲟鱼火锅", "price": 4999}`

图形化客户端里也会按相同前缀展示层次结构，看起来清爽很多。

Hash：对象字段可以单独改#

Hash 类型也叫散列，Value 是一个无序字典，类似 Java 的 HashMap。

String 存对象时，要改某个属性得整体改；Hash 可以把对象每个字段独立存储，针对单个字段做 CRUD。

KEY	field	value
`reggie:user:1`	name	Jack
`reggie:user:1`	age	21
`reggie:user:2`	name	Rose
`reggie:user:2`	age	18

常用命令：

命令	描述
`HSET key field value`	添加或修改 hash 类型 key 的 field 值
`HGET key field`	获取 hash 类型 key 的 field 值
`HMSET`	批量添加多个 field 值
`HMGET`	批量获取多个 field 值
`HGETALL`	获取所有 field 和 value
`HKEYS`	获取所有 field
`HINCRBY`	hash 字段值自增并指定步长
`HSETNX`	field 不存在时才添加

List：像 LinkedList 一样排队#

Redis 的 List 类似 Java 的 LinkedList，可以看成双向链表，支持正向和反向检索。

特点：

有序
元素可重复
插入和删除快
查询速度一般

常用来存有序数据，比如朋友圈点赞列表、评论列表。

常用命令：

命令	描述
`LPUSH key element ...`	向列表左侧插入一个或多个元素
`LPOP key`	移除并返回列表左侧第一个元素，没有则返回 nil
`RPUSH key element ...`	向列表右侧插入一个或多个元素
`RPOP key`	移除并返回列表右侧第一个元素
`LRANGE key start end`	返回指定角标范围内的元素
`BLPOP` / `BRPOP`	类似 `LPOP`/`RPOP`，没有元素时等待指定时间

Set：去重和交集的好帮手#

Redis 的 Set 类似 Java 的 HashSet，可以理解为 value 为 null 的 HashMap。

特点：

无序
元素不可重复
查找快
支持交集、并集、差集

常用命令：

命令	描述
`SADD key member ...`	向 set 添加一个或多个元素
`SREM key member ...`	移除指定元素
`SCARD key`	返回元素个数
`SISMEMBER key member`	判断元素是否存在
`SMEMBERS`	获取所有元素
`SINTER key1 key2 ...`	求交集
`SUNION key1 key2 ...`	求并集
`SDIFF key1 key2 ...`	求差集

小练习：用 Set 维护好友关系#

Terminal window

1
# 张三的好友：李四、王五、赵六
2
127.0.0.1:6379> sadd zhangsan lisi wangwu zhaoliu
3
(integer) 3
4

5
# 李四的好友：王五、麻子、二狗
6
127.0.0.1:6379> sadd lisi wangwu mazi ergou
7
(integer) 3

计算张三的好友人数：

Terminal window

1
127.0.0.1:6379> scard zhangsan
2
(integer) 3

计算张三和李四的共同好友：

Terminal window

1
127.0.0.1:6379> sinter zhangsan lisi
2
1) "wangwu"

查询是张三好友、但不是李四好友的人：

Terminal window

1
127.0.0.1:6379> sdiff zhangsan lisi
2
1) "zhaoliu"
3
2) "lisi"

查询两人的好友总人数：

Terminal window

1
127.0.0.1:6379> sunion zhangsan lisi
2
1) "wangwu"
3
2) "zhaoliu"
4
3) "ergou"
5
4) "lisi"
6
5) "mazi"

判断李四是否是张三的好友：

Terminal window

1
127.0.0.1:6379> sismember zhangsan lisi
2
(integer) 1

判断张三是否是李四的好友：

Terminal window

1
127.0.0.1:6379> sismember lisi zhangsan
2
(integer) 0

把李四从张三好友列表移除：

Terminal window

1
127.0.0.1:6379> srem zhangsan lisi
2
(integer) 1

SortedSet：排行榜专业户#

SortedSet 是可排序的 Set，和 Java 的 TreeSet 有点像，但底层差别很大。每个元素带一个 score，可基于 score 排序，底层实现是跳表（SkipList）+ hash 表。

特点：

可排序
元素不重复
查询速度快

因为能排序，SortedSet 经常用来做排行榜。

常用命令：

命令	描述
`ZADD key score member`	添加一个或多个元素，已存在则更新 score
`ZREM key member`	删除指定元素
`ZSCORE key member`	获取指定元素 score
`ZRANK key member`	获取指定元素排名
`ZCARD key`	获取元素个数
`ZCOUNT key min max`	统计 score 在给定范围内的元素个数
`ZINCRBY key increment member`	指定元素自增，步长为 increment
`ZRANGE key min max`	按 score 升序获取指定排名范围元素
`ZRANGEBYSCORE key min max`	按 score 获取指定分数范围元素
`ZDIFF` / `ZINTER` / `ZUNION`	求差集、交集、并集

升序与降序

排名默认升序。如果要降序，在命令的 Z 后面加 REV：

升序：ZRANK key member
降序：ZREVRANK key member

小练习：用 SortedSet 做班级成绩榜#

存入学生成绩：Jack 85, Lucy 89, Rose 82, Tom 95, Jerry 78, Amy 92, Miles 76

Terminal window

1
127.0.0.1:6379> zadd stu 85 Jack 89 Lucy 82 Rose 95 Tom 78 Jerry 92 Amy 76 Miles
2
(integer) 7

删除 Tom：

Terminal window

1
127.0.0.1:6379> zrem stu Tom
2
(integer) 1

获取 Amy 的分数：

Terminal window

1
127.0.0.1:6379> zscore stu Amy
2
"92"

获取 Rose 的排名：

Terminal window

1
127.0.0.1:6379> zrank stu Rose
2
(integer) 2

查询 80 分以下有几个学生：

Terminal window

1
127.0.0.1:6379> zcount stu 0 80
2
(integer) 2

给 Amy 加 2 分：

Terminal window

1
127.0.0.1:6379> zincrby stu 2 Amy
2
"94"

查出成绩前 3 名：

Terminal window

1
127.0.0.1:6379> zrange stu 0 2
2
1) "Miles"
3
2) "Jerry"
4
3) "Rose"

查出 80 分以下的所有同学：

Terminal window

1
127.0.0.1:6379> zrangebyscore stu 0 80
2
1) "Miles"
3
2) "Jerry"

Java 客户端：Jedis 与 Spring Data Redis#

主流 Redis Java 客户端可以这样理解：

客户端	说明
Jedis / Lettuce	提供 Redis 命令对应的 API，方便操作 Redis；Spring Data Redis 对它们做了抽象和封装
Redisson	在 Redis 基础上实现分布式可伸缩 Java 数据结构（Map、Queue 等），支持跨进程同步机制（Lock、Semaphore 等）

学习建议

Spring Data Redis 对 Jedis/Lettuce 都做了封装，后期建议直接以 Spring Data Redis 为主。

Jedis 快速入门#

Step 1：导入 Maven 坐标#

1
<!--jedis-->
2
<dependency>
3
    <groupId>redis.clients</groupId>
4
    <artifactId>jedis</artifactId>
5
    <version>3.7.0</version>
6
</dependency>
7
<!--单元测试-->
8
<dependency>
9
    <groupId>org.junit.jupiter</groupId>
10
    <artifactId>junit-jupiter</artifactId>
11
    <version>5.7.0</version>
12
    <scope>test</scope>
13
</dependency>

Step 2：建立连接#

1
private Jedis jedis;
2

3
@BeforeEach
4
void setUp() {
5
    // 1. 建立连接
6
    jedis = new Jedis("101.42.225.160", 6379);
7
    // 2. 设置密码
8
    jedis.auth("root");
9
    // 3. 选择库
10
    jedis.select(0);
11
}

Step 3：写两个测试感受一下#

1
@Test
2
void testString() {
3
    jedis.set("name", "Kyle");
4
    String name = jedis.get("name");
5
    System.out.println("name = " + name);
6
}
7

8
@Test
9
void testHash() {
10
    jedis.hset("reggie:user:1", "name", "Jack");
11
    jedis.hset("reggie:user:2", "name", "Rose");
12
    jedis.hset("reggie:user:1", "age", "21");
13
    jedis.hset("reggie:user:2", "age", "18");
14
    Map<String, String> map = jedis.hgetAll("reggie:user:1");
15
    System.out.println(map);
16
}

展开收起

Step 4：释放资源#

1
@AfterEach
2
void tearDown() {
3
    if (jedis != null) {
4
        jedis.close();
5
    }
6
}

Jedis 连接池：别频繁创建销毁连接#

直连的性能问题

Jedis 本身是线程不安全的，频繁创建和销毁连接也有性能损耗，推荐使用 Jedis 连接池。

1
public class JedisConnectionFactory {
2

3
    private static JedisPool jedisPool;
4

5
    static {
6
        // 配置连接池
7
        JedisPoolConfig poolConfig = new JedisPoolConfig();
8
        poolConfig.setMaxTotal(8);
9
        poolConfig.setMaxIdle(8);
10
        poolConfig.setMinIdle(0);
11
        poolConfig.setMaxWaitMillis(1000);
12
        // 创建连接池对象，参数：连接池配置、服务端 IP、服务端端口、超时时间、密码
13
        jedisPool = new JedisPool(poolConfig, "101.42.225.160", 6379, 1000, "root");
14
    }
15

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

展开收起

测试类可以改成：

1
@SpringBootTest
2
class RedisTestApplicationTests {
3

4
    private Jedis jedis = JedisConnectionFactory.getJedis();
5

6
    @Test
7
    void testString() {
8
        jedis.set("name", "Kyle");
9
        String name = jedis.get("name");
10
        System.out.println("name = " + name);
11
    }
12

13
    @Test
14
    void testHash() {
15
        jedis.hset("reggie:user:1", "name", "Jack");
16
        jedis.hset("reggie:user:2", "name", "Rose");
17
        jedis.hset("reggie:user:3", "name", "Kyle");
18
        jedis.hset("reggie:user:1", "age", "21");
19
        jedis.hset("reggie:user:2", "age", "18");
20
        jedis.hset("reggie:user:3", "age", "18");
21
        Map<String, String> map = jedis.hgetAll("reggie:user:1");
22
        System.out.println(map);
23
    }
24

25
    @AfterEach
26
    void tearDown() {
27
        if (jedis != null) {
28
            jedis.close();
29
        }
30
    }
31
}

展开收起

Spring Data Redis：项目里更常见的选择#

Spring Data 是 Spring 的数据操作模块，其中对 Redis 的集成模块叫 Spring Data Redis。

官网：https://spring.io/projects/spring-data-redis

主要能力：

整合不同 Redis 客户端（Lettuce 和 Jedis）
提供 RedisTemplate 统一 API
支持 Redis 发布订阅模型
支持 Redis 哨兵和集群
支持基于 Lettuce 的响应式编程
支持 JDK、JSON、字符串、Spring 对象等序列化方式
支持基于 Redis 的 JDKCollection 实现

RedisTemplate 把不同数据类型的操作封装到了不同 API 中：

API	返回值类型	说明
`redisTemplate.opsForValue()`	`ValueOperations`	操作 String 类型数据
`redisTemplate.opsForHash()`	`HashOperations`	操作 Hash 类型数据
`redisTemplate.opsForList()`	`ListOperations`	操作 List 类型数据
`redisTemplate.opsForSet()`	`SetOperations`	操作 Set 类型数据
`redisTemplate.opsForZSet()`	`ZSetOperations`	操作 SortedSet 类型数据
`redisTemplate`	—	通用命令

Step 1：导入依赖#

1
<!--redis依赖-->
2
<dependency>
3
    <groupId>org.springframework.boot</groupId>
4
    <artifactId>spring-boot-starter-data-redis</artifactId>
5
</dependency>
6
<!--common-pool-->
7
<dependency>
8
    <groupId>org.apache.commons</groupId>
9
    <artifactId>commons-pool2</artifactId>
10
</dependency>
11
<!--Jackson依赖-->
12
<dependency>
13
    <groupId>com.fasterxml.jackson.core</groupId>
14
    <artifactId>jackson-databind</artifactId>
15
</dependency>
16
<!--lombok-->
17
<dependency>
18
    <groupId>org.projectlombok</groupId>
19
    <artifactId>lombok</artifactId>
20
    <optional>true</optional>
21
</dependency>
22
<dependency>
23
    <groupId>org.springframework.boot</groupId>
24
    <artifactId>spring-boot-starter-test</artifactId>
25
    <scope>test</scope>
26
</dependency>

展开收起

Step 2：配置 Redis#

1
spring:
2
  redis:
3
    host: 101.42.225.160
4
    port: 6379
5
    password: root
6
    lettuce:
7
      pool:
8
        max-active: 8
9
        max-idle: 8
10
        min-idle: 0
11
        max-wait: 100ms

Step 3：注入 RedisTemplate#

有了 Spring Boot 自动装配，可以直接拿来用：

1
@Autowired
2
private RedisTemplate redisTemplate;

Step 4：写个测试#

1
@Test
2
void stringTest() {
3
    redisTemplate.opsForValue().set("username", "David");
4
    String username = (String) redisTemplate.opsForValue().get("username");
5
    System.out.println(username);
6
}

自定义序列化：默认 JDK 序列化不太好看#

RedisTemplate 可以接收任意 Object 作为值写入 Redis，但默认会用 JDK 序列化，结果可能是这样的：

1
\xAC\xED\x00\x05t\x00\x06\xE5\xBC\xA0\xE4\xB8\x89

JDK 序列化的缺点

可读性差
内存占用较大

可以自定义 RedisTemplate 的序列化方式，比如在 com.blog.config 包下配置：

1
@Configuration
2
public class RedisConfig {
3

4
    @Bean
5
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
6
        // 创建 RedisTemplate 对象
7
        RedisTemplate<String, Object> template = new RedisTemplate<>();
8
        // 设置连接工厂
9
        template.setConnectionFactory(connectionFactory);
10
        // 创建 JSON 序列化工具
11
        GenericJackson2JsonRedisSerializer jsonRedisSerializer =
12
                new GenericJackson2JsonRedisSerializer();
13
        // 设置 Key 的序列化
14
        template.setKeySerializer(RedisSerializer.string());
15
        template.setHashKeySerializer(RedisSerializer.string());
16
        // 设置 Value 的序列化
17
        template.setValueSerializer(jsonRedisSerializer);
18
        template.setHashValueSerializer(jsonRedisSerializer);
19
        // 返回
20
        return template;
21
    }
22
}

展开收起

写个 User 类试试：

1
@Data
2
@AllArgsConstructor
3
@NoArgsConstructor
4
public class User {
5
    private String name;
6
    private Integer age;
7
}

测试方法：

1
@Test
2
void stringTest() {
3
    redisTemplate.opsForValue().set("userdata", new User("张三", 18));
4
}

采用 JSON 序列化后，结果大致如下：

1
{
2
  "@class": "com.blog.entity.User",
3
  "name": "张三",
4
  "age": 18
5
}

可读性提升明显，而且能把 Java 对象自动序列化为 JSON，查询时再自动反序列化回 Java 对象。

关于 @class 字段

它记录了序列化时对应的 class 名称，目的是查询时能自动反序列化。但这会带来额外内存开销，所以还有更省内存的方案。

StringRedisTemplate：手动序列化，内存更清爽#

为了节省内存，可以不使用 JSON 序列化器处理 value，而是统一使用 String 序列化器。这样只能存 String 类型的 key 和 value；需要存 Java 对象时，手动完成序列化和反序列化。

因为序列化和反序列化都由我们自己实现，Spring Data Redis 就不会把 class 信息写进 Redis 了。

Spring Data Redis 提供了 RedisTemplate 的子类 StringRedisTemplate，它的 key 和 value 默认就是 String 序列化：

1
public class StringRedisTemplate extends RedisTemplate<String, String> {
2
    public StringRedisTemplate() {
3
        this.setKeySerializer(RedisSerializer.string());
4
        this.setValueSerializer(RedisSerializer.string());
5
        this.setHashKeySerializer(RedisSerializer.string());
6
        this.setHashValueSerializer(RedisSerializer.string());
7
    }
8
}

这样就可以省去自定义序列化的步骤，直接使用：

1
@Autowired
2
private StringRedisTemplate stringRedisTemplate;
3

4
@Autowired
5
private ObjectMapper mapper;
6

7
@Test
8
void stringTest() throws JsonProcessingException {
9
    // 创建对象
10
    User user = new User("张三", 18);
11
    // 手动序列化
12
    String json = mapper.writeValueAsString(user);
13
    // 写入数据
14
    stringRedisTemplate.opsForValue().set("userdata", json);
15
    // 获取数据
16
    String userdata = stringRedisTemplate.opsForValue().get("userdata");
17
    // 手动反序列化
18
    User readValue = mapper.readValue(userdata, User.class);
19
    System.out.println(readValue);
20
}

展开收起

存入 Redis 中是这样的：

1
{
2
  "name": "张三",
3
  "age": 18
4
}

序列化选型建议

不想写序列化代码、且不介意多存 @class 字段 → 使用 RedisTemplate + GenericJackson2JsonRedisSerializer
追求极致内存、希望 key 清晰易读 → 使用 StringRedisTemplate + 手动 JSON 序列化

收个尾：三个阶段完成跃迁#

回顾一下，这篇笔记其实完成了三个阶段的升级：

认知层：理解 NoSQL 与关系型数据库的核心差异，包括结构化、关联、查询、事务、存储和扩展性。
命令层：掌握 Redis 五大数据结构（String、Hash、List、Set、SortedSet）以及通用命令。
工程层：通过 Jedis 与 Spring Data Redis 两种 Java 客户端，把 Redis 接入实际项目，并掌握序列化选型技巧。

下一步学什么

建议继续深入：持久化机制（RDB/AOF）→ 主从复制 → 哨兵模式 → 分片集群，一步步补齐 Redis 生产知识体系。