高考辅助填报系统招生计划页面Redis缓存加速实施方案

原创已于 2025-11-30 08:46:26 修改 · 587 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#缓存 #高考 #redis

于 2025-11-30 08:22:40 首次发布

## 1. 项目背景与需求分析

### 1.1 背景
招生计划管理页面（`/data-maintenance/enrollment-plan/`）作为高考志愿填报系统的数据维护核心功能之一，承担着展示和管理招生计划数据的重要职责。随着数据量的不断增长，该页面在频繁访问时可能面临性能瓶颈，影响用户体验。

### 1.2 性能挑战
通过代码分析，发现以下性能问题：
1. 每次页面加载都需要执行多个数据库查询来获取筛选选项（学科、批次、专业等）
2. 查询结果未进行缓存，重复查询相同条件时会重复执行数据库操作
3. 数据量较大时，这些数据库查询会显著增加页面加载时间

### 1.3 需求目标
为招生计划管理页面实施Redis缓存加速，具体目标：
- 减少页面加载时的数据库查询次数
- 提升页面响应速度
- 保持数据的一致性和实时性
- 与现有缓存机制保持一致的设计风格

## 2. Redis缓存实施方案设计

### 2.1 缓存架构
采用与`summary/search/`页面相同的多级缓存架构：
- **筛选选项缓存**：缓存页面所需的所有筛选下拉选项数据
- **查询结果缓存**：缓存用户查询后的分页数据结果

### 2.2 缓存分类

| 缓存类型 | 缓存键模式 | 过期时间 | 缓存内容 | 缓存时机 |
|---------|----------|---------|---------|--------|
| 筛选选项缓存 | `enrollment_plan_filter_options` | 2小时 | 学科、批次、专业等筛选选项列表 | 首次访问页面时 |
| 查询结果缓存 | `enrollment_plan_list:{hash}` | 10分钟 | 特定查询条件下的分页数据结果 | 用户执行查询时 |

### 2.3 键设计策略
- 筛选选项缓存：使用固定键名`enrollment_plan_filter_options`
- 查询结果缓存：使用`enrollment_plan_list:{hash}`格式，其中`hash`由查询参数生成的MD5值
- 参数排序后再生成哈希，确保相同参数不同顺序生成相同的键

### 2.4 过期策略
- 筛选选项：2小时过期，适合相对稳定的数据
- 查询结果：10分钟过期，平衡实时性和性能

## 3. 实施步骤

### 3.1 环境准备
确保项目已正确配置Redis缓存：
- 项目已配置Django缓存后端，包含`query_cache`缓存别名
- Redis服务已安装并运行

### 3.2 Django缓存配置
确保在`settings.py`中正确配置了Redis缓存后端：
```python
CACHES = {
'default': {
'BACKEND': 'django_redis.cache.RedisCache',
'LOCATION': 'redis://127.0.0.1:6379/1',
'OPTIONS': {
'CLIENT_CLASS': 'django_redis.client.DefaultClient',
}
},
'query_cache': {
'BACKEND': 'django_redis.cache.RedisCache',
'LOCATION': 'redis://127.0.0.1:6379/2',
'OPTIONS': {
'CLIENT_CLASS': 'django_redis.client.DefaultClient',
}
}
}
```

### 3.3 缓存工具类
利用现有的`cache_utils.py`中的工具函数：
- `generate_cache_key`: 用于生成唯一的缓存键
- `caches['query_cache']`: 用于访问专门的查询缓存

### 3.4 代码实现

#### 3.4.1 筛选选项缓存实现

在`data_maintenance.py`文件中添加筛选选项缓存函数：

```python
def get_enrollment_plan_filter_options():
"""
获取并缓存招生计划筛选选项
"""
# 尝试从Redis缓存获取筛选选项
query_cache = caches['query_cache']
key = "enrollment_plan_filter_options"
options = query_cache.get(key)
if options is None:
options = {
'disciplines': list(models.EnrollmentPlan.objects.values_list('discipline', flat=True).distinct().order_by('discipline')),
'batches': list(models.EnrollmentPlan.objects.values_list('batch_name', flat=True).distinct().order_by('batch_name')),
'categories': list(models.EnrollmentPlan.objects.values_list('subject_category', flat=True).distinct().order_by('subject_category')),
'natures': list(models.EnrollmentPlan.objects.values_list('plan_nature', flat=True).distinct().order_by('plan_nature')),
'subjects': list(models.EnrollmentPlan.objects.values_list('alternative_subject', flat=True).distinct().order_by('alternative_subject')),
# 限制专业名称数量以减少缓存大小
'majors': list(models.EnrollmentPlan.objects.values_list('major_name', flat=True).distinct().order_by('major_name')[:1000]),
# 添加缓存时间戳
'cache_timestamp': timezone.now().isoformat()
}
# 保存到Redis缓存，设置2小时过期时间
query_cache.set(key, options, 7200) # 缓存2小时
return options
```

#### 3.4.2 查询结果缓存实现

修改`enrollment_plan_list`函数，添加查询结果缓存逻辑：

```python
def enrollment_plan_list(request):
# 获取搜索和筛选参数
key = request.GET.get('key', '').strip()
discipline_filter = request.GET.get('discipline', '')
batch_filter = request.GET.get('batch', '')
category_filter = request.GET.get('category', '')
nature_filter = request.GET.get('nature', '')
subject_filter = request.GET.get('subject', '')
selected_majors = request.GET.getlist('major')
page = request.GET.get('page', '1')

# 生成缓存键，包含查询参数和分页信息
cache_params = {
'key': key,
'discipline': discipline_filter,
'batch': batch_filter,
'category': category_filter,
'nature': nature_filter,
'subject': subject_filter,
'major': selected_majors,
'page': page
}
cache_key = generate_cache_key("enrollment_plan_list", cache_params)

# 尝试从查询缓存获取结果
query_cache = caches['query_cache']
cached_result = query_cache.get(cache_key)

if cached_result:
plans_page = cached_result['plans_page']
total_count = cached_result['total_count']
else:
# 构建查询...
# 执行数据库查询...
# 分页处理...

# 将查询结果转换为可序列化的形式
serializable_plans = []
for plan in plans_page:
serializable_plan = {
'id': plan.id,
'institution_name': plan.institution_name,
'major_name': plan.major_name,
'discipline': plan.discipline,
'batch_name': plan.batch_name,
'subject_category': plan.subject_category,
'plan_nature': plan.plan_nature,
'alternative_subject': plan.alternative_subject,
'plan_number': plan.plan_number,
'year': plan.year
}
serializable_plans.append(serializable_plan)

# 缓存查询结果，设置10分钟过期时间
query_cache.set(cache_key, {
'plans_page': serializable_plans,
'total_count': total_count
}, 600) # 缓存10分钟

plans_page = serializable_plans

# 获取筛选选项（从缓存）
options = get_enrollment_plan_filter_options()
# 准备上下文数据并渲染模板...
```

## 4. 性能提升预期

### 4.1 性能对比分析

| 操作类型 | 优化前 | 优化后 | 预期提升倍数 |
|---------|-------|-------|------------|
| 首次加载筛选选项 | 多次数据库查询 | 单次数据库查询 | 5-10倍 |
| 重复加载筛选选项 | 多次数据库查询 | 内存缓存读取 | 100-500倍 |
| 重复查询相同条件 | 完整数据库查询 | 内存缓存读取 | 20-100倍 |

### 4.2 实际效果评估

基于类似页面的优化经验，预计页面加载时间将从原来的：
- 首次加载：降低约60-80%
- 重复访问：降低约90-95%

## 5. 缓存维护与监控

### 5.1 缓存一致性维护

当招生计划数据发生变更时，需要清除相关缓存以保持数据一致性：

```python
# 在数据变更相关的视图或信号处理函数中
from django.core.cache import caches

def clear_enrollment_plan_cache():
"""清除招生计划相关缓存"""
query_cache = caches['query_cache']
# 清除筛选选项缓存
query_cache.delete("enrollment_plan_filter_options")
# 清除所有查询结果缓存（使用模式匹配）
query_cache.delete_pattern("enrollment_plan_list:*")
```

### 5.2 缓存监控

建议通过Redis提供的监控工具或自定义监控函数来监控缓存使用情况：

```python
from app.utils.cache_utils import get_cache_stats

def get_enrollment_cache_stats():
"""获取招生计划缓存统计信息"""
stats = get_cache_stats()
# 可以添加特定于招生计划缓存的统计逻辑
return stats
```

## 6. 测试与验证

### 6.1 测试脚本

已创建测试脚本`test_enrollment_cache.py`用于验证缓存功能的正确性，包括：
- 筛选选项缓存的读取性能测试
- 查询结果缓存的读写测试
- 缓存键验证

### 6.2 浏览器验证

建议在实际环境中进行以下验证：
1. 访问`/data-maintenance/enrollment-plan/`页面，记录加载时间
2. 刷新页面，验证二次加载速度显著提升
3. 尝试不同的筛选条件，验证缓存键的正确性

## 7. 部署与注意事项

### 7.1 部署前检查

- 确保Redis服务已安装并正常运行
- 验证Django缓存配置正确无误
- 检查项目依赖是否包含`django-redis`