1. 一个简单的选课系统的雏形

站长

2024年06月18日 16:56 · 阅读数 27

能学到什么

sync.Mutex使用场景
Grom操作事务与锁机制
位运算

涉及技术

Gin
Mysql

架构设计

1. 一个简单的选课系统的雏形

目录文件说明

1. 一个简单的选课系统的雏形

数据库设计

user

由于只是一个简单的demo，不涉及到跟多的字段

package models

type User struct {
    BaseModel
    UserName string `json:"username" gorm:"type:varchar(64);not null;index;comment:用户名称;"`
    Password string `json:"password" gorm:"type:varchar(64);not null;comment:密码;"`
}

course

package models

import "time"

// CourseCategory 课程种类
type CourseCategory struct {
    BaseModel
    Name string `json:"name" gorm:"type:varchar(32);not null;comment:分类名称"`
}

// Course 课程
type Course struct {
    BaseModel
    Title string `json:"title" gorm:"type:varchar(64);not null;comment:课程名称"`
    // 课程分类
    CategoryID uint            `json:"categoryID" gorm:"not null;comment:分类ID"`
    Category   *CourseCategory `json:"category" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;comment:课程分类"`

    // 上课周 1 ~ 5
    Week uint8 `json:"week" gorm:"type:int;"`
    // 例如：  上午 08:10 ~ 11:50 |  下午 14:10 ~ 16:50 |  晚上 18:50 ~ 21:20
    Duration string `json:"duration" gorm:"type:varchar(32);not null;comment:上课时间段"`
    // 容纳人数
    Capacity uint `json:"capacity" gorm:"type:int;not null;comment:容纳人数"`
}

// UserCourse 用户选课关系表
type UserCourse struct {
    UserID    uint      `json:"userID" gorm:"not null;uniqueIndex:user_course;comment:用户ID"`
    User      *User     `json:"users" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;comment:用户"`
    CourseID  uint      `json:"courseID" gorm:"not null;uniqueIndex:user_course;comment:课程ID"`
    Course    *Course   `json:"course" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;comment:课程"`
    CreatedAt time.Time `json:"created_at" comment:"创建时间"`
}

选课流程

暂时无法在飞书文档外展示此内容

1. 一个简单的选课系统的雏形

业务

Gorm使用事务


if err := database.Client.Transaction(func(tx *gorm.DB) error {}); err != nil {
   // ... 这里为一个整体的事务，需要注意的是必须使用tx对象，返回nil的话默认是提交事务，返回err会进行回滚
}

gorm使用锁

// 共享锁
if err := tx.Clauses(clause.Locking{Strength: "SHARE"}).).First(&course,1).Error; err != nil {
       return nil
}

// 排它锁
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).).First(&course,1).Error; err != nil {
       return nil
}

课程时间冲突校验


// 2.2 检查用户是否已选该课程或时间冲突
var userCourses []*models.UserCourse
if err := tx.Where("user_id = ?", req.UserID).Preload("Course").Find(&userCourses).Error; err != nil {
    logger.Logger.WithContext(ctx).Info("查询用户课程失败", err)
    return err
}
for _, userCourse := range userCourses {
    if userCourse.CourseID == req.CourseID {
       logger.Logger.WithContext(ctx).Info("用户已选择该门课程")
       resp.Fail(ctx, code.NotFound, code.CourseSelected, code.CourseSelectedMsg)
       return nil
    }
    if userCourse.Course.Week == course.Week && userCourse.Course.Duration == course.Duration {
       logger.Logger.WithContext(ctx).Info("课程上课时间存在冲突")
       resp.Fail(ctx, code.NotFound, code.CourseTimeConflict, code.CourseTimeConflictMsg)
       return nil
    }
}

这里的话每次进行校验时都需要进行到user_course表进行查询一次，且还需要在业务层进行遍历进行对比。非常的低效。

优化对课程时间校验的冲突

方案一

使用缓存进行记录用户选的课程，根据课程的Week字段和Duration字段作为值，这里的话使用Redis作为缓存，使用Set数据结构，进行记录用户选择过的时间段。

方案二

使用一个 uint16 作为标记，因为一周有 5 天上课，每天分为早中晚 3 次课。一个 uint16 正好16位每一位记录着每个时间段。

例：

用户标志位：0000000000000000

课程：[课程1 （早上周五），课程2 （下午周三），课程3（下午周四），课程4 （下午周三）]

用户选择课程1

用户标志位 : 0000000000000000 | = 1 << (4*3+1) = 0001000000000000

用户选择课程2

用户标志位 : 0001000000000000 | = 1 << (2*3+2) = 0001000010000000

用户选择课程4

校验 (0001000010000000 >> (2*3+2)) & 1

此时发现标准位进行右移8位再&（与）运算得到1，就说明该位上已经存在了。

package main

// TimeSlotBitmap 用于表示一天中各个时间槽的占用情况
type TimeSlotBitmap uint16 // 假设一天有32个时间槽，使用uint32存储

// SetBit 设置指定位置的位为1，表示时间槽被占用
func (tb *TimeSlotBitmap) SetBit(slot int) {
    if slot < 0 || slot >= 16 {
       panic("over")
    }
    *tb |= 1 << slot
}

// ClearBit 清除指定位置的位，表示释放时间槽
func (tb *TimeSlotBitmap) ClearBit(slot int) {
    if slot < 0 || slot >= 16 {
       panic("over")
    }
    *tb &= ^(1 << slot)
}

// TestBit 检查指定位置的位是否为1，即时间槽是否被占用
func (tb *TimeSlotBitmap) TestBit(slot int) bool {
    if slot < 0 || slot >= 16 {
       panic("over")
    }
    return (*tb>>(slot))&1 == 1
}

// Conflict 检测两个位图是否存在冲突的时间槽
func Conflict(a, b TimeSlotBitmap) bool {
    return a&b != 0
}
func main() {
    /*
       // 假设有两门课程，第一门课占用第2、4时间槽，第二门课占用第3、5时间槽
       course1 := new(TimeSlotBitmap)
       course1.SetBit(2)
       course1.SetBit(4)
       bit := course1.TestBit(9)
       fmt.Println(bit)

    */
    //c := uint(8)

}

实现

优化用户表

package models

type Flag uint32
type User struct {
    BaseModel
    UserName string `json:"username" gorm:"type:varchar(64);not null;index;comment:用户名称;"`
    Password string `json:"password" gorm:"type:varchar(64);not null;comment:密码;"`
    Flag     Flag   `json:"flag" gorm:"type:int;not null;comment:用户标准位记录着选课的已选字段;"`
}

// SetBit 设置指定位置的位为1，表示时间槽被占用
func (tb *Flag) SetBit(slot int) {
    if slot < 0 || slot >= 16 {
       panic("Slot out of range")
    }
    *tb |= 1 << slot
}

// ClearBit 清除指定位置的位，表示释放时间槽
func (tb *Flag) ClearBit(slot int) {
    if slot < 0 || slot >= 16 {
       panic("Slot out of range")
    }
    *tb &= ^(1 << slot)
}

// TestBit 检查指定位置的位是否为1，即时间槽是否被占用
func (tb *Flag) TestBit(slot int) bool {
    if slot < 0 || slot >= 16 {
       panic("Slot out of range")
    }
    return (*tb>>(slot))&1 == 1
}

优化课程表

package models

import "time"

type Duration uint8
type Week uint8

const (
    _ = iota
    Morning Duration = iota // 上午 08:10 ~ 11:50
    AfterNoon // 下午 14:10 ~ 16:50
    Evening // 晚上 18:50 ~ 21:20
)
const (
    // 上课周
    _ Week = iota
    Mon
Tue
Wed
Thu
Fri
)

// CourseCategory 课程种类
type CourseCategory struct {
    BaseModel
    Name string `json:"name" gorm:"type:varchar(32);not null;comment:分类名称"`
}

// Course 课程
type Course struct {
    BaseModel
    Title string `json:"title" gorm:"type:varchar(64);not null;comment:课程名称"`
    // 课程分类
    CategoryID uint            `json:"categoryID" gorm:"not null;comment:分类ID"`
    Category   *CourseCategory `json:"category" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;comment:课程分类"`

    // 上课周 1 ~ 5
    // 上课时间段 早中晚
    ScheduleID uint      `json:"ScheduleID" gorm:"not null;comment:分类ID"`
    Schedule   *Schedule `json:"schedule" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;comment:课程时间"`
    // 容纳人数
    Capacity uint `json:"capacity" gorm:"type:int;not null;comment:容纳人数"`
}

type Schedule struct {
    BaseModel
    // 上下午阶段
    Duration Duration `json:"duration" gorm:"type:int;"`
    // 上课周 周一到周五
    Week Week `json:"week" gorm:"type:int;"`
}

// UserCourse 用户选课关系表
type UserCourse struct {
    UserID    uint      `json:"userID" gorm:"not null;uniqueIndex:user_course;comment:用户ID"`
    User      *User     `json:"users" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;comment:用户"`
    CourseID  uint      `json:"courseID" gorm:"not null;uniqueIndex:user_course;comment:课程ID"`
    Course    *Course   `json:"course" gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;comment:课程"`
    CreatedAt time.Time `json:"created_at" comment:"创建时间"`
}

最终选课业务代码

func SelectCourse(ctx *gin.Context) {
    // 1. 参数校验
    var req request.SelectCourseReq
    if err := ctx.ShouldBind(&req); err != nil {
       logger.Logger.WithContext(ctx).Info("参数校验失败", err)
       resp.ParamErr(ctx)
       return
    }
    var user models.User

    // 2. 数据库操作
    if err := database.Client.WithContext(context.Background()).Transaction(func(tx *gorm.DB) error {
       // 2.1 用户是否已选该门课程（这里可以不用判断因为如果用户选择了该门课程就会存在时间冲突
       if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
          Where("id=?", req.UserID).
          First(&user).Error; err != nil {
          if errors.Is(err, gorm.ErrRecordNotFound) {
             logger.Logger.WithContext(ctx).Info("用户不存在", err)
             resp.Fail(ctx, code.NotFound, code.UserNotFound, code.UserNotFoundMsg)
          }
       }

       // 2.2 检查课程是否存在和库存
       var course models.Course
       if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
          Model(models.Course{}).
          Preload("Schedule").
          Where("id=? and capacity > 0", req.CourseID).
          First(&course).Error; err != nil {
          if errors.Is(err, gorm.ErrRecordNotFound) {
             logger.Logger.WithContext(ctx).Info("课程不存在或库存不足", err)
             resp.Fail(ctx, code.NotFound, code.CourseNotFound, code.CourseNotFoundMsg)
             return nil //无需回滚，业务逻辑错误
          }
          return err
       }
       // 2.3 检查用户是否已选该课程或时间冲突
       offset := int(course.Schedule.Week)*3 + int(course.Schedule.Duration) - 1
       if user.Flag.TestBit(offset) {
          logger.Logger.WithContext(ctx).Info("用户已选该课程或时间冲突")
          resp.Fail(ctx, code.ParamErr, code.CourseTimeConflict, code.CourseTimeConflictMsg)
          return errors.New("用户已选该课程或时间冲突")
       }

       // 2.4 扣减课程库存
       if err := tx.Model(&course).
          Update("capacity", gorm.Expr("capacity - 1")).Error; err != nil {
          logger.Logger.WithContext(ctx).Info("更新课程容量失败", err)
          resp.DBError(ctx)
          return err
       }
       // 2.5 创建选课记录
       if err := tx.Create(&models.UserCourse{
          UserID:   req.UserID,
          CourseID: req.CourseID,
       }).Error; err != nil {
          logger.Logger.WithContext(ctx).Info("创建选课记录失败", err)
          resp.DBError(ctx)
          return err
       }
       // 2.6 更新用户选课记录
       user.Flag.SetBit(offset)
       if err := tx.Save(&user).Error; err != nil {
          logger.Logger.WithContext(ctx).Info("更新用户选课记录失败", err)
          resp.DBError(ctx)
          return err
       }
       return nil // 成功，无错误返回
    }); err != nil {
       logger.Logger.WithContext(ctx).Info("事务回滚", err)
       return
    }
    // 事务成功，响应成功
    resp.Success(ctx, nil)
}

退课逻辑

这里就不赘述了，也就是选课逻辑的逆向操作

func BackCourse(ctx *gin.Context) {
    // 1. 参数校验
    var req request.SelectCourseReq
    if err := ctx.ShouldBind(&req); err != nil {
       logger.Logger.WithContext(ctx).Info("参数校验失败", err)
       resp.ParamErr(ctx)
       return
    }
    // 2. 数据库操作
    if err := database.Client.WithContext(context.Background()).Transaction(func(tx *gorm.DB) error {
       // 2.1 用户是否选择了该课程
       var userCourse models.UserCourse
       if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
          Where("user_id=? and course_id=?", req.UserID, req.CourseID).
          First(&userCourse).Error; err != nil {
          if errors.Is(err, gorm.ErrRecordNotFound) {
             logger.Logger.WithContext(ctx).Info("用户未选该课程", err)
             resp.Fail(ctx, code.ParamErr, code.CourseNotSelected, code.CourseNotSelectedMsg)
             return err
          }
          resp.DBError(ctx)
          return err
       }
       // 2.2 获取课程信息，获取schedule的week和duration 计算出offset
       var course models.Course
       if err := tx.Model(models.Course{}).
          Preload("Schedule").
          Where("id=?", req.CourseID).
          First(&course).Error; err != nil {
          if errors.Is(err, gorm.ErrRecordNotFound) {
             logger.Logger.WithContext(ctx).Info("课程不存在", err)
             resp.Fail(ctx, code.NotFound, code.CourseNotFound, code.CourseNotFoundMsg)
             return err
          }
          return err
       }
       var user models.User
       // 2.3 这里必须加锁，因为要保证flag字段并发安全
       if err := tx.
          Clauses(clause.Locking{Strength: "UPDATE"}).
          Where("id=?", req.UserID).
          First(&user).Error; err != nil {
          if errors.Is(err, gorm.ErrRecordNotFound) {
             logger.Logger.WithContext(ctx).Info("用户不存在", err)
             resp.Fail(ctx, code.NotFound, code.UserNotFound, code.UserNotFoundMsg)
             return err
          }
          resp.DBError(ctx)
          return err
       }
       // 2.4 删除选课记录
       if err := tx.Where("user_id=? and course_id=?", req.UserID, req.CourseID).
          Delete(&models.UserCourse{}).Error; err != nil {
          logger.Logger.WithContext(ctx).Info("删除选课记录失败", err)
          resp.DBError(ctx)
          return err
       }
       // 2.5 课程容量+1
       if err := tx.Model(&course).
          Update("capacity", gorm.Expr("capacity + 1")).Error; err != nil {
          logger.Logger.WithContext(ctx).Info("更新课程容量失败", err)
          resp.DBError(ctx)
          return err
       }
       // 2.6 更新用户选课记录
       offset := int(course.Schedule.Week)*3 + int(course.Schedule.Duration) - 1
       user.Flag.ClearBit(offset)
       if err := tx.Save(&user).Error; err != nil {
          logger.Logger.WithContext(ctx).Info("更新用户选课记录失败", err)
          resp.DBError(ctx)
          return err
       }
       return nil
    }); err != nil {
       logger.Logger.WithContext(ctx).Info("事务回滚", err)
       return
    }
    // 事务成功，响应成功
    resp.Success(ctx, nil)
}

总结

本期代码请见：github.com/bbz1024/sel…

若阁下感兴趣可以clone下来玩一玩。

bash
复制代码
git clone --branch demo1 https://github.com/bbz1024/select-course.git

转载自:https://juejin.cn/post/7378084350128324635