SpringBoot + Mybatis Plus 整合 Redis

---

Redis 在用户管理系统中的典型应用场景

联合你的用户增编削查接口，以下是 Redis 的实用场景和具体实现方案：
场景作用实现方案用户信息缓存减少数据库压力，加速查询响应使用 Spring Cache + Redis 注解缓存登录 Token 存储分布式 Session 或 JWT Token 管理将 Token 与用户信息绑定，设置逾期时间接口限流防止恶意刷接口基于 Redis 计数器实现滑动窗口限流重复提交拦截防止用户重复提交表单用 Redis 存储哀求唯一标识，设置短期逾期热点数据预加载提前缓存高频访问数据定时任务 + Redis 存储

---

Mac M1 安装 Redis 详细步骤

1. 通过 Homebrew 安装 Redis

1. # 安装 Homebrew（如果尚未安装）
2. /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
4. # 安装 Redis
5. brew install redis

复制代码

2. 启动 Redis 服务

1. # 前台启动（测试用，Ctrl+C 退出）
2. redis-server
4. # 后台启动（推荐）
5. brew services start redis

复制代码

3. 验证安装

1. # 连接 Redis 客户端
2. redis-cli ping  # 应返回 "PONG"

复制代码

---

Spring Boot 3 整合 Redis

1. 添加依赖

在 pom.xml 中：

1.                 <!-- Spring Cache 核心依赖 -->
2.         <dependency>
3.             <groupId>org.springframework.boot</groupId>
4.             <artifactId>spring-boot-starter-cache</artifactId>
5.         </dependency>
7.         <!-- Redis 驱动 -->
8.         <dependency>
9.             <groupId>org.springframework.boot</groupId>
10.             <artifactId>spring-boot-starter-data-redis</artifactId>
11.         </dependency>
12.         <dependency>
13.             <groupId>com.fasterxml.jackson.core</groupId>
14.             <artifactId>jackson-databind</artifactId>
15.         </dependency>

复制代码

2. 配置 Redis 毗连

application.yml：

1. spring:
2.   data:
3.     redis:
4.       host: localhost
5.       port: 6379
6.       # password: your-password  # 如果设置了密码
7.       lettuce:
8.         pool:
9.           max-active: 8
10.           max-idle: 8

复制代码

3. 示例

配置类

1. package com.example.spring_demo01.config;
3. import org.springframework.cache.CacheManager;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
6. import org.springframework.data.redis.cache.RedisCacheConfiguration;
7. import org.springframework.data.redis.cache.RedisCacheManager;
8. import org.springframework.data.redis.connection.RedisConnectionFactory;
9. import org.springframework.data.redis.core.RedisTemplate;
10. import org.springframework.data.redis.serializer.*;
12. import java.time.Duration;
14. @Configuration
15. public class RedisConfig {
17.     // 配置 RedisTemplate
18.     @Bean
19.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
20.         RedisTemplate<String, Object> template = new RedisTemplate<>();
21.         template.setConnectionFactory(factory);
23.         // Key 序列化
24.         template.setKeySerializer(new StringRedisSerializer());
26.         // Value 序列化为 JSON
27.         template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
29.         // Hash 结构序列化
30.         template.setHashKeySerializer(new StringRedisSerializer());
31.         template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
33.         return template;
34.     }
36.     // 配置缓存管理器
37.     @Bean
38.     public CacheManager cacheManager(RedisConnectionFactory factory) {
39.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
40.                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
41.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
42.                 .entryTtl(Duration.ofMinutes(30)); // 设置默认过期时间
44.         return RedisCacheManager.builder(factory)
45.                 .cacheDefaults(config)
46.                 .build();
47.     }
48. }

复制代码

接口限流工具类

1. package com.example.spring_demo01.utils;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.data.redis.core.RedisTemplate;
5. import org.springframework.stereotype.Component;
7. import java.util.UUID;
8. import java.util.concurrent.TimeUnit;
10. @Component
11. public class RateLimiter {
13.     @Autowired
14.     private RedisTemplate<String, Object> redisTemplate;
16.     public boolean allowRequest(String userId) {
17.         String key = "rate_limit:" + userId;
18.         long now = System.currentTimeMillis();
19.         long windowMs = 60_000; // 1 分钟
21.         // 移除窗口外的请求记录
22.         redisTemplate.opsForZSet().removeRangeByScore(key, 0, now - windowMs);
24.         // 统计当前窗口内请求数
25.         Long count = redisTemplate.opsForZSet().zCard(key);
26.         if (count != null && count >= 10) {
27.             return false; // 超过限制
28.         }
30.         // 记录本次请求
31.         redisTemplate.opsForZSet().add(key, UUID.randomUUID().toString(), now);
32.         redisTemplate.expire(key, windowMs, TimeUnit.MILLISECONDS);
33.         return true;
34.     }
35. }

复制代码

实体类

1. package com.example.spring_demo01.entity;
3. import com.baomidou.mybatisplus.annotation.*;
4. import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
5. import lombok.Data;
7. import java.io.Serializable;
9. @Data
10. @TableName("user")
11. @JsonIgnoreProperties(ignoreUnknown = true) // 防止 JSON 反序列化问题
12. public class User implements Serializable { // 实现 Serializable
13.     @TableId(type = IdType.AUTO) // 主键自增
14.     private Long id;
15.     private String name;
16.     private Integer age;
17.     private String email;
18. }

复制代码

service层

1. package com.example.spring_demo01.service.impl;
3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
4. import com.example.spring_demo01.entity.User;
5. import com.example.spring_demo01.mapper.UserMapper;
6. import com.example.spring_demo01.service.UserService;
7. import org.springframework.cache.annotation.CacheEvict;
8. import org.springframework.cache.annotation.Cacheable;
9. import org.springframework.stereotype.Service;
11. import java.io.Serializable;
13. @Service
14. public class UserServiceImpl
15.         extends ServiceImpl<UserMapper, User>
16.         implements UserService {
17.     // 对 MyBatis Plus 的 getById 方法添加缓存
18.     @Cacheable(value = "user", key = "#id")
19.     @Override
20.     public User getById(Serializable id) {
21.         return super.getById(id);
22.     }
24.     // 更新时清除缓存
25.     @CacheEvict(value = "user", key = "#entity.id")
26.     @Override
27.     public boolean updateById(User entity) {
28.         return super.updateById(entity);
29.     }
31.     // 删除时清除缓存
32.     @CacheEvict(value = "user", key = "#id")
33.     @Override
34.     public boolean removeById(Serializable id) {
35.         return super.removeById(id);
36.     }
37. }

复制代码

controller层

1. package com.example.spring_demo01.controller;
3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
5. import com.example.spring_demo01.annotation.AdminOnly;
6. import com.example.spring_demo01.entity.User;
7. import com.example.spring_demo01.service.UserService;
8. import com.example.spring_demo01.utils.RateLimiter;
9. import lombok.extern.slf4j.Slf4j;
10. import org.springframework.beans.factory.annotation.Autowired;
11. import org.springframework.data.redis.core.RedisTemplate;
12. import org.springframework.web.bind.annotation.*;
14. import java.time.Duration;
15. import java.util.List;
16. import java.util.UUID;
18. @Slf4j
19. @RestController
20. @RequestMapping("/user")
21. public class UserController {
23.     @Autowired
24.     private UserService userService;
26.     @Autowired
27.     private RedisTemplate<String, Object> redisTemplate;
29.     @Autowired
30.     private RateLimiter rateLimiter;
33.     // ------------------------------ 增 ------------------------------
35.     @PostMapping
36.     public String addUser(@RequestBody User user, @RequestHeader String clientId) {
37.         String key = "SUBMIT_LOCK:" + clientId + ":" + user.hashCode();
39.         // 10秒内不允许重复提交
40.         Boolean success = redisTemplate.opsForValue()
41.                 .setIfAbsent(key, "", Duration.ofSeconds(10));
43.         if (Boolean.FALSE.equals(success)) {
44.             throw new RuntimeException("请勿重复提交");
45.         }
47.         userService.save(user);
48.         return "新增成功";
49.     }
51.     // ------------------------------ 删 ------------------------------
52.     @DeleteMapping("/{id}")
53.     public String deleteUser(@PathVariable Long id) {
54.         userService.removeById(id);
55.         return "删除成功";
56.     }
58.     @DeleteMapping("/batch")
59.     public String deleteBatch(@RequestBody List<Long> ids) {
60.         userService.removeByIds(ids);
61.         return "批量删除成功";
62.     }
64.     // ------------------------------ 改 ------------------------------
65.     @PutMapping
66.     public String updateUser(@RequestBody User user) {
67.         userService.updateById(user);
68.         return "更新成功";
69.     }
71.     // ------------------------------ 查 ------------------------------
72.     @GetMapping("/{id}")
73.     @AdminOnly
74.     public User getUserById(@PathVariable Long id) {
75.         return userService.getById(id);
76.     }
78.     @GetMapping("/list")
79.     public List<User> listUsers(
80.             @RequestParam(required = false) String name,
81.             @RequestParam(required = false) Integer age) {
82.         QueryWrapper<User> wrapper = new QueryWrapper<>();
83.         if (name != null) {
84.             wrapper.like("name", name); // 模糊查询姓名
85.         }
86.         if (age != null) {
87.             wrapper.eq("age", age);     // 精确查询年龄
88.         }
89.         return userService.list(wrapper);
90.     }
91.    
92.     @GetMapping("/page")
93.     public Page<User> pageUsers(
94.             @RequestParam(defaultValue = "1") Integer pageNum,
95.             @RequestParam(defaultValue = "10") Integer pageSize,
96.             @RequestHeader(value = "Authorization") String token) {
98.         // 从 Token 中获取用户ID
99.         log.info("token:{}", token);
100.         log.info("User:{}", redisTemplate.opsForValue().get(token.split(" ")[1]));
101.         User user = (User) redisTemplate.opsForValue().get(token.split(" ")[1]);
102.         if (user == null) throw new RuntimeException("未登录");
104.         // 限流校验
105.         if (!rateLimiter.allowRequest("PAGE_" + user.getId())) {
106.             throw new RuntimeException("请求过于频繁");
107.         }
109.         return userService.page(new Page<>(pageNum, pageSize));
110.     }
112.     // ------------------------------ other ------------------------------
113.     @GetMapping("/error")
114.     public String getError() {
115.         throw new RuntimeException();
116.     }
118.     @PostMapping("/login")
119.     public String login(@RequestBody User user) {
120.         log.info("login user:{}", user);
121.         // 验证用户逻辑（示例简化）
122.         User dbUser = userService.getOne(new QueryWrapper<User>()
123.                 .eq("id", user.getId())
124.                 .eq("name", user.getName()));
126.         if (dbUser == null) {
127.             throw new RuntimeException("登录失败");
128.         }
130.         // 生成 Token 并存储
131.         String token = "TOKEN_" + UUID.randomUUID();
132.         redisTemplate.opsForValue().set(
133.                 token,
134.                 dbUser,
135.                 Duration.ofMinutes(30)
136.         );
137.         return token;
138.     }
139. }

复制代码

在启动类添加注解：

1. package com.example.spring_demo01;
3. import org.mybatis.spring.annotation.MapperScan;
4. import org.springframework.boot.SpringApplication;
5. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. import org.springframework.boot.web.servlet.ServletComponentScan;
7. import org.springframework.cache.annotation.EnableCaching;
9. @SpringBootApplication
10. @MapperScan("com.example.spring_demo01.mapper")
11. @ServletComponentScan // 启用 Servlet 组件扫描（如 Filter、Servlet）
12. @EnableCaching // 启动缓存，Redis使用
13. public class SpringDemo01Application {
15.     public static void main(String[] args) {
16.         SpringApplication.run(SpringDemo01Application.class, args);
17.     }
19. }

复制代码

---

常见问题排查

Q1: 毗连 Redis 超时

• 检查服务状态：运行 redis-cli ping 确认 Redis 是否正常运行
  
• 查看端口占用：lsof -i :6379
  
• 关闭防火墙：sudo ufw allow 6379
  

Q2: Spring Boot 无法注入 RedisTemplate

• 确认配置类：添加 @EnableCaching 和 @Configuration
  
• 检查序列化器：显式配置序列化方式避免 ClassCastException
  1. @Configuration
  2. public class RedisConfig {
  3.     @Bean
  4.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  5.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  6.         template.setConnectionFactory(factory);
  7.         template.setKeySerializer(new StringRedisSerializer());
  8.         template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
  9.         return template;
  10.     }
  11. }

  复制代码

---

总结

通过 Redis 你可以为项目快速实现：

• 高性能缓存层 - 低落数据库负载
  
• 分布式会话管理 - 支持横向扩展
  
• 精致化流量控制 - 保障系统稳定性
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。