SpringBoot+微信小程序在线选课系统开发实践

1. 项目概述：微信小程序在线选课系统的技术架构

这个基于SpringBoot和微信小程序的在线选课系统，是当前教育信息化领域的一个典型应用案例。系统采用前后端分离架构，前端使用微信小程序原生开发框架，后端基于SpringBoot构建RESTful API服务。这种架构组合在校园信息化系统中越来越常见，主要得益于微信生态的普及和SpringBoot的高效开发特性。

从技术选型来看，微信小程序提供了天然的移动端入口，学生和教师无需下载额外APP，通过微信即可访问系统。而后端选择SpringBoot框架，则是因为其在快速构建微服务方面的优势，特别适合处理选课系统这种高并发场景。系统源码中应该包含了完整的用户认证、课程管理、选课逻辑、数据统计等模块。

提示：在实际教育项目开发中，选课系统需要特别注意高并发场景下的数据一致性问题。比如热门课程被瞬间抢光时，如何防止超卖和保证公平性。

2. 系统核心功能模块解析

2.1 用户认证与权限管理

微信小程序端的用户认证通常采用微信官方提供的登录API。具体流程是：前端调用wx.login获取code，后端用appid+appsecret+code向微信服务器换取openid和session_key。这个openid就是用户在微信生态中的唯一标识。

java复制// SpringBoot后端处理微信登录的示例代码
@PostMapping("/wxLogin")
public Result wxLogin(@RequestParam String code) {
    String url = "https://api.weixin.qq.com/sns/jscode2session?appid={appid}&secret={secret}&js_code={code}&grant_type=authorization_code";
    Map<String, String> params = new HashMap<>();
    params.put("appid", appId);
    params.put("secret", appSecret);
    params.put("code", code);
    String response = restTemplate.getForObject(url, String.class, params);
    // 解析response获取openid和session_key
    // ...生成自定义token返回给小程序端
}

权限管理方面，系统需要区分学生、教师和管理员三种角色：

• 学生：查看可选课程、选课/退课、查看个人课表
• 教师：发布课程信息、查看选课学生名单、录入成绩
• 管理员：课程管理、用户管理、系统配置

2.2 课程管理模块设计

课程数据模型设计是系统的核心，主要包含以下实体：

java复制@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;        // 课程名称
    private String teacher;     // 授课教师
    private Integer capacity;   // 容量
    private Integer selected;   // 已选人数
    private String schedule;    // 上课时间
    private String location;    // 上课地点
    // 其他字段和getter/setter
}

后端API需要提供：

• 课程列表分页查询（支持按名称、教师等条件筛选）
• 课程详情查看
• 课程增删改（管理员权限）
• 选课人数统计

2.3 选课业务逻辑实现

选课功能的核心是处理并发选课请求，确保不会出现超选情况。常见的解决方案有：

1. 数据库乐观锁：

java复制@Transactional
public boolean selectCourse(Long courseId, Long studentId) {
    Course course = courseRepository.findById(courseId).orElseThrow();
    if(course.getSelected() >= course.getCapacity()) {
        return false; // 已满
    }
    course.setSelected(course.getSelected() + 1);
    courseRepository.save(course);
    // 创建选课记录
    SelectionRecord record = new SelectionRecord(courseId, studentId);
    selectionRecordRepository.save(record);
    return true;
}

2. Redis分布式锁：

java复制public boolean selectCourseWithLock(Long courseId, Long studentId) {
    String lockKey = "course:lock:" + courseId;
    String requestId = UUID.randomUUID().toString();
    try {
        // 尝试获取锁
        boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, 30, TimeUnit.SECONDS);
        if(!locked) {
            return false; // 获取锁失败
        }
        // 执行业务逻辑
        return selectCourse(courseId, studentId);
    } finally {
        // 释放锁
        if(requestId.equals(redisTemplate.opsForValue().get(lockKey))) {
            redisTemplate.delete(lockKey);
        }
    }
}

注意：在高并发场景下，单纯依赖数据库事务可能不够，需要结合缓存和队列等技术。实际项目中，我们曾遇到选课高峰期系统崩溃的情况，后来通过引入Redis缓存课程余量和RabbitMQ异步处理选课请求解决了问题。

3. 微信小程序前端关键技术点

3.1 小程序页面布局与组件

选课系统的小程序端通常包含以下主要页面：

• 首页：展示推荐课程、快速入口
• 课程列表：分页展示所有可选课程
• 课程详情：课程介绍、教师信息、选课按钮
• 个人中心：已选课程、课表展示

关键组件实现示例：

xml复制<!-- 课程卡片组件 -->
<view class="course-card" bindtap="navigateToDetail" data-id="{{course.id}}">
  <view class="card-header">
    <text class="course-name">{{course.name}}</text>
    <text class="teacher">{{course.teacher}}</text>
  </view>
  <view class="card-body">
    <text>时间：{{course.schedule}}</text>
    <text>地点：{{course.location}}</text>
    <text>余量：{{course.capacity - course.selected}}/{{course.capacity}}</text>
  </view>
  <button class="select-btn" disabled="{{course.selected >= course.capacity}}">
    {{course.selected >= course.capacity ? '已满' : '选课'}}
  </button>
</view>

3.2 网络请求封装

小程序端需要封装统一的请求方法，处理token、错误码等：

javascript复制// utils/http.js
const request = (url, method, data) => {
  return new Promise((resolve, reject) => {
    wx.request({
      url: `${baseUrl}${url}`,
      method,
      data,
      header: {
        'Authorization': `Bearer ${wx.getStorageSync('token')}`
      },
      success: (res) => {
        if (res.statusCode === 200) {
          resolve(res.data)
        } else {
          reject(res.data)
        }
      },
      fail: (err) => {
        reject(err)
      }
    })
  })
}

// 使用示例
const getCourseList = (params) => request('/api/courses', 'GET', params)
const selectCourse = (courseId) => request(`/api/select/${courseId}`, 'POST')

3.3 全局状态管理

对于用户登录状态、已选课程等全局数据，可以使用小程序的全局变量或第三方状态管理库：

javascript复制// app.js
App({
  globalData: {
    userInfo: null,
    selectedCourses: []
  },
  // 初始化用户信息
  initUserInfo() {
    const token = wx.getStorageSync('token')
    if (token) {
      request('/api/user/info', 'GET').then(res => {
        this.globalData.userInfo = res.data
        this.loadSelectedCourses()
      })
    }
  },
  // 加载已选课程
  loadSelectedCourses() {
    if (this.globalData.userInfo) {
      request('/api/user/courses', 'GET').then(res => {
        this.globalData.selectedCourses = res.data
      })
    }
  }
})

4. SpringBoot后端关键技术实现

4.1 项目结构与配置

标准的SpringBoot项目结构如下：

code复制src/main/java
  ├── com.example.selectcourse
  │   ├── config       # 配置类
  │   ├── controller   # 控制器
  │   ├── service      # 业务逻辑
  │   ├── repository   # 数据访问
  │   ├── entity       # 实体类
  │   └── exception    # 异常处理
src/main/resources
  ├── application.yml  # 主配置文件
  ├── static           # 静态资源
  └── templates        # 模板文件

关键Maven依赖：

xml复制<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- 数据库 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!-- 其他工具 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.78</version>
    </dependency>
</dependencies>

4.2 接口安全与鉴权

使用JWT进行接口鉴权是常见做法，实现步骤：

1. 添加JWT依赖：

xml复制<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2. 创建JWT工具类：

java复制public class JwtUtil {
    private static final String SECRET_KEY = "your-secret-key";
    private static final long EXPIRATION = 86400000; // 24小时

    public static String generateToken(String openid) {
        return Jwts.builder()
                .setSubject(openid)
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }

    public static String getOpenidFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }
}

3. 实现拦截器：

java复制public class JwtInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("Authorization");
        if (token == null || !token.startsWith("Bearer ")) {
            throw new UnauthorizedException("缺少有效的token");
        }
        token = token.substring(7);
        try {
            String openid = JwtUtil.getOpenidFromToken(token);
            request.setAttribute("openid", openid);
            return true;
        } catch (Exception e) {
            throw new UnauthorizedException("无效的token");
        }
    }
}

4.3 数据持久层设计

使用Spring Data JPA简化数据库操作：

1. 实体类定义：

java复制@Entity
@Data
@NoArgsConstructor
public class User {
    @Id
    private String openid; // 微信openid作为主键
    private String name;
    private Integer role; // 0-学生,1-教师,2-管理员
    // 其他字段...
}

@Entity
@Data
@NoArgsConstructor
public class SelectionRecord {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Long courseId;
    private String studentOpenid;
    private LocalDateTime selectTime;
    // 其他字段...
}

2. Repository接口：

java复制public interface CourseRepository extends JpaRepository<Course, Long> {
    // 自定义查询方法
    Page<Course> findByNameContaining(String name, Pageable pageable);
    
    @Query("SELECT c FROM Course c WHERE c.teacher = :teacher")
    List<Course> findByTeacherName(@Param("teacher") String teacher);
}

public interface SelectionRecordRepository extends JpaRepository<SelectionRecord, Long> {
    boolean existsByCourseIdAndStudentOpenid(Long courseId, String studentOpenid);
    
    @Query("SELECT c FROM Course c JOIN SelectionRecord s ON c.id = s.courseId WHERE s.studentOpenid = :openid")
    List<Course> findSelectedCourses(@Param("openid") String openid);
}

5. 系统部署与性能优化

5.1 多环境配置

SpringBoot支持通过profile区分不同环境配置：

application-dev.yml（开发环境）：

yaml复制server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/select_course_dev
    username: dev
    password: dev123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

application-prod.yml（生产环境）：

yaml复制server:
  port: 80
spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/select_course_prod
    username: prod
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false

启动时通过--spring.profiles.active指定环境：

bash复制java -jar select-course.jar --spring.profiles.active=prod

5.2 缓存策略优化

对于选课系统这种读多写少的场景，合理使用缓存可以显著提升性能：

1. 课程列表缓存：

java复制@Service
@CacheConfig(cacheNames = "courses")
public class CourseService {
    @Autowired
    private CourseRepository courseRepository;
    
    @Cacheable(key = "'list:' + #page + ':' + #size")
    public Page<Course> getCourseList(int page, int size) {
        return courseRepository.findAll(PageRequest.of(page, size));
    }
    
    @CachePut(key = "'detail:' + #course.id")
    public Course updateCourse(Course course) {
        return courseRepository.save(course);
    }
    
    @CacheEvict(key = "'detail:' + #id")
    public void deleteCourse(Long id) {
        courseRepository.deleteById(id);
    }
}

2. 选课余量缓存：

java复制public boolean selectCourseWithCache(Long courseId, String openid) {
    String key = "course:remain:" + courseId;
    Long remain = redisTemplate.opsForValue().decrement(key);
    if (remain == null) {
        // 缓存未命中，从数据库加载
        Course course = courseRepository.findById(courseId).orElseThrow();
        remain = course.getCapacity() - course.getSelected() - 1;
        redisTemplate.opsForValue().set(key, remain, 1, TimeUnit.HOURS);
    }
    if (remain < 0) {
        redisTemplate.opsForValue().increment(key); // 回滚
        return false;
    }
    // 执行选课逻辑...
}

5.3 压力测试与调优

使用JMeter进行压力测试时，需要特别关注以下指标：

• 选课接口的TPS（每秒事务数）
• 平均响应时间
• 错误率
• 数据库连接池使用情况

常见优化手段：

1. 数据库连接池配置：

yaml复制spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000

2. JVM参数调优：

bash复制java -server -Xms2g -Xmx2g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -jar select-course.jar

3. 异步处理非核心业务：

java复制@Async
public void sendSelectCourseNotification(String openid, Long courseId) {
    // 发送选课成功通知
    User user = userRepository.findById(openid).orElseThrow();
    Course course = courseRepository.findById(courseId).orElseThrow();
    String message = String.format("您已成功选修《%s》课程，上课时间：%s，地点：%s", 
            course.getName(), course.getSchedule(), course.getLocation());
    notificationService.sendWechatMessage(user.getOpenid(), message);
}

在实际项目中，我们通过以下优化将系统承载能力提升了3倍：

• 引入Redis缓存热门课程数据
• 使用消息队列削峰处理选课请求
• 对数据库进行读写分离
• 优化JPA查询，避免N+1问题