mirror of
https://github.com/zhenxun-org/zhenxun_bot.git
synced 2026-10-07 21:00:21 +08:00
refactor: extract is_ban_cached method to BanConsole
This commit is contained in:
HibiKier
@@ -1,249 +0,0 @@
|
||||
# 权限检查系统 - 缓存优化指南
|
||||
|
||||
## DataAccess 缓存机制说明
|
||||
|
||||
### 已实现的缓存功能
|
||||
|
||||
`DataAccess` 类已经实现了完整的 Redis 缓存机制，包括：
|
||||
|
||||
1. **自动缓存查询结果**
|
||||
```python
|
||||
# 第一次查询：从数据库获取并缓存
|
||||
plugin = await plugin_dao.safe_get_or_none(module="example")
|
||||
|
||||
# 后续查询：直接从缓存获取（如果缓存未过期）
|
||||
plugin = await plugin_dao.safe_get_or_none(module="example")
|
||||
```
|
||||
|
||||
2. **空结果缓存（5分钟TTL）**
|
||||
```python
|
||||
# 查询不存在的记录时，会缓存空结果标记
|
||||
# 避免频繁查询数据库确认记录不存在
|
||||
user = await user_dao.safe_get_or_none(user_id="nonexistent")
|
||||
# 5分钟内再次查询相同记录，直接从缓存返回 None
|
||||
```
|
||||
|
||||
3. **缓存统计**
|
||||
```python
|
||||
from zhenxun.services.data_access import DataAccess
|
||||
|
||||
# 获取缓存统计信息
|
||||
stats = DataAccess.get_cache_stats()
|
||||
# 返回格式：
|
||||
# [
|
||||
# {
|
||||
# "cache_type": "GLOBAL_ALL_PLUGINS",
|
||||
# "hits": 1000, # 缓存命中次数
|
||||
# "null_hits": 50, # 空结果缓存命中次数
|
||||
# "misses": 200, # 缓存未命中次数
|
||||
# "hit_rate": "84.00%" # 缓存命中率
|
||||
# },
|
||||
# ...
|
||||
# ]
|
||||
```
|
||||
|
||||
4. **自动缓存失效**
|
||||
- 数据创建、更新、删除时自动清除相关缓存
|
||||
- 支持手动清除：`await dao.clear_cache(**kwargs)`
|
||||
|
||||
## 权限检查中的缓存优化
|
||||
|
||||
### 当前缓存使用情况
|
||||
|
||||
在权限检查系统中，以下数据访问已经自动使用缓存：
|
||||
|
||||
1. **PluginInfo（插件信息）**
|
||||
```python
|
||||
plugin_dao = DataAccess(PluginInfo)
|
||||
plugin = await plugin_dao.safe_get_or_none(module=module)
|
||||
# ✅ 自动缓存，基于 module 字段
|
||||
```
|
||||
|
||||
2. **UserConsole（用户信息）**
|
||||
```python
|
||||
user_dao = DataAccess(UserConsole)
|
||||
user = await user_dao.get_by_func_or_none(
|
||||
UserConsole.get_user, False, user_id=user_id
|
||||
)
|
||||
# ✅ 自动缓存，基于 user_id 字段
|
||||
```
|
||||
|
||||
3. **GroupConsole（群组信息）**
|
||||
```python
|
||||
group_dao = DataAccess(GroupConsole)
|
||||
group = await group_dao.safe_get_or_none(
|
||||
group_id=group_id, channel_id__isnull=True
|
||||
)
|
||||
# ✅ 自动缓存，基于 group_id 字段
|
||||
```
|
||||
|
||||
4. **BanConsole（ban记录）**
|
||||
```python
|
||||
ban_dao = DataAccess(BanConsole)
|
||||
ban = await ban_dao.safe_get_or_none(
|
||||
user_id=user_id, group_id=group_id
|
||||
)
|
||||
# ✅ 自动缓存，基于 user_id 和 group_id
|
||||
```
|
||||
|
||||
5. **BotConsole（Bot信息）**
|
||||
```python
|
||||
bot_dao = DataAccess(BotConsole)
|
||||
bot = await bot_dao.safe_get_or_none(bot_id=bot_id)
|
||||
# ✅ 自动缓存，基于 bot_id 字段
|
||||
```
|
||||
|
||||
6. **LevelUser（用户权限）**
|
||||
```python
|
||||
level_dao = DataAccess(LevelUser)
|
||||
level = await level_dao.safe_get_or_none(
|
||||
user_id=user_id, group_id=group_id
|
||||
)
|
||||
# ✅ 自动缓存，基于 user_id 和 group_id
|
||||
```
|
||||
|
||||
### 优化建议
|
||||
|
||||
#### 1. 并行获取数据，提高缓存命中率
|
||||
|
||||
**当前实现**：
|
||||
```python
|
||||
# 串行获取，可能错过缓存优势
|
||||
plugin = await plugin_dao.safe_get_or_none(module=module)
|
||||
user = await user_dao.get_by_func_or_none(...)
|
||||
group = await group_dao.safe_get_or_none(...)
|
||||
```
|
||||
|
||||
**优化后**：
|
||||
```python
|
||||
# 并行获取，DataAccess 会自动处理缓存
|
||||
plugin, user, group = await asyncio.gather(
|
||||
plugin_dao.safe_get_or_none(module=module),
|
||||
user_dao.get_by_func_or_none(UserConsole.get_user, False, user_id=user_id),
|
||||
group_dao.safe_get_or_none(group_id=group_id, channel_id__isnull=True)
|
||||
if group_id else asyncio.sleep(0)
|
||||
)
|
||||
```
|
||||
|
||||
#### 2. 提前获取所有需要的数据
|
||||
|
||||
**当前实现**：
|
||||
```python
|
||||
# group 数据在 hooks 执行时才获取
|
||||
# 在 auth 函数中
|
||||
group = None
|
||||
if entity.group_id:
|
||||
group = await group_dao.safe_get_or_none(...)
|
||||
```
|
||||
|
||||
**优化后**：
|
||||
```python
|
||||
# 在获取 plugin 和 user 时，同时获取 group
|
||||
# 统一数据获取，充分利用缓存
|
||||
async def get_all_auth_data(module, user_id, group_id):
|
||||
plugin_dao = DataAccess(PluginInfo)
|
||||
user_dao = DataAccess(UserConsole)
|
||||
group_dao = DataAccess(GroupConsole) if group_id else None
|
||||
|
||||
tasks = [
|
||||
plugin_dao.safe_get_or_none(module=module),
|
||||
user_dao.get_by_func_or_none(UserConsole.get_user, False, user_id=user_id),
|
||||
]
|
||||
if group_id and group_dao:
|
||||
tasks.append(
|
||||
group_dao.safe_get_or_none(group_id=group_id, channel_id__isnull=True)
|
||||
)
|
||||
|
||||
results = await asyncio.gather(*tasks)
|
||||
return results
|
||||
```
|
||||
|
||||
#### 3. 监控缓存效果
|
||||
|
||||
**实现方案**：
|
||||
```python
|
||||
from zhenxun.services.data_access import DataAccess
|
||||
|
||||
async def auth(...):
|
||||
# 记录开始时的缓存统计
|
||||
cache_stats_before = DataAccess.get_cache_stats()
|
||||
|
||||
try:
|
||||
# 执行权限检查
|
||||
...
|
||||
finally:
|
||||
# 记录结束时的缓存统计
|
||||
cache_stats_after = DataAccess.get_cache_stats()
|
||||
|
||||
# 分析缓存效果
|
||||
for before, after in zip(cache_stats_before, cache_stats_after):
|
||||
cache_type = after["cache_type"]
|
||||
hits_diff = after["hits"] - before["hits"]
|
||||
misses_diff = after["misses"] - before["misses"]
|
||||
total = hits_diff + misses_diff
|
||||
|
||||
if total > 0:
|
||||
hit_rate = (hits_diff / total) * 100
|
||||
logger.debug(
|
||||
f"缓存统计 - {cache_type}: "
|
||||
f"命中率={hit_rate:.1f}%, "
|
||||
f"命中={hits_diff}, 未命中={misses_diff}",
|
||||
LOGGER_COMMAND
|
||||
)
|
||||
|
||||
# 如果缓存命中率过低，记录警告
|
||||
if hit_rate < 30:
|
||||
logger.warning(
|
||||
f"缓存命中率过低: {cache_type} = {hit_rate:.1f}%",
|
||||
LOGGER_COMMAND
|
||||
)
|
||||
```
|
||||
|
||||
#### 4. 调整空结果缓存时间
|
||||
|
||||
**根据实际需求调整**：
|
||||
```python
|
||||
from zhenxun.services.data_access import DataAccess
|
||||
|
||||
# 对于频繁查询但可能不存在的记录，可以增加空结果缓存时间
|
||||
# 例如：ban记录查询，如果用户未被ban，可以缓存更长时间
|
||||
DataAccess.set_null_result_ttl(600) # 10分钟
|
||||
|
||||
# 对于需要实时性的数据，可以减少缓存时间
|
||||
# 例如：用户权限查询
|
||||
DataAccess.set_null_result_ttl(60) # 1分钟
|
||||
```
|
||||
|
||||
## 缓存性能优化检查清单
|
||||
|
||||
- [ ] 所有数据访问都通过 `DataAccess`，而不是直接使用模型类
|
||||
- [ ] 并行获取多个数据，而不是串行获取
|
||||
- [ ] 提前获取所有需要的数据，避免在检查过程中重复获取
|
||||
- [ ] 监控缓存命中率，确保缓存效果良好
|
||||
- [ ] 根据实际需求调整空结果缓存时间
|
||||
- [ ] 定期查看缓存统计，优化缓存策略
|
||||
|
||||
## 预期缓存效果
|
||||
|
||||
### 高并发场景下的缓存命中率预期
|
||||
|
||||
- **PluginInfo（插件信息）**：90-95%（插件信息变化不频繁）
|
||||
- **UserConsole（用户信息）**：80-90%（用户信息相对稳定）
|
||||
- **GroupConsole（群组信息）**：85-95%（群组信息变化不频繁）
|
||||
- **BanConsole（ban记录）**：70-85%（ban状态可能变化）
|
||||
- **BotConsole（Bot信息）**：95-99%（Bot信息很少变化）
|
||||
- **LevelUser（用户权限）**：75-85%（权限可能变化）
|
||||
|
||||
### 性能提升预期
|
||||
|
||||
- **缓存命中时**：查询时间从 10-50ms 降低到 1-5ms（减少 80-90%）
|
||||
- **总体性能**：在高并发场景下，总体执行时间减少 30-50%
|
||||
- **数据库压力**：减少数据库查询 40-60%
|
||||
|
||||
## 注意事项
|
||||
|
||||
1. **缓存一致性**：DataAccess 在数据更新时会自动清除缓存，确保一致性
|
||||
2. **缓存失效**：如果需要强制刷新缓存，可以使用 `await dao.clear_cache(**kwargs)`
|
||||
3. **监控缓存**：定期查看缓存统计，确保缓存效果良好
|
||||
4. **空结果缓存**：空结果缓存有助于减少对不存在记录的查询，但需要根据实际需求调整TTL
|
||||
|
||||
@@ -1,373 +0,0 @@
|
||||
# 权限检查系统 - 立即可以实施的改进
|
||||
|
||||
## 当前问题总结
|
||||
|
||||
经过分析，当前权限检查系统存在以下主要问题：
|
||||
|
||||
### 1. 检查执行顺序不合理
|
||||
|
||||
- **问题**：所有检查并行执行，ban 检查应该优先执行
|
||||
- **影响**：用户被 ban 后，其他检查（金币、限制等）仍然会执行，浪费资源
|
||||
- **优先级**：高
|
||||
|
||||
### 2. 缺乏早期退出机制
|
||||
|
||||
- **问题**：即使某个检查失败，其他检查仍会继续执行
|
||||
- **影响**：浪费 CPU 和数据库资源
|
||||
- **优先级**：高
|
||||
|
||||
### 3. 数据获取可以优化
|
||||
|
||||
- **问题**：group 数据在 hooks 执行时才获取，可以提前获取
|
||||
- **影响**：增加总体执行时间
|
||||
- **优先级**：中
|
||||
|
||||
### 4. 充分利用 DataAccess 的 Redis 缓存
|
||||
|
||||
- **现状**：`DataAccess` 已经实现了完整的 Redis 缓存机制（包括空结果缓存 5 分钟）
|
||||
- **问题**：没有充分利用缓存，数据获取顺序不够优化
|
||||
- **影响**：缓存命中率可能不够高，重复查询数据库
|
||||
- **优先级**：高
|
||||
|
||||
## 立即可以实施的改进
|
||||
|
||||
### 改进 1：调整检查顺序，ban 检查优先执行
|
||||
|
||||
**位置**：`auth_checker.py` 第 498-514 行
|
||||
|
||||
**当前代码**：
|
||||
|
||||
```python
|
||||
hook_tasks = [
|
||||
time_hook(auth_ban(...), "auth_ban", hook_times),
|
||||
time_hook(auth_bot(...), "auth_bot", hook_times),
|
||||
# ... 其他检查
|
||||
]
|
||||
await asyncio.gather(*hook_tasks) # 并行执行
|
||||
```
|
||||
|
||||
**改进方案**：
|
||||
|
||||
```python
|
||||
# 1. 先执行关键检查（ban、bot），如果失败立即退出
|
||||
critical_checks = [
|
||||
("auth_ban", lambda: time_hook(auth_ban(...), "auth_ban", hook_times)),
|
||||
("auth_bot", lambda: time_hook(auth_bot(...), "auth_bot", hook_times)),
|
||||
]
|
||||
|
||||
for check_name, check_func in critical_checks:
|
||||
try:
|
||||
await check_func()
|
||||
except SkipPluginException:
|
||||
raise # 立即退出
|
||||
except Exception as e:
|
||||
logger.error(f"{check_name} 检查失败: {e}", LOGGER_COMMAND, session=session)
|
||||
# 关键检查失败，可以选择继续或退出
|
||||
|
||||
# 2. 关键检查通过后，再并行执行其他检查
|
||||
other_checks = [
|
||||
time_hook(auth_group(...), "auth_group", hook_times),
|
||||
time_hook(auth_admin(...), "auth_admin", hook_times),
|
||||
time_hook(auth_plugin(...), "auth_plugin", hook_times),
|
||||
time_hook(auth_limit(...), "auth_limit", hook_times),
|
||||
]
|
||||
await asyncio.gather(*other_checks)
|
||||
```
|
||||
|
||||
### 改进 2：提前获取 group 数据
|
||||
|
||||
**位置**：`auth_checker.py` 第 485-493 行
|
||||
|
||||
**当前代码**：
|
||||
|
||||
```python
|
||||
# 在hooks执行时才获取group
|
||||
group = None
|
||||
if entity.group_id:
|
||||
group_dao = DataAccess(GroupConsole)
|
||||
group = await with_timeout(...)
|
||||
```
|
||||
|
||||
**改进方案**：
|
||||
|
||||
```python
|
||||
# 在获取plugin和user时，同时获取group
|
||||
# 在 get_plugin_and_user 函数中或auth函数开始处
|
||||
group = None
|
||||
if entity.group_id:
|
||||
group_dao = DataAccess(GroupConsole)
|
||||
group_task = group_dao.safe_get_or_none(
|
||||
group_id=entity.group_id, channel_id__isnull=True
|
||||
)
|
||||
# 可以并行获取
|
||||
plugin, user, group = await asyncio.gather(
|
||||
plugin_task, user_task, group_task
|
||||
)
|
||||
```
|
||||
|
||||
### 改进 3：充分利用 DataAccess 的 Redis 缓存机制
|
||||
|
||||
**重要说明**：`DataAccess` 已经实现了完整的 Redis 缓存机制，包括：
|
||||
|
||||
- ✅ 自动缓存查询结果
|
||||
- ✅ 空结果缓存（5 分钟 TTL，避免频繁查询不存在的记录）
|
||||
- ✅ 缓存统计（命中率、命中次数等）
|
||||
- ✅ 自动处理缓存的获取和设置
|
||||
|
||||
**优化策略**：
|
||||
|
||||
#### 3.1 优化数据获取顺序，提高缓存命中率
|
||||
|
||||
**位置**：`auth_checker.py` 的 `get_plugin_and_user` 函数和 `auth` 函数
|
||||
|
||||
**当前问题**：
|
||||
|
||||
- plugin、user、group 数据分别获取，可能错过并行获取的缓存优势
|
||||
- group 数据在 hooks 执行时才获取，应该提前获取
|
||||
|
||||
**改进方案**：
|
||||
|
||||
```python
|
||||
async def get_plugin_user_and_group(
|
||||
module: str, user_id: str, group_id: str | None
|
||||
) -> tuple[PluginInfo, UserConsole, GroupConsole | None]:
|
||||
"""统一获取插件、用户和群组数据（充分利用 DataAccess 缓存）
|
||||
|
||||
注意：DataAccess 会自动使用 Redis 缓存，包括：
|
||||
- 查询结果缓存
|
||||
- 空结果缓存（5分钟）
|
||||
- 缓存统计
|
||||
"""
|
||||
user_dao = DataAccess(UserConsole)
|
||||
plugin_dao = DataAccess(PluginInfo)
|
||||
group_dao = DataAccess(GroupConsole) if group_id else None
|
||||
|
||||
# 并行获取所有数据，DataAccess 会自动处理缓存
|
||||
tasks = [
|
||||
plugin_dao.safe_get_or_none(module=module),
|
||||
user_dao.get_by_func_or_none(
|
||||
UserConsole.get_user, False, user_id=user_id
|
||||
)
|
||||
]
|
||||
|
||||
if group_id and group_dao:
|
||||
tasks.append(
|
||||
group_dao.safe_get_or_none(
|
||||
group_id=group_id, channel_id__isnull=True
|
||||
)
|
||||
)
|
||||
else:
|
||||
tasks.append(asyncio.create_task(asyncio.sleep(0))) # 占位
|
||||
|
||||
try:
|
||||
results = await with_timeout(
|
||||
asyncio.gather(*tasks), name="get_plugin_user_group"
|
||||
)
|
||||
plugin = results[0]
|
||||
user = results[1]
|
||||
group = results[2] if len(results) > 2 and group_id else None
|
||||
|
||||
# 验证数据
|
||||
if not plugin:
|
||||
raise PermissionExemption(f"插件:{module} 数据不存在...")
|
||||
if plugin.plugin_type == PluginType.HIDDEN:
|
||||
raise PermissionExemption(f"插件: {plugin.name}:{plugin.module} 为HIDDEN...")
|
||||
if not user:
|
||||
raise PermissionExemption("用户数据不存在...")
|
||||
|
||||
return plugin, user, group
|
||||
except asyncio.TimeoutError:
|
||||
# 超时时尝试从缓存获取（DataAccess 已经缓存了）
|
||||
logger.warning(
|
||||
f"数据获取超时，尝试从缓存获取，模块: {module}",
|
||||
LOGGER_COMMAND
|
||||
)
|
||||
# DataAccess 的缓存会自动生效，这里只需要重试一次
|
||||
plugin = await plugin_dao.safe_get_or_none(module=module)
|
||||
user = await user_dao.get_by_func_or_none(
|
||||
UserConsole.get_user, False, user_id=user_id
|
||||
)
|
||||
group = None
|
||||
if group_id and group_dao:
|
||||
group = await group_dao.safe_get_or_none(
|
||||
group_id=group_id, channel_id__isnull=True
|
||||
)
|
||||
|
||||
if not plugin or not user:
|
||||
raise PermissionExemption("获取数据失败，请稍后再试...")
|
||||
|
||||
return plugin, user, group
|
||||
```
|
||||
|
||||
#### 3.2 监控缓存命中率
|
||||
|
||||
**位置**：在权限检查中添加缓存统计监控
|
||||
|
||||
**实现方案**：
|
||||
|
||||
```python
|
||||
from zhenxun.services.data_access import DataAccess
|
||||
|
||||
# 在 auth 函数开始和结束时记录缓存统计
|
||||
async def auth(...):
|
||||
# 记录开始时的缓存统计
|
||||
cache_stats_before = DataAccess.get_cache_stats()
|
||||
|
||||
try:
|
||||
# ... 执行权限检查 ...
|
||||
pass
|
||||
finally:
|
||||
# 记录结束时的缓存统计
|
||||
cache_stats_after = DataAccess.get_cache_stats()
|
||||
|
||||
# 计算本次检查的缓存命中情况
|
||||
for before, after in zip(cache_stats_before, cache_stats_after):
|
||||
hits_diff = after["hits"] - before["hits"]
|
||||
misses_diff = after["misses"] - before["misses"]
|
||||
total = hits_diff + misses_diff
|
||||
if total > 0:
|
||||
hit_rate = (hits_diff / total) * 100
|
||||
if hit_rate < 50: # 缓存命中率低于50%时记录警告
|
||||
logger.warning(
|
||||
f"缓存命中率较低: {after['cache_type']} = {hit_rate:.1f}%",
|
||||
LOGGER_COMMAND
|
||||
)
|
||||
```
|
||||
|
||||
#### 3.3 优化检查函数中的数据访问
|
||||
|
||||
**说明**：各个检查函数（auth_ban、auth_bot 等）中使用的 `DataAccess` 已经自动缓存，无需额外处理。
|
||||
|
||||
**建议**：
|
||||
|
||||
- 确保所有数据访问都通过 `DataAccess`，而不是直接使用模型类
|
||||
- 对于频繁查询的数据（如 ban 记录），`DataAccess` 会自动缓存
|
||||
- 空结果也会被缓存 5 分钟，避免频繁查询不存在的记录
|
||||
|
||||
### 改进 4：统一错误处理策略
|
||||
|
||||
**位置**：各个检查函数
|
||||
|
||||
**当前问题**：
|
||||
|
||||
- `auth_ban` 超时时不阻塞
|
||||
- `auth_bot` 超时时不阻塞
|
||||
- `auth_limit` 超时时不阻塞
|
||||
- 但 `get_plugin_and_user` 超时时会抛出异常
|
||||
|
||||
**改进方案**：
|
||||
|
||||
```python
|
||||
# 定义统一的超时处理策略
|
||||
class TimeoutStrategy:
|
||||
FAIL_FAST = "fail_fast" # 超时立即失败
|
||||
CONTINUE = "continue" # 超时继续执行
|
||||
CACHE_FALLBACK = "cache_fallback" # 超时使用缓存
|
||||
|
||||
# 根据检查的重要性设置策略
|
||||
CHECK_TIMEOUT_STRATEGY = {
|
||||
"auth_ban": TimeoutStrategy.FAIL_FAST, # 关键检查，超时失败
|
||||
"auth_bot": TimeoutStrategy.FAIL_FAST, # 关键检查，超时失败
|
||||
"auth_group": TimeoutStrategy.CONTINUE, # 非关键，超时继续
|
||||
"auth_limit": TimeoutStrategy.CONTINUE, # 非关键，超时继续
|
||||
"get_plugin_and_user": TimeoutStrategy.CACHE_FALLBACK, # 使用缓存降级
|
||||
}
|
||||
```
|
||||
|
||||
## 实施优先级
|
||||
|
||||
### 高优先级（立即实施）
|
||||
|
||||
1. ✅ **调整检查顺序**：ban 检查优先执行
|
||||
- 风险：低
|
||||
- 收益：高
|
||||
- 工作量：小（1-2 小时）
|
||||
|
||||
### 中优先级（本周实施）
|
||||
|
||||
2. ✅ **提前获取 group 数据，统一数据获取**
|
||||
|
||||
- 风险：低
|
||||
- 收益：高（充分利用 DataAccess 缓存）
|
||||
- 工作量：小（1-2 小时）
|
||||
|
||||
3. ✅ **优化数据获取顺序，提高缓存命中率**
|
||||
|
||||
- 风险：低（DataAccess 已实现缓存）
|
||||
- 收益：高（减少数据库查询）
|
||||
- 工作量：小（1 小时）
|
||||
|
||||
4. ✅ **添加缓存统计监控**
|
||||
- 风险：低
|
||||
- 收益：中（可以监控缓存效果）
|
||||
- 工作量：小（30 分钟）
|
||||
|
||||
### 低优先级（后续优化）
|
||||
|
||||
4. ⏳ **统一错误处理策略**
|
||||
- 风险：中（可能影响现有逻辑）
|
||||
- 收益：中
|
||||
- 工作量：中（3-4 小时）
|
||||
|
||||
## 代码示例：改进后的 auth 函数结构
|
||||
|
||||
```python
|
||||
async def auth(...):
|
||||
# 1. 获取所有需要的数据（并行）
|
||||
plugin, user, group = await gather_all_data(...)
|
||||
|
||||
# 2. 关键检查（串行，失败立即退出）
|
||||
await critical_checks(plugin, user, group, ...)
|
||||
|
||||
# 3. 其他检查（并行）
|
||||
await other_checks(plugin, user, group, ...)
|
||||
|
||||
# 4. 金币检查（最后执行，超时不影响）
|
||||
cost_gold = await check_cost(user, plugin, ...)
|
||||
```
|
||||
|
||||
## 注意事项
|
||||
|
||||
1. **向后兼容**：确保改进不影响现有功能
|
||||
2. **充分测试**：特别是缓存相关的改进
|
||||
3. **监控指标**：记录改进前后的性能指标
|
||||
4. **逐步实施**：先实施低风险改进，再实施高风险改进
|
||||
|
||||
## 预期效果
|
||||
|
||||
- **性能提升**：总体执行时间减少 20-30%
|
||||
- **资源节省**：减少不必要的检查执行 30-50%
|
||||
- **缓存优化**：充分利用 DataAccess 的 Redis 缓存，缓存命中率提升 40-60%
|
||||
- **数据库压力**：减少数据库查询 30-50%（通过缓存）
|
||||
- **用户体验**：响应速度提升，特别是在高并发场景下
|
||||
|
||||
## 关于 DataAccess 缓存的说明
|
||||
|
||||
### DataAccess 已实现的缓存机制
|
||||
|
||||
1. **自动缓存查询结果**
|
||||
|
||||
- 所有通过 `DataAccess.safe_get_or_none()` 等方法的查询结果都会自动缓存
|
||||
- 缓存键基于模型的主键字段（如 `user_id`、`module` 等）
|
||||
|
||||
2. **空结果缓存**
|
||||
|
||||
- 查询结果为 `None` 时，会缓存一个特殊标记（`_NULL_RESULT`）
|
||||
- 默认 TTL 为 5 分钟，避免频繁查询不存在的记录
|
||||
- 可通过 `DataAccess.set_null_result_ttl()` 调整
|
||||
|
||||
3. **缓存统计**
|
||||
|
||||
- 自动统计缓存命中率、命中次数、未命中次数等
|
||||
- 可通过 `DataAccess.get_cache_stats()` 获取统计信息
|
||||
|
||||
4. **缓存失效**
|
||||
- 数据更新、创建、删除时自动清除相关缓存
|
||||
- 支持手动清除：`DataAccess.clear_cache(**kwargs)`
|
||||
|
||||
### 优化建议
|
||||
|
||||
1. **统一使用 DataAccess**：确保所有数据访问都通过 `DataAccess`，而不是直接使用模型类
|
||||
2. **并行获取数据**：利用 `asyncio.gather()` 并行获取多个数据，提高缓存命中率
|
||||
3. **监控缓存效果**：定期查看 `DataAccess.get_cache_stats()`，了解缓存命中率
|
||||
4. **调整空结果 TTL**：根据实际需求调整 `DataAccess.set_null_result_ttl()`，平衡缓存效果和实时性
|
||||
@@ -1,234 +0,0 @@
|
||||
# 权限检查系统优化方案
|
||||
|
||||
## 当前设计分析
|
||||
|
||||
### 优点
|
||||
1. ✅ 模块化设计，每个检查独立
|
||||
2. ✅ 并行执行检查，提高效率
|
||||
3. ✅ 有超时控制和重试机制
|
||||
4. ✅ 有缓存降级策略
|
||||
5. ✅ 有并发控制（信号量）
|
||||
|
||||
### 存在的问题
|
||||
|
||||
#### 1. **缺乏优先级机制**
|
||||
- 所有检查并行执行，没有优先级区分
|
||||
- ban检查应该优先执行，如果用户被ban，其他检查就不需要执行
|
||||
- 浪费计算资源
|
||||
|
||||
#### 2. **缺乏早期退出机制**
|
||||
- 即使某个检查已经失败，其他检查仍然会继续执行
|
||||
- 例如：用户被ban了，但金币检查、限制检查等仍然会执行
|
||||
|
||||
#### 3. **数据获取分散**
|
||||
- 每个检查函数可能都需要查询数据库
|
||||
- 缺乏统一的数据上下文管理
|
||||
- 可能导致重复查询
|
||||
|
||||
#### 4. **错误处理不一致**
|
||||
- 有些检查超时时抛出异常
|
||||
- 有些检查超时时只是记录日志继续执行
|
||||
- 缺乏统一的错误处理策略
|
||||
|
||||
#### 5. **缺乏检查结果缓存**
|
||||
- 对于相同的请求（相同的user_id, group_id, plugin），可能会重复执行相同的检查
|
||||
- ban检查、bot检查等结果可以缓存一段时间
|
||||
|
||||
## 优化方案
|
||||
|
||||
### 方案1：优先级分层检查（推荐）
|
||||
|
||||
#### 核心思想
|
||||
将检查分为多个优先级阶段，高优先级检查失败时立即退出，不执行后续检查。
|
||||
|
||||
#### 检查优先级划分
|
||||
|
||||
```
|
||||
阶段1（CRITICAL - 关键检查）：
|
||||
- auth_ban: 用户/群组ban检查
|
||||
- auth_bot: Bot状态检查
|
||||
→ 如果失败，立即退出
|
||||
|
||||
阶段2（HIGH - 高优先级）：
|
||||
- auth_plugin: 插件状态检查
|
||||
- auth_group: 群组状态检查
|
||||
→ 并行执行，任一失败则退出
|
||||
|
||||
阶段3（MEDIUM - 中等优先级）：
|
||||
- auth_admin: 管理员权限检查
|
||||
- auth_limit: 限制检查
|
||||
→ 并行执行，任一失败则退出
|
||||
|
||||
阶段4（LOW - 低优先级）：
|
||||
- auth_cost: 金币检查
|
||||
→ 超时不影响其他检查
|
||||
```
|
||||
|
||||
#### 实现要点
|
||||
|
||||
1. **统一数据上下文**
|
||||
```python
|
||||
@dataclass
|
||||
class AuthContext:
|
||||
"""统一管理所有需要的数据"""
|
||||
plugin: PluginInfo
|
||||
user: UserConsole
|
||||
group: GroupConsole | None
|
||||
bot_id: str
|
||||
entity: EntityIDs
|
||||
# ... 其他数据
|
||||
```
|
||||
|
||||
2. **早期退出机制**
|
||||
```python
|
||||
# 阶段1检查
|
||||
for check in critical_checks:
|
||||
result = await execute_check(check)
|
||||
if not result.success:
|
||||
raise result.error # 立即退出，不执行后续检查
|
||||
```
|
||||
|
||||
3. **检查结果缓存**
|
||||
```python
|
||||
# 对ban、bot等检查结果进行缓存
|
||||
cache_key = f"ban:{user_id}:{group_id}:{module}"
|
||||
if cached_result := get_cached_result(cache_key):
|
||||
return cached_result
|
||||
```
|
||||
|
||||
### 方案2：责任链模式
|
||||
|
||||
#### 核心思想
|
||||
使用责任链模式，按优先级顺序执行检查，任一检查失败则中断链。
|
||||
|
||||
#### 优点
|
||||
- 清晰的检查顺序
|
||||
- 易于添加新的检查
|
||||
- 支持动态调整检查顺序
|
||||
|
||||
#### 缺点
|
||||
- 无法充分利用并行执行的优势
|
||||
- 可能增加总体执行时间
|
||||
|
||||
### 方案3：混合模式（最佳实践）
|
||||
|
||||
#### 核心思想
|
||||
结合优先级和并行执行：
|
||||
- 关键检查（ban、bot）串行执行，失败立即退出
|
||||
- 同优先级检查并行执行
|
||||
- 不同优先级按顺序执行
|
||||
|
||||
## 具体优化建议
|
||||
|
||||
### 1. 立即实施的优化（低风险）
|
||||
|
||||
#### a) 调整检查顺序
|
||||
```python
|
||||
# 在 auth_checker.py 中调整检查顺序
|
||||
# 1. 先执行ban检查（如果失败，立即退出）
|
||||
# 2. 再执行其他检查
|
||||
```
|
||||
|
||||
#### b) 统一数据获取
|
||||
```python
|
||||
# 在auth函数开始处，统一获取所有需要的数据
|
||||
plugin, user, group = await gather_all_data(...)
|
||||
# 然后传递给各个检查函数
|
||||
```
|
||||
|
||||
#### c) 添加检查结果缓存
|
||||
```python
|
||||
# 对ban检查结果缓存30秒
|
||||
@lru_cache(maxsize=1000, ttl=30)
|
||||
async def check_ban_cached(user_id, group_id):
|
||||
return await is_ban(user_id, group_id)
|
||||
```
|
||||
|
||||
### 2. 中期优化（需要重构）
|
||||
|
||||
#### a) 实现优先级机制
|
||||
- 将检查函数注册到优先级系统
|
||||
- 按优先级顺序执行
|
||||
- 高优先级失败时立即退出
|
||||
|
||||
#### b) 统一错误处理
|
||||
- 定义统一的检查结果类型
|
||||
- 所有检查返回统一格式的结果
|
||||
- 统一的超时处理策略
|
||||
|
||||
### 3. 长期优化（架构级改进）
|
||||
|
||||
#### a) 检查结果持久化
|
||||
- 将检查结果存储到Redis
|
||||
- 支持分布式缓存
|
||||
- 减少数据库查询
|
||||
|
||||
#### b) 异步检查队列
|
||||
- 对于非关键检查，可以异步执行
|
||||
- 使用消息队列处理检查任务
|
||||
- 提高响应速度
|
||||
|
||||
## 性能提升预期
|
||||
|
||||
### 当前性能
|
||||
- 所有检查并行执行：~200-500ms
|
||||
- 高并发时可能超时
|
||||
|
||||
### 优化后预期
|
||||
- 关键检查优先：~50-100ms（如果失败）
|
||||
- 完整检查：~150-300ms
|
||||
- 缓存命中：~10-20ms
|
||||
|
||||
### 资源节省
|
||||
- 减少不必要的检查执行：~30-50%
|
||||
- 减少数据库查询：~20-30%
|
||||
- 提高并发处理能力：~40-60%
|
||||
|
||||
## 实施步骤
|
||||
|
||||
### 阶段1：准备（1-2天）
|
||||
1. 分析当前检查函数的依赖关系
|
||||
2. 确定优先级划分
|
||||
3. 设计统一的数据上下文
|
||||
|
||||
### 阶段2：实现（3-5天）
|
||||
1. 实现优先级机制
|
||||
2. 实现早期退出机制
|
||||
3. 实现检查结果缓存
|
||||
4. 统一错误处理
|
||||
|
||||
### 阶段3：测试（2-3天）
|
||||
1. 单元测试
|
||||
2. 集成测试
|
||||
3. 性能测试
|
||||
4. 压力测试
|
||||
|
||||
### 阶段4：部署（1天）
|
||||
1. 灰度发布
|
||||
2. 监控性能指标
|
||||
3. 逐步全量
|
||||
|
||||
## 风险评估
|
||||
|
||||
### 低风险
|
||||
- 调整检查顺序
|
||||
- 添加缓存
|
||||
- 统一数据获取
|
||||
|
||||
### 中风险
|
||||
- 实现优先级机制（需要充分测试）
|
||||
- 早期退出机制（可能影响某些边界情况）
|
||||
|
||||
### 高风险
|
||||
- 架构级重构（需要完整的测试覆盖）
|
||||
|
||||
## 建议
|
||||
|
||||
1. **先实施低风险优化**：立即调整检查顺序，添加缓存
|
||||
2. **逐步实施中风险优化**：实现优先级机制，充分测试
|
||||
3. **长期规划高风险优化**：根据实际需求决定是否进行架构级重构
|
||||
|
||||
## 参考实现
|
||||
|
||||
详见 `auth_checker_optimized.py`（设计示例，仅供参考）
|
||||
|
||||
@@ -9,11 +9,9 @@ from nonebot_plugin_uninfo import Uninfo
|
||||
from zhenxun.configs.config import Config
|
||||
from zhenxun.models.ban_console import BanConsole
|
||||
from zhenxun.models.plugin_info import PluginInfo
|
||||
from zhenxun.services.cache import CacheRoot
|
||||
from zhenxun.services.data_access import DataAccess
|
||||
from zhenxun.services.db_context import DB_TIMEOUT_SECONDS
|
||||
from zhenxun.services.log import logger
|
||||
from zhenxun.utils.enum import CacheType, PluginType
|
||||
from zhenxun.utils.enum import PluginType
|
||||
from zhenxun.utils.utils import EntityIDs, get_entity_ids
|
||||
|
||||
from .config import LOGGER_COMMAND, WARNING_THRESHOLD
|
||||
@@ -164,23 +162,9 @@ async def auth_ban(
|
||||
if entity.user_id in bot.config.superusers:
|
||||
return
|
||||
|
||||
cache_key = f"{entity.user_id}_{entity.group_id}"
|
||||
|
||||
results = await CacheRoot.get(CacheType.BAN, cache_key)
|
||||
results = await BanConsole.is_ban_cached(entity.user_id, entity.group_id)
|
||||
if not results:
|
||||
results = await BanConsole.is_ban(entity.user_id, entity.group_id)
|
||||
await CacheRoot.set(
|
||||
CacheType.BAN,
|
||||
cache_key,
|
||||
results or DataAccess._NULL_RESULT,
|
||||
)
|
||||
else:
|
||||
if results == DataAccess._NULL_RESULT:
|
||||
return
|
||||
tmp_results: list[BanConsole] = []
|
||||
for r in results:
|
||||
tmp_results.append(CacheRoot._deserialize_value(r, BanConsole))
|
||||
results = tmp_results
|
||||
return
|
||||
|
||||
for result in results:
|
||||
if not result.user_id and result.group_id:
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
import asyncio
|
||||
import random
|
||||
|
||||
from arclet.alconna import Args
|
||||
from nonebot import get_driver
|
||||
from nonebot.adapters.onebot.v11 import (
|
||||
Bot,
|
||||
Event,
|
||||
GroupMessageEvent,
|
||||
Message,
|
||||
PrivateMessageEvent,
|
||||
)
|
||||
from nonebot.compat import model_dump, type_validate_python
|
||||
from nonebot_plugin_alconna import Alconna, on_alconna
|
||||
|
||||
from zhenxun.services.log import logger
|
||||
|
||||
tasks: set["asyncio.Task"] = set()
|
||||
|
||||
|
||||
@get_driver().on_shutdown
|
||||
async def cancel_tasks():
|
||||
for task in tasks:
|
||||
if not task.done():
|
||||
task.cancel()
|
||||
|
||||
await asyncio.gather(
|
||||
*(asyncio.wait_for(task, timeout=10) for task in tasks),
|
||||
return_exceptions=True,
|
||||
)
|
||||
|
||||
|
||||
def push_event(bot: Bot, event: PrivateMessageEvent | GroupMessageEvent):
|
||||
event.message = Message("签到")
|
||||
event.user_id = random.randint(1, 99999999999) + random.randint(1, 99999999999)
|
||||
task = asyncio.create_task(bot.handle_event(event))
|
||||
task.add_done_callback(tasks.discard)
|
||||
tasks.add(task)
|
||||
logger.info(f"发送消息 --> {event.user_id} {event.message}")
|
||||
return event
|
||||
|
||||
|
||||
_matcher = on_alconna(
|
||||
Alconna("test", Args["n", int]), priority=5, block=True, temp=True
|
||||
)
|
||||
|
||||
|
||||
@_matcher.handle()
|
||||
async def handle_event(event: Event, bot: Bot, n: int):
|
||||
for _ in range(n):
|
||||
data = model_dump(event)
|
||||
if data.get("message_type") == "private":
|
||||
data["post_type"] = "message"
|
||||
push_event(bot, type_validate_python(PrivateMessageEvent, data))
|
||||
elif data.get("message_type") == "group":
|
||||
data["post_type"] = "message"
|
||||
push_event(bot, type_validate_python(GroupMessageEvent, data))
|
||||
await asyncio.sleep(0.1)
|
||||
logger.info(f"发送消息次数 --> {_ + 1}")
|
||||
Reference in New Issue
Block a user