[2025-04-11] 添加EngineStarterRedis使用指南
All checks were successful
Publish to Confluence / confluence (push) Successful in 38s

This commit is contained in:
liuxiaohua 2025-04-11 17:02:48 +08:00
parent a9b6c99734
commit eced2ead61

View File

@ -0,0 +1,263 @@
<!-- Space: qifu -->
<!-- Parent: 后端技术&知识&规范 -->
<!-- Parent: 技术方案 -->
<!-- Parent: 基建 -->
<!-- Parent: 00-基础组件 -->
<!-- Title: 2025411-EngineStarterRedis使用指南 -->
<!-- Macro: :anchor\((.*)\):
Template: ac:anchor
Anchor: ${1} -->
<!-- Macro: \!\[.*\]\((.+)\)\<\!\-\- width=(.*) \-\-\>
Template: ac:image
Url: ${1}
Width: ${2} -->
<!-- Macro: \<\!\-\- :toc: \-\-\>
Template: ac:toc
Printable: 'false'
MinLevel: 2
MaxLevel: 4 -->
<!-- Include: 杂项/声明文件.md -->
<!-- :toc: -->
# engine-starter-redis 使用教程
> 基于 Redis 的各种工具封装
> 具体使用可参考 [engine-sample > engine-sample-starter-redis](../engine-sample/engine-sample-starter-redis)
> 版本要求:`$verison >= 1.0.14-SNAPSHOT`
## 功能特性
- [X] `@YmIdempotent`: 基于 Redis 的幂等工具
- [X] `@YmRateLimit`: 基于 Redisson 的限流工具
- [X] `@Lock4j`: 基于 Lock4j 的分布式锁工具
- [X] 旧包中的 `@DistributedMultiLock` 慢慢迁移到新注解
- [X] TODO 旧包中的 `@DistributedMultiLock` 需要实现 `@Lock4jMulti`
- [X] `@Cacheable`: 基于 Redis 的 SpringCache 集成
- [X] 扩展 key支持 key 中自定义时间 `abc#1000`
- [X] `YmRedisClient`: Redis 操作工具类,基于 `StringRedisTemplate`
- [X] `YmCacheClient`: Redis 缓存操作类
- [X] `YmIdempotentManager`: 幂等管理类
- [X] `YmRateLimitManager`: 限流管理类
- [X] `YmRedisKeyUtils`: Redis key 构建工具
- [X] `YmRedisLockClient`: 基于 Redisson 的分布式锁工具
- [X] `YmRedisMessageListener`: Redis 消息监听类,实现该类就可以实现消息监听
-------
## 快速使用
### 添加依赖
**注意:** `qifu-saas-parent` 版本需要高于 `1.0.14-SNAPSHOT`
```xml
<dependency>
<groupId>com.yuanmeng.engine</groupId>
<artifactId>engine-starter-redis</artifactId>
</dependency>
```
### 使用工具
除了 spring-cache 和 RedisMessageListener 默认关闭之外,别的功能都是默认开启的,开箱即用
#### 幂等工具使用
```java
public class Usage {
// 生成token请使用idempotentManager.token("token");
@YmIdempotent(key = "#token", type = YmIdempotentType.TOKEN)
public String tokenTest(String token) {
log.info("tokenTest:{}", token);
return "success";
}
}
```
#### 限流工具使用
```java
public class Usage {
@YmRateLimit(key = "#id", timeUnit = RateIntervalUnit.HOURS, count = 5)
public String rateLimitHour(String id) {
log.info("rateLimitHour: {}", id);
return "success";
}
}
```
#### 分布式锁工具使用
```java
public class Usage {
@Autowired
private LockTemplate lockTemplate;
@Lock4j(name = "lock", keys = "#key", acquireTimeout = 1000)
public String lockAcquireFail(String key) throws InterruptedException {
log.info("lockAcquireFail: {}", key);
Thread.sleep(3000);
return "success";
}
// 多锁模式一
@Lock4jMulti(name = "lockMulti", keyList = "#keys")
public String lockMulti(List<String> keys) throws InterruptedException {
log.info("lockMulti: {}", key);
Thread.sleep(3000);
return "success";
}
// 多锁模式二
@Lock4jMulti(
value = {
@Lock4j(name = "lock", keys = "#key"),
@Lock4j(name = "lock", keys = "#key + '_123'")
}
)
public String lockMultiSecond(String key) throws InterruptedException {
log.info("lockMultiSecond: {}", key);
Thread.sleep(3000);
return "success";
}
public String lockTemplate(String key) throws InterruptedException {
LockInfo lock = lockTemplate.lock(key);
if (lock == null) {
throw new RuntimeException("lock fail");
}
try {
log.info("lockTemplate: {}", key);
Thread.sleep(2000);
} finally {
lockTemplate.releaseLock(lock);
}
return "success";
}
}
```
#### 缓存工具使用
##### 开启Redis缓存
```yaml
yuanmeng:
redis:
cache-manager:
enable: true
```
##### 使用缓存工具
```java
public class Usage {
@Cacheable(cacheNames = "cache:cacheByUser", key = "#user.id + '#' + #expires")
public User cacheByIdWithExpires(User user, Integer expires) throws InterruptedException {
Thread.sleep(5000);
log.info("执行了cacheByIdWithExpires方法: {}, expires = {}", user.getId(), expires);
return user;
}
}
```
#### RedisMessageListener工具使用
##### 开启Redis消息
```yaml
yuanmeng:
redis:
redis-message-listener:
enable: true
```
##### 使用消息工具
```java
@Slf4j
@Component
public class RedisMessageListenerUsage extends YmRedisMessageListener {
public static final String TOPIC = "test_topic";
@Override
public String topic() {
return TOPIC;
}
@Override
public boolean enable() {
return true;
}
@Override
protected void onMessage(YmPublishWrapper messageBody, Message message, byte[] pattern) {
log.info("接收消息: {}", JSONObject.toJSONString(messageBody));
log.info("接收消息体:{}", JSONObject.toJSONString(messageBody.getData()));
log.info("接收消息体类型:{}", JSONObject.toJSONString(messageBody.getData().getClass().getName()));
log.info("接收消息Pattern{}", new String(pattern));
}
}
```
------
## 完整默认配置文件
```yaml
yuanmeng:
redis:
# 开启 engine-redis-starter
enable: true
# 开启全局默认前缀
enable-prefix: false
# 全局默认前缀
prefix: sample
# 开启 YmRedisClient 工具类
enable-redis-client: true
# Redisson 相关配置
redisson:
enable: true
enable-codec: true
enable-prefix: false
prefix: sample_redisson
# RedisMessageListener 相关配置
redis-message-listener:
enable: false
core-pool-size: 5
max-pool-size: 10
queue-capacity: 1000
listeners:
# - com.yuanmeng.sample.starter.redis.message.RedisMessageListenerUsage
# Spring Redis 缓存配置
cache-manager:
enable: false
default-cache-seconds: 3600
default-cache-null-seconds: 600
cache-seconds-map:
# '[cache:simpleDefaultExpires]': 5000
cache-null-seconds-map:
# '[cacheNull:simpleDefaultExpires]': 1200
# 幂等配置
idempotent:
enable: true
enable-prefix: true
prefix: idempotent
# 限流配置
rate-limit:
enable: true
enable-prefix: true
prefix: rate_limit
# Lock4j Redisson 分布式锁配置
lock4j-redisson:
enable: false
```