高并发在线选课系统架构设计与实现-代码聚汇网

高并发在线选课系统架构设计与实现

苏黎世贝勒爷

1. 项目概述：在线选课系统的核心价值与实现路径

这个选课系统本质上是一个教育信息化基础设施，它解决了传统纸质选课流程中的三大痛点：时间冲突导致的选课难、人工统计效率低下、数据难以追溯分析。我见过太多学校在开学季因为选课系统崩溃而手忙脚乱，这正是我们需要构建稳定可靠的在线选课平台的原因。

系统采用Java+SSM+Django的混合架构不是偶然选择。SSM（Spring+SpringMVC+MyBatis）作为核心框架处理高并发的选课请求，Django则凭借其强大的Admin后台快速搭建课程管理模块。这种架构组合既保证了系统在选课高峰期的稳定性（实测可支持3000+并发请求），又大幅降低了后台管理功能的开发成本。

2. 系统架构设计与技术选型

2.1 前后端分离架构解析

系统采用典型的前后端分离设计，但做了针对性优化：

前端：Vue.js + ElementUI实现响应式布局，特别适配手机端选课场景
后端微服务划分：
- 选课核心服务（Java SSM）：处理选课/退课等核心业务
- 课程管理服务（Django）：提供课程CRUD及教师管理
- 认证服务（Java）：JWT令牌实现跨系统认证

关键决策：将选课业务与管理业务物理分离，避免选课高峰期影响后台管理操作

2.2 数据库设计精要

课程系统的数据库设计有几个易错点需要特别注意：

sql复制CREATE TABLE `course_selection` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `student_id` VARCHAR(20) NOT NULL COMMENT '学号加密存储',
  `course_id` BIGINT NOT NULL,
  `selection_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `status` TINYINT NOT NULL DEFAULT 1 COMMENT '1-有效 0-退课',
  PRIMARY KEY (`id`),
  UNIQUE KEY `idx_unique_selection` (`student_id`,`course_id`,`status`),
  KEY `idx_course` (`course_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

这个设计解决了我们踩过的两个坑：

唯一索引防止重复选课
加密学号字段满足隐私保护要求

3. 核心业务逻辑实现

3.1 选课并发控制方案

选课场景最关键的并发问题我们通过三级锁机制解决：

乐观锁校验课程余量：

java复制@Transactional
public boolean selectCourse(Long courseId, String studentId) {
    Course course = courseMapper.selectForUpdate(courseId); // 悲观锁
    if (course.getRemain() <= 0) {
        throw new BusinessException("课程已满");
    }
    // 校验是否已选该课程
    if (selectionMapper.existsSelection(studentId, courseId)) {
        throw new BusinessException("不可重复选课");
    }
    // 扣减余量
    courseMapper.decreaseRemain(courseId); 
    // 创建选课记录
    SelectionRecord record = new SelectionRecord(studentId, courseId);
    return selectionMapper.insert(record) > 0;
}

分布式锁防止超卖（Redis实现）：

java复制String lockKey = "course_lock_" + courseId;
try {
    boolean locked = redisTemplate.opsForValue()
        .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
    if (!locked) {
        throw new BusinessException("系统繁忙请重试");
    }
    // 执行选课逻辑
} finally {
    redisTemplate.delete(lockKey);
}

数据库悲观锁兜底：

xml复制<select id="selectForUpdate" resultType="Course">
    SELECT * FROM course WHERE id=#{id} FOR UPDATE
</select>

3.2 课程冲突检测算法

时间冲突检测是选课系统的另一个难点，我们采用位图法实现高效检测：

python复制# Django服务中的冲突检测实现
def check_schedule_conflict(student_id, new_course):
    # 获取学生已选课程时间表
    selected = Selection.objects.filter(
        student_id=student_id,
        status=1
    ).select_related('course')
    
    # 初始化时间位图（每周168小时）
    time_map = [0] * (24 * 7)
    
    for selection in selected:
        for time_slot in selection.course.schedule:
            # 标记已占用的时间段
            time_map[time_slot] = 1
    
    # 检查新课程时间是否冲突
    for slot in new_course.schedule:
        if time_map[slot]:
            raise ConflictException("时间冲突")

4. 系统特色功能实现

4.1 智能推荐课程模块

基于协同过滤的推荐算法实现：

java复制public List<Course> recommendCourses(String studentId) {
    // 1. 获取学生历史选课记录
    List<Long> selected = selectionMapper.selectCourseIdsByStudent(studentId);
    
    // 2. 查找相似学生的选课记录
    List<Similarity> similars = studentMapper.findSimilarStudents(
        selected, 5); // 取前5个相似学生
    
    // 3. 加权计算推荐课程
    Map<Long, Double> recommendScores = new HashMap<>();
    for (Similarity sim : similars) {
        for (Long courseId : sim.getCourses()) {
            if (!selected.contains(courseId)) {
                recommendScores.merge(courseId, sim.getScore(), Double::sum);
            }
        }
    }
    
    // 4. 返回TOP10推荐课程
    return recommendScores.entrySet().stream()
        .sorted(Map.Entry.<Long, Double>comparingByValue().reversed())
        .limit(10)
        .map(e -> courseMapper.selectById(e.getKey()))
        .collect(Collectors.toList());
}

4.2 可视化课表生成

使用iTextPDF生成可打印课表：

java复制public byte[] generateTimetable(String studentId) throws IOException {
    List<Course> courses = selectionMapper.selectCurrentCourses(studentId);
    
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    PdfDocument pdf = new PdfDocument(new PdfWriter(baos));
    Document document = new Document(pdf);
    
    // 创建7x24的表格
    float[] widths = new float[8];
    Arrays.fill(widths, 1f);
    Table table = new Table(widths);
    
    // 填充表头
    for (String day : DAYS_OF_WEEK) {
        table.addCell(new Cell().add(new Paragraph(day)));
    }
    
    // 填充课程信息
    for (Course course : courses) {
        for (TimeSlot slot : course.getTimeSlots()) {
            table.addCell(new Cell(slot.getRowSpan(), slot.getColSpan())
                .add(new Paragraph(course.getName())));
        }
    }
    
    document.add(table);
    document.close();
    return baos.toByteArray();
}

5. 性能优化实战经验

5.1 选课高峰期应对策略

我们通过以下措施保障系统在选课高峰期的稳定性：

多级缓存策略：
- 课程基本信息：Redis缓存5分钟
- 课程余量：本地缓存+Redis原子计数器
- 学生课表：Ehcache二级缓存
数据库优化：

sql复制-- 课程表添加选课人数索引
ALTER TABLE course ADD INDEX idx_popularity (selection_count DESC);

-- 分库分表策略
spring.shardingsphere.datasource.names=ds0,ds1
spring.shardingsphere.sharding.tables.course_selection.actual-data-nodes=ds$->{0..1}.course_selection_$->{0..15}
spring.shardingsphere.sharding.tables.course_selection.table-strategy.inline.sharding-column=student_id
spring.shardingsphere.sharding.tables.course_selection.table-strategy.inline.algorithm-expression=course_selection_$->{student_id.hashCode() % 16}

限流措施：

java复制@Configuration
public class RateLimitConfig {
    @Bean
    public FilterRegistrationBean<RateLimitFilter> rateLimitFilter() {
        FilterRegistrationBean<RateLimitFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new RateLimitFilter());
        registration.addUrlPatterns("/api/select/*");
        registration.setOrder(1);
        return registration;
    }
}

public class RateLimitFilter implements Filter {
    private final RateLimiter limiter = RateLimiter.create(1000); // 1000请求/秒
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        if (!limiter.tryAcquire()) {
            ((HttpServletResponse)response).sendError(429);
            return;
        }
        chain.doFilter(request, response);
    }
}

6. 安全防护体系构建

6.1 防刷课机制实现

我们设计了多维度防刷策略：

行为分析：记录用户操作频率，异常行为触发验证码
设备指纹：通过浏览器特征识别唯一设备
时间窗口限制：同一课程5秒内只能提交一次请求

安全校验代码示例：

java复制public void checkSelectionSecurity(HttpServletRequest request, String studentId) {
    // 1. 验证码校验
    String captcha = request.getParameter("captcha");
    if (!captchaService.verify(captcha)) {
        throw new SecurityException("验证码错误");
    }
    
    // 2. 频率检查
    String key = "select_limit_" + studentId;
    Long count = redisTemplate.opsForValue().increment(key, 1L);
    if (count != null && count == 1) {
        redisTemplate.expire(key, 1, TimeUnit.MINUTES);
    }
    if (count > 20) { // 每分钟最多20次选课操作
        throw new SecurityException("操作过于频繁");
    }
    
    // 3. 设备指纹验证
    String deviceId = DeviceUtils.getDeviceId(request);
    if (blacklistService.isBlocked(deviceId)) {
        throw new SecurityException("可疑设备");
    }
}

6.2 数据加密方案

敏感数据加密存储方案：

java复制// 学号加密处理
public String encryptStudentId(String studentId) {
    try {
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, new GCMParameterSpec(128, iv));
        byte[] encrypted = cipher.doFinal(studentId.getBytes());
        return Base64.getEncoder().encodeToString(encrypted);
    } catch (Exception e) {
        throw new RuntimeException("加密失败", e);
    }
}

// 日志脱敏处理
@Around("execution(* com..service.*.*(..))")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Object[] args = pjp.getArgs();
    // 对参数进行脱敏处理
    for (int i = 0; i < args.length; i++) {
        if (args[i] instanceof String) {
            String arg = (String) args[i];
            if (arg.matches("\\d{10}")) { // 匹配学号格式
                args[i] = arg.substring(0, 3) + "****" + arg.substring(7);
            }
        }
    }
    return pjp.proceed(args);
}

7. 系统部署与监控

7.1 容器化部署方案

使用Docker Compose编排服务：

yaml复制version: '3.8'
services:
  selection-service:
    image: selection:1.0
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  course-manage:
    image: course-manage:1.0
    ports:
      - "8000:8000"
    depends_on:
      - redis
      - mysql

  redis:
    image: redis:6
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

volumes:
  redis_data:

7.2 监控告警配置

Prometheus监控指标示例：

yaml复制- job_name: 'selection-service'
  metrics_path: '/actuator/prometheus'
  static_configs:
    - targets: ['selection-service:8080']
      labels:
        service: 'selection'

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

rule_files:
  - 'alerts/*.rules'

# 自定义业务指标
- pattern: 'course.selection.<operation>.<status>'
  name: 'course_selection_${operation}_${status}'
  help: 'Course selection operation metrics'
  type: COUNTER

关键业务指标监控：

选课成功率（成功数/请求总数）
平均响应时间（按接口维度）
课程余量预警（当余量<10%时触发）
异常请求比例（非200响应占比）

8. 项目演进路线

8.1 第一阶段：核心功能实现

基础选课/退课流程
课程冲突检测
简单的后台管理

8.2 第二阶段：性能优化

引入Redis缓存
数据库读写分离
接口限流措施

8.3 第三阶段：智能化扩展

课程推荐系统
选课结果预测
自动排课算法

8.4 第四阶段：生态整合

与教务系统对接
移动端小程序开发
在线学习平台集成

在实际开发中，我们团队花了3个月完成基础版本，又经过2个迭代周期优化性能，最终系统在某高校实际运行中支撑了8000名学生同时选课，峰值QPS达到1200，平均响应时间保持在200ms以内。这个过程中最大的教训是：选课系统的瓶颈往往不在技术层面，而在于业务规则的理解深度。比如我们最初没有考虑到"试听期退课不占名额"的特殊规则，导致第一版逻辑出现严重漏洞。