Day01 - 初识项目

1.1 项目介绍

1.1.1 功能演示

天机学堂是一个基于微服务架构的生产级在线教育项目。项目源码：https://gitee.com/yaoyu_turin/tj-exam。

1. 管理端（B端）：

演示地址：https://tjxt-admin.itheima.net/#/main/index，账号：12088888888，密码：888itcast.CN764%...

2. 学生端（C端）：

演示地址：https://tjxt-user.itheima.net/#/main/index，账号：12077777777，密码：888itcast.CN764%...

1.1.2 项目亮点

1. 项目亮点：

2. 技术架构：

1.2 项目环境搭建

1.2.1 企业开发模式

1. 微服务项目与传统项目相比，包含项目模块非常多，每个模块都要独立部署，因此在开发模式上有很大差别：

   • 开发人员成倍增多，分组分别开发不同的微服务模块

   • 微服务模块之间有业务关联，需要相互协作

2. 我们开发时，是否能把所有的项目代码都拉取到本地，然后在本地部署运行、开发测试？

   大型微服务项目显然不能，原因如下：

   • 我们可能没有其它模块的代码拉取权限

   • 微服务运行环境过于复杂，本地部署成本较高

   • 微服务模块较多，本地计算机性能难以支撑

3. 在开发的不同阶段，往往有不同的测试手段：

   • 单元测试：测试最小的可测试单元

   • 集成测试：验证某个功能接口

   • 组件测试：验证微服务组件

   • 端对端联调：验证整个系统

1.2.2 模拟企业环境

为了模拟真实开发环境，我们准备了一台虚拟机，在其中安装了各种各样的公共服务和组件。

虚拟机导入说明：https://b11et3un53m.feishu.cn/wiki/wikcnp21tivsf57nQrHckQuZ3Vd

自定义部署：https://b11et3un53m.feishu.cn/wiki/R068wmzUtifYg5kEMP7c6EMTn9d

1.2.3 持续集成环境

我们在虚拟机中已经基于 Jenkins 实现了持续集成，访问 http://jenkins.tianji.com (账号：root/123) 即可查看控制台：

1.2.4 本地开发部署

我们在虚拟机环境中准备了一个Git私服，访问 http://git.tianji.com (账号：tjxt/123321) 即可查看私服控制台：

1. 将代码克隆到自己的 IDEA 工作空间中：

# master 分支是完整项目代码，上课要从 lesson-init 分支开发
git clone http://192.168.150.101:10880/tjxt/tianji.git -b lesson-init

2. 以 lesson-init 分支为起点，创建一个 dev 分支，完成项目开发：

xxxxxxxxxx
cd tianji
git checkout -b dev

3. 然后用 IDEA 打开项目即可。

1.2.5 熟悉项目

首先是项目结构，目前企业微服务开发项目结构有两种模式：

• 每个项目下的每一个微服务，需要创建一个 Project，尽可能降低耦合

• 每个项目创建一个 Project ，项目下的多个微服务是 Project 下的 Module，方便管理（√）

SpringBoot 的配置文件支持多环境配置，在天机学堂中也基于不同环境有不同配置文件：

除了基本配置以外，其它的配置都放在了 Nacos 中共享，包括两大类：共享的配置、微服务中根据业务变化的配置。

登录 http://nacos.tianji.com (账号：nacos/nacos) 即可看到所有被管理的配置信息。

1.3 学会 DEBUG

1.3.1 阅读源码

BUG：都是普通用户，为什么用户 Jack 可以删除自己的订单，而用户 Rose 则无法成功删除？

1.3.2 远程调试

如果部署的微服务不在本地，我们可以利用 IDEA 的远程调试功能：

1.3.3 分析解决

​x
package com.tianji.trade.service.impl;

@Override
public void deleteOrder(Long id) {
    if(userId != order.getUserId()) {
        throw new BadRequestException("不能删除他人订单");
    }
}

BUG 分析：Integer、Long 等包装类 -128 到 127 之间的数值使用共享对象，可以用 == 判断，但其它则需要采用 equals 判断。

xxxxxxxxxx
package com.tianji.trade.service.impl;

@Override
public void deleteOrder(Long id) {
    if(!userId.equals(order.getUserId())) {
        throw new BadRequestException("不能删除他人订单");
    }
}

1.3.4 测试部署

当我们完成项目的 BUG 修复后，可以把项目提交并推送到 Git 私服，而 Jenkins 可以帮我们完成项目自动编译、构建。

由于我们现在是基于 dev 分支开发，所以必须修改 Jenkins 中的自动化构建脚本，让其监听 dev 分支的变动：

Day02 - 我的课程

2.1 分析产品原型

2.1.1 分析业务流程

2.1.2 设计业务接口

管理端 - 产品原型与接口：https://lanhuapp.com/link/#/invite?sid=qx03viNU，密码: Ssml

用户端 - 产品原型与接口：https://lanhuapp.com/link/#/invite?sid=qx0Fy3fa，密码: ZsP3

2.2 数据结构

2.2.1 字段分析

课表要记录的是用户的学习状态，所谓学习状态就是记录谁在学习哪个课程，学习的进度如何。

• 课表就是用户和课程的中间关系表，因此一定要包含三个字段：

  • userId：用户 id，也就是谁

  • courseId：课程 id，也就是学的课程

  • id：唯一主键

• 学习进度则是一些附加的功能字段，页面需要哪些功能就添加哪些字段即可：

  • status：课程学习状态。0-未学习，1-学习中，2-已学完，3-已过期

  • planStatus：学习计划状态，0-没有计划，1-计划进行中

  • weekFreq：计划的学习频率

  • learnedSections：已学习小节数量，注意，课程总小节数、课程名称、封面等可由课程id查询得出，无需重复记录

  • latestSectionId：最近一次学习的小节id，方便根据id查询最近学习的课程正在学第几节

  • latestLearnTime：最近一次学习时间，用于分页查询的排序：

  • createTime 和 expireTime：也就是课程加入时间和过期时间

2.2.2 表结构

课表对应的数据库结构应该是这样的：

xxxxxxxxxx
CREATE TABLE learning_lesson (
    id bigint NOT NULL COMMENT '主键',
    user_id bigint NOT NULL COMMENT '学员id',
    course_id bigint NOT NULL COMMENT '课程id',
    status tinyint DEFAULT '0' COMMENT '课程状态，0-未学习，1-学习中，2-已学完，3-已失效',
    week_freq tinyint DEFAULT NULL COMMENT '每周学习频率，每周3天，每天2节，则频率为6',
    plan_status tinyint NOT NULL DEFAULT '0' COMMENT '学习计划状态，0-没有计划，1-计划进行中',
    learned_sections int NOT NULL DEFAULT '0' COMMENT '已学习小节数量',
    latest_section_id bigint DEFAULT NULL COMMENT '最近一次学习的小节id',
    latest_learn_time datetime DEFAULT NULL COMMENT '最近一次学习的时间',
    create_time datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    expire_time datetime NOT NULL COMMENT '过期时间',
    update_time datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (id),
    UNIQUE KEY idx_user_id (user_id,course_id) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='学生课表';

在一个名为 tj_learning 的 database 中，执行资料提供的 SQL 脚本，创建 learning_lesson 表：

2.2.3 代码生成

1. 一般开发新功能都需要创建一个 feature 类型分支，不能在 DEV 分支直接开发：

xxxxxxxxxx
git checkout -b feature-lessons

2. 我们使用的是 Mybatis 作为持久层框架，并且引入了 MybatisPlus 来简化开发。因此，在创建据库以后，就需要创建对应的实体类、mapper、service等。这些代码格式固定，编写起来又比较费时。好在 IDEA 中提供了一个 MP 插件，可以生成这些重复代码：

3. 安装完成以后，我们先配置一下数据库地址：

4. 严格按照下图的模式去设置，不要填错项目名称和包名称。最后，点击 code generatro 按钮，即可生成代码：

• 默认情况下 PO 的主键 ID 是自增长，而项目默认希望采用雪花算法作为 ID，因此这里需要对 LearningLesson 做修改：

xxxxxxxxxx
package com.tianji.learning.domain.po;

// @TableId(value = "id", type = IdType.AUTO)
@TableId(value = "id", type = IdType.ASSIGN_ID)

• 除此之外，我们还要按照Restful风格，对请求路径做修改：

xxxxxxxxxx
package com.tianji.learning.controller;

// @RequestMapping("/learning-lesson")
@RequestMapping("/lessons")

2.2.4 状态枚举

1. 在数据结构中，课表是有学习状态的，学习计划也有状态。如果每次编码手写很容易写错，因此一般都会定义出枚举：

xxxxxxxxxx
package com.tianji.learning.enums;

@Getter
public enum LessonStatus implements BaseEnum {...}

xxxxxxxxxx
package com.tianji.learning.enums;

@Getter
public enum PlanStatus implements BaseEnum {...}

2. 这样一来，我们就需要修改 PO 对象，用枚举类型替代原本的 Integer 类型：

xxxxxxxxxx
package com.tianji.learning.domain.po;

// 课程状态，0-未学习，1-学习中，2-已学完，3-已失效
private LessonStatus status;

// 学习计划状态，0-没有计划，1-计划进行中
private PlanStatus planStatus;

MybatisPlus会在我们与数据库交互时实现自动的数据类型转换，无需我们操心。

2.3 开发接口功能

2.3.1 添加课程到课表中

需求：用户购买课程后，交易服务会通过 MQ 通知学习服务，学习服务将课程加入用户课表中。

1. 在 tj-learning 服务中定义一个 MQ 的监听器：

xxxxxxxxxx
package com.tianji.learning.mq;

@Slf4j
@Component
@RequiredArgsConstructor
public class LessonChangeListener {
    private final ILearningLessonService lessonService;

    // 监听订单支付或课程报名的消息
    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "learning.lesson.pay.queue", durable = "true"),
        exchange = @Exchange(name = MqConstants.Exchange.ORDER_EXCHANGE, type = ExchangeTypes.TOPIC),
        key = MqConstants.Key.ORDER_PAY_KEY
    ))
    public void listenLessonPay(OrderBasicDTO order){
        // 1. 健壮性处理
        if(order == null || order.getUserId() == null || CollUtils.isEmpty(order.getCourseIds())){
            log.error("接收到MQ消息有误，订单数据为空");
            return;
        }
        // 2. 添加课程
        log.debug("监听到用户{}的订单{}，需要添加课程{}到课表中", 
                  order.getUserId(), order.getOrderId(), order.getCourseIds());
        lessonService.addUserLessons(order.getUserId(), order.getCourseIds());
    }
}

2. 实现 LearningLessonServiceImpl 中的 addUserLessons 方法：

xxxxxxxxxx
public void addUserLessons(Long userId, List<Long> courseIds) {
    // 1. 查询课程有效期
    List<CourseSimpleInfoDTO> cInfoList = courseClient.getSimpleInfoList(courseIds);
    if (CollUtils.isEmpty(cInfoList)) {
        log.error("课程信息不存在，无法添加到课表");
        return;
    }
    // 2. 循环遍历，处理LearningLesson数据
    List<LearningLesson> list = new ArrayList<>(cInfoList.size());
    for (CourseSimpleInfoDTO cInfo : cInfoList) {
        LearningLesson lesson = new LearningLesson();
        Integer validDuration = cInfo.getValidDuration();   // 获取过期时间
        if (validDuration != null && validDuration > 0) {
            LocalDateTime now = LocalDateTime.now();
            lesson.setCreateTime(now);
            lesson.setExpireTime(now.plusMonths(validDuration));
        }
        lesson.setUserId(userId);   // 填充userId和courseId
        lesson.setCourseId(cInfo.getId());
        list.add(lesson);
    }
    // 3.批量新增
    saveBatch(list);
}

2.3.2 分页查询我的课表

2.3.2.1 获取登录用户

1. 网关解析 token，获取用户存入header，向下传递：

xxxxxxxxxx
package com.tianji.gateway.filter;

@Component
public class AccountAuthFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 尝试获取用户信息
        List<String> authHeaders = exchange.getRequest().getHeaders().get(AUTHORIZATION_HEADER);
        String token = authHeaders == null ? "" : authHeaders.get(0);
        R<LoginUserDTO> r = authUtil.parseToken(token);
        // 如果用户是登录状态，尝试更新请求头，传递用户信息
        if(r.success()){
            exchange.mutate()
                .request(builder -> builder.header(USER_HEADER, r.getData().getUserId().toString()))
                .build();
        }
    }
}

2. 拦截器解析 header 中的用户信息，存入 UserContext：

xxxxxxxxxx
package com.tianji.authsdk.resource.interceptors;

@Slf4j
public class UserInfoInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 1. 尝试获取头信息中的用户信息
        String authorization = request.getHeader(JwtConstants.USER_HEADER);
        // 2. 判断是否为空
        if (authorization == null) return true;
        // 3. 转为用户id并保存
        Long userId = Long.valueOf(authorization);
        UserContext.setUser(userId);
        return true;
    }
}

3. UserContext 是一个基于 ThreadLocal 的工具，可以确保不同的请求之间互不干扰，避免线程安全问题发生：

xxxxxxxxxx
package com.tianji.common.utils;

public class UserContext {
    private static final ThreadLocal<Long> TL = new ThreadLocal<>();

    public static void setUser(Long userId){
        TL.set(userId);
    }
    public static Long getUser(){
        return TL.get();
    }
    public static void removeUser(){
        TL.remove();
    }
}

2.3.2.2 分页查询我的课表

需求：在个人中心-我的课程页面，可以分页查询用户的课表及学习状态信息。

1. Query 实体类：

xxxxxxxxxx
package com.tianji.common.domain.query;

@Data
@ApiModel(description = "分页请求参数")
@Accessors(chain = true)
public class PageQuery {
    public <T> Page<T> toMpPage(String defaultSortBy, boolean isAsc) {
        if (StringUtils.isBlank(sortBy)){
            sortBy = defaultSortBy;
            this.isAsc = isAsc;
        }
        Page<T> page = new Page<>(pageNo, pageSize);
        OrderItem orderItem = new OrderItem();
        orderItem.setAsc(this.isAsc);
        orderItem.setColumn(sortBy);
        page.addOrder(orderItem);
        return page;
    }
}

2. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@Api(tags = "我的课程相关接口")
@RequiredArgsConstructor
@RestController
@RequestMapping("/lessons")
public class LearningLessonController {
    @ApiOperation("分页查询我的课表")
    @GetMapping("page")
    public PageDTO<LearningLessonVO> queryMyLessons(PageQuery query){
        return lessonService.queryMyLessons(query);
    }
}

3. Service 层：

xxxxxxxxxx
@Override
public PageDTO<LearningLessonVO> queryMyLessons(PageQuery query) {
    // 1. 获取当前登录用户
    Long userId = UserContext.getUser();
    // 2. 分页查询我的课表
    Page<LearningLesson> page = lambdaQuery()               // select * from learning_lesson
        .eq(LearningLesson::getUserId, userId)              // where user_id = #{userId}
        .page(query.toMpPage("latest_learn_time", false));  // order by latest_learn_time
    List<LearningLesson> records = page.getRecords();
    if (CollUtils.isEmpty(records)) {
        return PageDTO.empty(page);
    }
    // 3. 查询我的课程信息
    Map<Long, CourseSimpleInfoDTO> cMap = queryCourseSimpleInfoList(records);
    // 4. 封装 VO 并返回
    List<LearningLessonVO> list = new ArrayList<>(records.size());
    for (LearningLesson r : records) {
        LearningLessonVO vo = BeanUtils.copyBean(r, LearningLessonVO.class);
        CourseSimpleInfoDTO cInfo = cMap.get(r.getCourseId());
        vo.setCourseName(cInfo.getName());
        vo.setCourseCoverUrl(cInfo.getCoverUrl());
        vo.setSections(cInfo.getSectionNum());
        list.add(vo);
    }
    return PageDTO.of(page, list);
}

private Map<Long, CourseSimpleInfoDTO> queryCourseSimpleInfoList(List<LearningLesson> records) {
    // 3.1 获取课程 id
    Set<Long> cIds = records.stream().map(LearningLesson::getCourseId).collect(Collectors.toSet());
    // 3.2 查询课程信息
    List<CourseSimpleInfoDTO> cInfoList = courseClient.getSimpleInfoList(cIds);
    if (CollUtils.isEmpty(cInfoList)) {
        throw new BadRequestException("课程信息不存在！");
    }
    // 3.3 把 PO 集合处理成 Map, 否则要双重 for 设置到 VO 集合
    Map<Long, CourseSimpleInfoDTO> cMap = cInfoList.stream()
        .collect(Collectors.toMap(CourseSimpleInfoDTO::getId, c -> c));
    return cMap;
}

2.3.3 查询学习中的课程

需求：在首页、个人中心-课程表页，需要查询并展示当前用户最近一次学习的课程。

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@GetMapping("/now")
@ApiOperation("查询正在学习的课程")
public LearningLessonVO queryMyCurrentLesson() {
    return lessonService.queryMyCurrentLesson();
}

2. Service 层：

xxxxxxxxxx
private final CatalogueClient catalogueClient;

@Override
public LearningLessonVO queryMyCurrentLesson() {
    // 1. 获取当前登录的用户
    Long userId = UserContext.getUser();
    // 2. 查询正在学习的课程
    LearningLesson lesson = lambdaQuery()                   // select * from learning_lesson
        .eq(LearningLesson::getUserId, userId)              // where user_id = #{userId}
        .eq(LearningLesson::getStatus, LessonStatus.LEARNING.getValue())
        .orderByDesc(LearningLesson::getLatestLearnTime)    // order by latest_learn_time
        .last("limit 1").one();                             // limit 1 AND status = 1
    if (lesson == null) return null;
    // 3. 拷贝 PO 基础属性到 VO
    LearningLessonVO vo = BeanUtils.copyBean(lesson, LearningLessonVO.class);
    // 4. 查询我的课程信息
    CourseFullInfoDTO cInfo = courseClient.getCourseInfoById(lesson.getCourseId(), false, false);
    if (cInfo == null) throw new BadRequestException("课程不存在");
    vo.setCourseName(cInfo.getName());
    vo.setCourseCoverUrl(cInfo.getCoverUrl());
    vo.setSections(cInfo.getSectionNum());
    // 5. 统计课表中的课程数量
    Integer courseAmount = lambdaQuery()                    // select count(1) from learning_lesson
        .eq(LearningLesson::getUserId, userId).count();     // where user_id = #{userId}
    vo.setCourseAmount(courseAmount);
    // 6. 查询小节信息
    List<CataSimpleInfoDTO> cataInfos =
        catalogueClient.batchQueryCatalogue(CollUtils.singletonList(lesson.getLatestSectionId()));
    if (!CollUtils.isEmpty(cataInfos)) {
        CataSimpleInfoDTO cataInfo = cataInfos.get(0);
        vo.setLatestSectionName(cataInfo.getName());
        vo.setLatestSectionIndex(cataInfo.getCIndex());
    }
    return vo;
}

2.3.4 删除课表中的课程

需求：用户可以直接删除《已失效》的课程，学习服务将删除用户课表中的课程。

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@ApiOperation("用户手动删除当前课程")
@DeleteMapping("/{courseId}")
public void deleteCourseFromLesson(@PathVariable("courseId") Long couseId){
    Long user = UserContext.getUser();
    lessonService.deleteCourseFromLesson(user, couseId);
}

2. Service 层：

xxxxxxxxxx
@Override
public void deleteCourseFromLesson(Long userId, Long courseId) {
    remove(buildUserIdAndCourseIdWrapper(userId, courseId));
}

2.3.5 移除课表中的课程

需求：用户退款课程后，交易服务会通过 MQ 通知学习服务，学习服务将移除用户课表中的课程。

在 tj-learning 服务中定义一个 MQ 的监听器即可，deleteCourseFromLesson 方法已实现：

xxxxxxxxxx
package com.tianji.learning.mq;

@Slf4j
@Component
@RequiredArgsConstructor
public class LessonChangeListener {
    private final ILearningLessonService lessonService;

    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "trade.refund.result.queue", durable = "true"),
        exchange = @Exchange(name = MqConstants.Exchange.ORDER_EXCHANGE, type = ExchangeTypes.TOPIC),
        key = MqConstants.Key.ORDER_REFUND_KEY
    ))
    public void listenLessonRefund(OrderBasicDTO order){
        // 1. 健壮性处理
        if(order == null || order.getUserId() == null || CollUtils.isEmpty(order.getCourseIds())){
            log.error("接收到MQ消息有误，订单数据为空");
            return;
        }
        // 2. 删除课程表中删除该课程
        log.debug("监听到用户{}的订单{}，需要添加课程{}到课表中"
                  , order.getUserId(), order.getOrderId(), order.getCourseIds());
        lessonService.deleteCourseFromLesson(order.getUserId(), order.getCourseIds().get(0));
    }
}

2.3.6 检查课程是否有效

需求：当用户学习课程时，可能需要播放视频。此时提供播放功能的媒资系统就需要校验用户是否有播放资格。

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@ApiOperation("校验当前用户是否可以学习当前课程")
@GetMapping("/{courseId}/valid")
public Long isLessonValid(@PathVariable("courseId") Long courseId){
    return lessonService.isLessonValid(courseId);
}

2. Service 层：

xxxxxxxxxx
@Override
public Long isLessonValid(Long courseId) {
    Long user = UserContext.getUser();
    if(user==null || courseId==null) return null;
    LearningLesson lesson = lambdaQuery()               // select * from learning_lesson
        .eq(LearningLesson::getUserId, user)            // where user_id = #{userId}
        .eq(LearningLesson::getCourseId, courseId)      // and course_id = #{courseId}
        .one();
    // 用户课表中没有该课程
    if(lesson==null) return null;
    // 课程的状态是已经过期
    if(lesson.getExpireTime() != null && LocalDateTime.now().isAfter(lesson.getExpireTime())){
        return  null;
    }
    return lesson.getId();
}

2.3.7 查询指定课程状态

需求：进入详情页以后，需要查询用户的课表中是否有该课程，如果有则返回课程的学习进度、课程有效期等信息。

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;  

@ApiOperation("用户是否拥有该课程并返回学习进度")
@GetMapping("/{courseId}")
public LessonStatusVO queryLessonByCourseId(
    @ApiParam(value = "课程id", example = "1") @PathVariable("courseId") Long couseId){
    LessonStatusVO lessonStatusVO = lessonService.queryLessonByCourseId(couseId);
    return lessonStatusVO;
}

2. Service 层：

xxxxxxxxxx
@Override
public LessonStatusVO queryLessonByCourseId(Long couseId) {
    // 1. 获取用户信息
    Long user = UserContext.getUser();
    // 2. 查询用户是否有该课程
    LambdaQueryWrapper<LearningLesson> wrapper = buildUserIdAndCourseIdWrapper(user, couseId);
    LearningLesson lesson = getOne(wrapper);
    if(lesson==null) return null;
    // 3. 如果有则设置学习进度
    LessonStatusVO vo = BeanUtils.copyBean(lesson, LessonStatusVO.class);
    return vo;
}

2.3.8 统计课程学习人数

需求：根据课程 id，统计该课程的报名人数。

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@ApiOperation("查询该课程的报名人数")
@GetMapping("/lessons/{courseId}/count")
Integer countLearningLessonByCourse(
    @ApiParam(value = "课程id", example = "1") @PathVariable("courseId") Long courseId){
    return lessonService.countLearningLessonByCourse(courseId);
}

2. Service 层：

xxxxxxxxxx
@Override
public Integer countLearningLessonByCourse(Long courseId) {
    Integer count = lambdaQuery()                           // select count(*) from learning_lesson
        .eq(LearningLesson::getCourseId, courseId).count(); // where course_id = #{courseId}
    return count;
}

Day03 - 学习系统

3.1 分析产品原型

3.1.1 分析业务流程

3.1.2 设计业务接口

1. 提交学习记录：

需求：在课程学习页面播放视频时或考试后，需要提交学习记录信息到服务端保存。

2. 查询学习记录：

需求：在课程学习页面需要查询出每一个小节的基本信息，以及小节对应的学习记录。

3. 创建学习计划：

需求：当点击创建学习计划时，会提交课程信息和计划的学习频率到服务端。服务端需要将数据写入对应的课表中。

4. 查询学习计划：

需求：在我的课程页面中，需要统计用户本周的学习计划及进度，数据较多，采用分页查询。

3.1.3 抽取业务实体

xxxxxxxxxx
CREATE TABLE `learning_record`  (
    `id` bigint NOT NULL COMMENT '学习记录的id',
    `lesson_id` bigint NOT NULL COMMENT '对应课表的id',
    `section_id` bigint NOT NULL COMMENT '对应小节的id',
    `user_id` bigint NOT NULL COMMENT '用户id',
    `moment` int NULL DEFAULT 0 COMMENT '视频的当前观看时间点，单位秒',
    `finished` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否完成学习，默认false',
    `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '第一次观看时间',
    `finish_time` datetime NULL DEFAULT NULL COMMENT '完成学习的时间',
    `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间（最近一次观看时间）',
    PRIMARY KEY (`id`) USING BTREE,
    UNIQUE INDEX `idx_user_id`(`user_id`, `section_id`) USING BTREE,
    INDEX `idx_update_time`(`update_time`) USING BTREE,
    INDEX `idx_lesson_id`(`lesson_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '学习记录表' ROW_FORMAT = DYNAMIC;

3.2 开发接口功能

3.2.1 提交学习记录

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@Api(tags = "学习记录的相关接口")
@RequiredArgsConstructor
@RestController
@RequestMapping("/learning-records")
public class LearningRecordController {
    @ApiOperation("提交学习记录")
    @PostMapping()
    public void addLearningRecord(@RequestBody @Validated LearningRecordFormDTO formDTO){
        recordService.addLearningRecord(formDTO);
    }
}

2. Service 层：

xxxxxxxxxx
private final CourseClient courseClient;

@Override
@Transactional
public void addLearningRecord(LearningRecordFormDTO recordDTO) {
    Long userId = UserContext.getUser();                    // 1. 获取登录用户
    boolean finished = false;
    if (recordDTO.getSectionType() == SectionType.VIDEO) {
        finished = handleVideoRecord(userId, recordDTO);    // 2. 处理视频记录
    }else{
        finished = handleExamRecord(userId, recordDTO);     // 3. 处理考试记录
    }
    handleLearningLessonsChanges(recordDTO, finished);      // 4. 处理课表数据
}

xxxxxxxxxx
private boolean handleVideoRecord(Long userId, LearningRecordFormDTO recordDTO) {
    // 2.1 判断记录是否已经存在
    LearningRecord old = queryOldRecord(recordDTO.getLessonId(), recordDTO.getSectionId());
    if (old == null) {
        // 2.2 新增学习记录
        LearningRecord record = BeanUtils.copyBean(recordDTO, LearningRecord.class);
        record.setUserId(userId);
        boolean success = save(record);
        if (!success) throw new DbException("新增学习记录失败！");
        return false;
    }
    // 2.3 更新学习记录
    boolean finished = !old.getFinished() && recordDTO.getMoment() * 2 >= recordDTO.getDuration();
    boolean success = lambdaUpdate()                            // update learning_record
        .set(LearningRecord::getMoment, recordDTO.getMoment())  // set moment = #{moment},
        .set(finished, LearningRecord::getFinished, true)       // finished = true, 
        // finishTime = #{CommitTime}
        .set(finished, LearningRecord::getFinishTime, recordDTO.getCommitTime())
        .eq(LearningRecord::getId, old.getId()).update();       // where id = #{id}
    if(!success) throw new DbException("更新学习记录失败！");
    return finished ;
}

private LearningRecord queryOldRecord(Long lessonId, Long sectionId) {
    return lambdaQuery()                                        // select * from learning_record
        .eq(LearningRecord::getLessonId, lessonId)              // where lesson_id = #{lessonId}
        .eq(LearningRecord::getSectionId, sectionId).one();     // and section_id = #{sectionId}
}

private boolean handleExamRecord(Long userId, LearningRecordFormDTO recordDTO) {
    // 3. 新增学习记录
    LearningRecord record = BeanUtils.copyBean(recordDTO, LearningRecord.class);
    record.setUserId(userId);
    record.setFinished(true);
    record.setFinishTime(recordDTO.getCommitTime());
    boolean success = save(record);
    if (!success) throw new DbException("新增考试记录失败！");
    return true;
}

private void handleLearningLessonsChanges(LearningRecordFormDTO recordDTO, boolean finished) {
    // 4.1 判断是否学完小节
    LearningLesson lesson = lessonService.getById(recordDTO.getLessonId());
    if (lesson == null) throw new BizIllegalException("课程不存在，无法更新数据！");
    boolean allLearned = false;
    if(finished){
        CourseFullInfoDTO cInfo = courseClient.getCourseInfoById(lesson.getCourseId(), false, false);
        if (cInfo == null) throw new BizIllegalException("课程不存在，无法更新数据！");
        // 4.2 判断是否学完全部小节
        allLearned = lesson.getLearnedSections() + 1 >= cInfo.getSectionNum();     
    }
    lessonService.lambdaUpdate()
        // 如果是第一次观看视频，则设置 lesson 为正在学习
        .set(lesson.getLearnedSections() == 0, LearningLesson::getStatus, LessonStatus.LEARNING.getValue())
        // 如果学完全部小节，则更新 lesson 为完成状态
        .set(allLearned, LearningLesson::getStatus, LessonStatus.FINISHED.getValue())
        // 4.3 如果没学完小节，则更新最后学习时间、学习章节
        .set(!finished, LearningLesson::getLatestSectionId, recordDTO.getSectionId())
        .set(!finished, LearningLesson::getLatestLearnTime, recordDTO.getCommitTime())
        // 4.4 如果已学完小节，则课表已学习小节数量 + 1
        .setSql(finished, "learned_sections = learned_sections + 1")
        .eq(LearningLesson::getId, lesson.getId()).update();
}

3.2.2 查询学习记录

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@ApiOperation("查询指定课程的学习记录")
@GetMapping("/course/{courseId}")
public LearningLessonDTO queryLearningRecordByCourse(
    @ApiParam(value = "课程id", example = "2") @PathVariable("courseId") Long courseId){
    return recordService.queryLearningRecordByCourse(courseId);
}

2. Service 层：

xxxxxxxxxx
private final ILearningLessonService lessonService;

@Override
public LearningLessonDTO queryLearningRecordByCourse(Long courseId) {
    // 1. 查询学习记录
    Long userId = UserContext.getUser();
    LearningLesson lesson = lessonService.queryByUserAndCourseId(userId, courseId);
    List<LearningRecord> records = lambdaQuery()                    // select * from learning_record
        .eq(LearningRecord::getLessonId, lesson.getId()).list();    // where lesson_id = #{lessonId}
    // 2. 封装 DTO 并返回
    LearningLessonDTO dto = new LearningLessonDTO();
    dto.setId(lesson.getId());
    dto.setLatestSectionId(lesson.getLatestSectionId());
    dto.setRecords(BeanUtils.copyList(records, LearningRecordDTO.class));
    return dto;
}

3. 远程调用接口：

xxxxxxxxxx
package com.tianji.learning.service.impl;

@Override
public LearningLesson queryByUserAndCourseId(Long userId, Long courseId) {
    return getOne(buildUserIdAndCourseIdWrapper(userId, courseId));
}

private LambdaQueryWrapper<LearningLesson> buildUserIdAndCourseIdWrapper(Long userId, Long courseId) {
    LambdaQueryWrapper<LearningLesson> queryWrapper = new QueryWrapper<LearningLesson>()
        .lambda()                                       // select * from learning_lesson
        .eq(LearningLesson::getUserId, userId)          // where user_id = #{userId}
        .eq(LearningLesson::getCourseId, courseId);     // and course_id = #{courseId}
    return queryWrapper;
}

3.2.3 创建学习计划

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@RestController
@RequestMapping("/lessons")
@Api(tags = "我的课表相关接口")
@RequiredArgsConstructor
public class LearningLessonController {
    @ApiOperation("创建学习计划")
    @PostMapping("/plans")
    public void createLearningPlans(@RequestBody @Validated LearningPlanDTO planDTO){
        lessonService.createLearningPlan(planDTO.getCourseId(), planDTO.getFreq());
    }
}

2. Service 层：

xxxxxxxxxx
@Override
public void createLearningPlan(Long courseId, Integer freq) {
    // 1. 查询课程有关的数据
    Long userId = UserContext.getUser();
    LearningLesson lesson = queryByUserAndCourseId(userId, courseId);
    AssertUtils.isNotNull(lesson, "课程信息不存在！");
    // 2. 更新课程数据
    LearningLesson l = new LearningLesson();
    l.setId(lesson.getId());
    l.setWeekFreq(freq);
    if(lesson.getPlanStatus() == PlanStatus.NO_PLAN) {
        l.setPlanStatus(PlanStatus.PLAN_RUNNING);
    }
    updateById(l);
}

3.2.4 查询学习计划

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@ApiOperation("查询我的学习计划")
@GetMapping("/plans")
public LearningPlanPageVO queryMyPlans(PageQuery query){
    return lessonService.queryMyPlans(query);
}

2. Service 层：

xxxxxxxxxx
private final LearningRecordMapper recordMapper;

@Override
public LearningPlanPageVO queryMyPlans(PageQuery query) {
    LearningPlanPageVO result = new LearningPlanPageVO();
    // 1. 获取当前登录用户
    Long userId = UserContext.getUser();
    // 2. 获取本周起始时间
    LocalDate now = LocalDate.now();
    LocalDateTime begin = DateUtils.getWeekBeginTime(now);
    LocalDateTime end = DateUtils.getWeekEndTime(now);
    // 3. 查询总的统计数据
    // 3.1. 本周总的已学习小节数量
    Integer weekFinished = recordMapper.selectCount(
        new LambdaQueryWrapper<LearningRecord>()            // select * from learning_record
        .eq(LearningRecord::getUserId, userId)              // where user_id = #{userId}
        .eq(LearningRecord::getFinished, true)              // and finished = true
        .gt(LearningRecord::getFinishTime, begin)           // and finishTime > begin
        .lt(LearningRecord::getFinishTime, end)             // and finishTime < end;
    );
    result.setWeekFinished(weekFinished);
    // 3.2 本周总的计划学习小节数量
    Integer weekTotalPlan = getBaseMapper().queryTotalPlan(userId);
    result.setWeekTotalPlan(weekTotalPlan);
    // TODO 3.3 本周学习积分
    
    // 4. 分页查询课表信息
    Page<LearningLesson> p = lambdaQuery()                  // select * from learning_lesson
        .eq(LearningLesson::getUserId, userId)              // where user_id = #{userId}
        .eq(LearningLesson::getPlanStatus, PlanStatus.PLAN_RUNNING)
                                                            // and plan_status = "计划进行中"
        .in(LearningLesson::getStatus, LessonStatus.NOT_BEGIN, LessonStatus.LEARNING)
                                                            // and plan_status in ("未学习", "学习中")
        .page(query.toMpPage("latest_learn_time", false));  // ordered by latest_learn_time DESC;
    List<LearningLesson> records = p.getRecords();
    if (CollUtils.isEmpty(records)) return result.emptyPage(p);
    // 5. 查询课表对应的课程信息
    Map<Long, CourseSimpleInfoDTO> cMap = queryCourseSimpleInfoList(records);
    // 6. 统计每一个课程本周已学习小节数量
    List<IdAndNumDTO> list = recordMapper.countLearnedSections(userId, begin, end);
    Map<Long, Integer> countMap = IdAndNumDTO.toMap(list);
    
    // 7. 封装 VO 并返回
    List<LearningPlanVO> voList = new ArrayList<>(records.size());
    for (LearningLesson r : records) {
        // 7.1 拷贝属性到 VO
        LearningPlanVO vo = BeanUtils.copyBean(r, LearningPlanVO.class);
        // 7.2 设置详细信息
        CourseSimpleInfoDTO cInfo = cMap.get(r.getCourseId());
        if (cInfo != null) {
            vo.setCourseName(cInfo.getName());
            vo.setSections(cInfo.getSectionNum());
        }
        // 7.3 每个课程的本周已学习小节数量
        vo.setWeekLearnedSections(countMap.getOrDefault(r.getId(), 0));
        voList.add(vo);
    }
    return result.pageInfo(p.getTotal(), p.getPages(), voList);
}

3. 远程调用接口：

xxxxxxxxxx
package com.tianji.learning.mapper;

public interface LearningRecordMapper extends BaseMapper<LearningRecord> {
    List<IdAndNumDTO> countLearnedSections(
        @Param("userId") Long userId,
        @Param("begin") LocalDateTime begin,
        @Param("end") LocalDateTime end);
}

xxxxxxxxxx
<select id="countLearnedSections" resultType="com.tianji.api.dto.IdAndNumDTO">
    SELECT lesson_id AS id, COUNT(1) AS num 
    FROM learning_record WHERE user_id = #{userId} 
    AND finished = 1 AND finish_time &gt; #{begin} AND finish_time &lt; #{end}
    GROUP BY lesson_id;
</select>

3.2.5 定时任务 (作业)

需求：编写一个 SpringTask 定时任务，定期检查 learning_lesson 表中的课程是否过期，如果过期则将课程状态修改为已过期。

xxxxxxxxxx
package com.tianji.learning.job;

@Component
@RequiredArgsConstructor
public class LessonStatusCheckJob {
    private final ILearningLessonService lessonService;

    @Scheduled(cron = "0 * * * * ?")    // 每分钟执行一次
    public void lessonStatusCheck() {
        // 1. 查询状态为未过期的课程
        List<LearningLesson> list = lessonService.list(
            Wrappers.<LearningLesson>lambdaQuery().ne(LearningLesson::getStatus, LessonStatus.EXPIRED)
        );
        LocalDateTime now = LocalDateTime.now();
        // 2. 判断是否过期
        for (LearningLesson lesson : list) {
            if (now.isAfter(lesson.getExpireTime())) {
                lesson.setStatus(LessonStatus.EXPIRED);
            }
        }
        // 3. 批量更新
        lessonService.updateBatchById(list);
    }
}

3.3 高并发优化

3.3.1 高并发优化方案

1. 提高单机并发：

   • 读：① 优化代码及 SQL；② 缓存。

   • 写：① 优化代码及 SQL；② 变同步为异步；③ 合并写请求。

2. 变同步为异步：

   • 优点：① 无需等待，减少响应时间；② 利用 MQ 暂存消息，流量削峰整形作用；③ 降低写频率，减轻数据库并发压力。

   • 缺点：① 依赖MQ可靠性；② 没有降低数据库写次数，仅仅降低写频率。

4. 合并写请求：

   • 优点：① 写缓存速度快，大大减少响应时间；② 降低了数据库写频率和写次数，减轻数据库并发压力。

   • 缺点：① 实现相对复杂；② 依赖缓存系统可靠性；③ 不支持事务和复杂业务。

3.3.2 播放进度优化方案

1. 优化方案选择：

   提交播放进度业务虽然看起来复杂，但大多数请求的处理很简单，就是更新播放进度。

   并且播放进度数据是可以合并的（覆盖之前旧数据），所以采用合并写请求方案。

2. Redis 数据结构设计：

   • KEY：课表 id（用户 id + 课程 id）：lessonId

   • HashKey：小节 id：sectionId

   • HashValue：记录 id：id，播放进度：moment，是否学完：finished

3. 持久化思路：

3.3.3 延迟任务

1. 延迟任务方案：

2. DelayQueue 的原理：

首先来看一下 DelayQueue 的源码：

xxxxxxxxxx
public class DelayQueue<E extends Delayed> extends AbstractQueue<E> implements BlockingQueue<E> {
    private final transient ReentrantLock lock = new ReentrantLock();
    private final PriorityQueue<E> q = new PriorityQueue<E>();
}

可以看到 DelayQueue 实现了 BlockingQueue 接口，是一个阻塞队列。DelayQueue 叫延迟队列，其中存储的就是延迟执行的任务。

根据 DelayQueue 的泛型定义，可知存入队列的元素必须是 Delayed 类型，这其实就是一个延迟任务的规范接口：

xxxxxxxxxx
public interface Delayed extends Comparable<Delayed> {
    long getDelay(TimeUnit unit);
}

可以看出Delayed 类型必须具备两个方法：getDelay()：获取任务剩余延迟时间；compareTo(T t)：根据延迟时间判断执行顺序。

3.3.4 代码改造

1. 定义延迟任务工具类：（了解）

xxxxxxxxxx
package com.tianji.learning.utils;

public class LearningRecordDelayTaskHandler {
    // 1. 查询 Redis 缓存中的指定小节的播放记录
    public LearningRecord readRecordCache(Long lessonId, Long sectionId) {...}
    // 2. 删除 Redis 缓存中的指定小节的播放记录
    public void cleanRecordCache(Long lessonId, Long sectionId) {...}
    // 3.1 添加播放记录到 Redis
    public void writeRecordCache(LearningRecord record) {...}
    // 3.2 添加一个延迟检测任务到 DelayQueue
    public void addLearningRecordTask(LearningRecord record) {...}
    // 4. 异步执行 DelayQueue 中的延迟检测任务，检测播放进度是否变化，如果无变化则写入数据库
    private void handleDelayTask() {...}
}

2. 改造提交学习记录功能：

xxxxxxxxxx
public void addLearningRecord(LearningRecordFormDTO recordDTO) {
    if (!finished) return;                  // 如果未学完, 直接返回, 不操作数据库
}

private LearningRecord queryOldRecord(Long lessonId, Long sectionId) {
    // ...                                  // 1. 查询 Redis 缓存中的指定小节的播放记录
    LearningRecord record = taskHandler.readRecordCache(lessonId, sectionId);
    if (record != null) return record;
    record = lambdaQuery()
        .eq(LearningRecord::getLessonId, lessonId)
        .eq(LearningRecord::getSectionId, sectionId).one();
    taskHandler.writeRecordCache(record);   // 3.1 添加播放记录到 Redis
    return record;
}

private boolean handleVideoRecord(Long userId, LearningRecordFormDTO recordDTO) {
    // ...                                  // 3.2 添加一个延迟检测任务到 DelayQueue
    if (!finished) {
        LearningRecord record = new LearningRecord();
        record.setLessonId(recordDTO.getLessonId());
        record.setSectionId(recordDTO.getSectionId());
        record.setMoment(recordDTO.getMoment());
        record.setId(old.getId());
        record.setFinished(old.getFinished());
        taskHandler.addLearningRecordTask(record);
        return false;
    }   
    // ...                                  // 2. 删除 Redis 缓存中的指定小节的播放记录
    taskHandler.cleanRecordCache(recordDTO.getLessonId(), recordDTO.getSectionId());
}

xxxxxxxxxx
private void handleLearningLessonsChanges(LearningRecordFormDTO recordDTO, boolean finished) {
    LearningLesson lesson = lessonService.getById(recordDTO.getLessonId());
    if (lesson == null) throw new BizIllegalException("课程不存在，无法更新数据！");
    CourseFullInfoDTO cInfo = courseClient.getCourseInfoById(lesson.getCourseId(), false, false);
    if (cInfo == null) throw new BizIllegalException("课程不存在，无法更新数据！");

    boolean allLearned = false;
    allLearned = lesson.getLearnedSections() + 1 >= cInfo.getSectionNum();
    lessonService.lambdaUpdate()
        // 如果是第一次观看视频，则设置 lesson 为正在学习
        .set(lesson.getLearnedSections() == 0, LearningLesson::getStatus, LessonStatus.LEARNING.getValue())
        // 如果学完全部小节，则更新 lesson 为完成状态、完成时间
        .set(allLearned, LearningLesson::getStatus, LessonStatus.FINISHED.getValue())
        .set(allLearned, LearningLesson::getFinishTime, LocalDateTime.now())
        // 如果已学完小节，则课表已学习小节数量 + 1
        .setSql("learned_sections = learned_sections + 1")
        .eq(LearningLesson::getId, lesson.getId()).update();
}

3.3.5 线程池的使用 (作业)

需求：目前我们的延迟任务执行还是单线程模式，大家将其改造为线程池模式，核心线程数与CPU核数一致即可。

xxxxxxxxxx
package com.tianji.learning.utils;

public class LearningRecordDelayTaskHandler {
    // 建议1. 如果任务为 cpu 运算型，核心线程适合设置为 cpu 核心数
    // 建议2. 如果任务为 io 型，推荐设置为 cpu 最大线程数
    static ThreadPoolExecutor poolExecutor = 
        new ThreadPoolExecutor(16, 5, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>(10));

    private void handleDelayTask(){
        try {
            poolExecutor.submit(new Runnable() {...});
        } catch (Exception e) {
            log.error("处理播放记录任务发生异常", e);
        }
    }
}

3.4 面试题

3.4.1 你负责学习系统的设计和开发，那能不能讲讲是如何设计的？

答：我参与了整个学习中心的功能开发，其中有很多的学习辅助功能都很有特色。比如视频播放的进度记录。

我们网站的课程是以录播视频为主，为了提高用户体验，需要实现续播功能。功能本身并不复杂，只不过我们产品提出的要求比较高：

• 首先续播时间误差要控制在 30 秒以内

• 而且要做到用户突然断开，甚至切换设备后，都可以继续上一次播放

要达成这个目的，传统的手段显然是不行的。首先，要做到切换设备后还能续播，用户的播放进度必须保存在服务端，而不是客户端。

其次，续播的时间误差不能超过 30 秒，那播放进度的记录频率就需要比较高。我们会在前端每隔 15 秒就发起一次心跳请求，提交最新的播放进度，记录到服务端。这样用户下一次续播时直接读取服务端的播放进度，就可以将时间误差控制在 15 秒左右。

3.4.2 播放进度保存在服务端哪里？如果写在数据库，那压力是不是太大了？

答：提交播放记录最终肯定是要保存到数据库中的。 因为我们不仅要做视频续播，还有用户学习计划、学习进度统计等功能，都需要用到用户的播放记录数据。

但确实如你所说，前端每隔 15 秒一次请求，如果在用户量较大时，直接全部写入数据库，对数据库压力会比较大。

因此我们采用了合并写请求的方案，当用户提交播放进度时会先缓存在 Redis 中，后续再将数据保存到数据库即可。 由于播放进度会不断覆盖，只保留最后一次即可。这样就可以大大减少对于数据库的访问次数和访问频率了。

Day04 - 问答系统

4.1 分析产品原型

4.1.1 分析业务流程

1. 分析业务流程：

2. 统计接口：

4.1.2 设计业务接口

1. 新增互动问题（C 端）：

2. 修改互动问题（C 端）：

3. 分页查询问题（C 端）：

4. 查询问题详情（C 端）：

5. 删除互动问题（C 端）：

xxxxxxxxxx
{   // 请求参数：
    "pageNo":  1,                                   // 页码
    "pageSize": 5,                                  // 每页大小
    "courseName": "课程名称",
    "status": 1,                                    // 问题状态，1-已查看、0-未查看
    "beginTime": "2023-01-01 12:00:00",             // 提问时间的最小值
    "endTime": "2023-01-02 12:00:00",               // 提问时间的最大值
}

{   // 返回值：
    "list": [
        {
            "id": "问题id",
            "title": "问题标题",
            "description": "问题描述",
            "chapterName": "章名称",
            "sectionName": "小节名称",
            "courseName": "课程名称",
            "categoryName": "分类名称1/分类名称2/分类名称3",
            "userName": "提问者昵称"
            "answerTimes": 0,                       // 回答数量            
            "createTime": "2022-7-18 19:52:36",
            "hidden": true,
            "status": 0,                            // 问题状态：0-未查看；1-已查看
        }
    ],
    "pages": 0,                                     // 总页数
    "total": 0                                      // 总条数
}

6. 分页查询问题（B 端）：

7. 查询问题详情（B 端）：

8. 隐藏显示问题（B 端）：

9. 新增回答或评论（C 端）：

10. 分页查询回答或评论（C 端）：

xxxxxxxxxx
{   // 请求参数：
    "pageNo":  1,                           // 页码
    "pageSize": 5,                          // 每页大小
    "courseName": "课程名称", 
    "status": 1,                            // 问题状态，1-已查看、0-未查看
    "beginTime": "2023-01-01 12:00:00",     // 提问时间的最小值
    "endTime": "2023-01-02 12:00:00",       // 提问时间的最大值
}

{   // 返回值：
    "list": [
        {
            "id": "问题id",
            "title": "问题标题",
            "description": "问题描述",
            "chapterName": "章名称",
            "sectionName": "小节名称",
            "courseName": "课程名称",
            "categoryName": "分类名称1/分类名称2/分类名称3",
            "userName": "提问者昵称"
            "answerTimes": 0,               // 回答数量            
            "createTime": "2022-7-18 19:52:36",
            "hidden": true,
            "status": 0,                    // 问题状态：0-未查看；1-已查看
        }
    ],
    "pages": 0,                             // 总页数
    "total": 0                              // 总条数
}

11. 分页查询回答或评论（B 端）：

12. 隐藏显示回答或评论（B 端）：

4.1.3 抽取业务实体

1. 问题表 interaction_question：

xxxxxxxxxx
CREATE TABLE IF NOT EXISTS `interaction_question` (
    `id` bigint NOT NULL COMMENT '主键，互动问题的id',
    `title` varchar(255) CHARACTER SET utf8mb4  NOT NULL COMMENT '互动问题的标题',
    `description` varchar(2048) CHARACTER SET utf8mb4  NOT NULL DEFAULT '' COMMENT '问题描述信息',
    `course_id` bigint NOT NULL COMMENT '所属课程id',
    `chapter_id` bigint NOT NULL COMMENT '所属课程章id',
    `section_id` bigint NOT NULL COMMENT '所属课程节id',
    `user_id` bigint NOT NULL COMMENT '提问学员id',
    `latest_answer_id` bigint DEFAULT NULL COMMENT '最新的一个回答的id',
    `answer_times` int unsigned NOT NULL DEFAULT '0' COMMENT '问题下的回答数量',
    `anonymity` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否匿名，默认false',
    `hidden` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否被隐藏，默认false',
    `status` tinyint DEFAULT '0' COMMENT '管理端问题状态：0-未查看，1-已查看',
    `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '提问时间',
    `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (`id`) USING BTREE,
    KEY `idx_course_id` (`course_id`) USING BTREE,
    KEY `section_id` (`section_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC COMMENT='互动提问的问题表';

2. 回答、评论表 interaction_reply：

xxxxxxxxxx
CREATE TABLE IF NOT EXISTS `interaction_reply` (
    `id` bigint NOT NULL COMMENT '互动问题的回答id',
    `question_id` bigint NOT NULL COMMENT '互动问题问题id',
    `answer_id` bigint DEFAULT '0' COMMENT '回复的上级回答id',
    `user_id` bigint NOT NULL COMMENT '回答者id',
    `content` varchar(255) CHARACTER SET utf8mb4 NOT NULL COMMENT '回答内容',
    `target_user_id` bigint DEFAULT '0' COMMENT '回复的目标用户id',
    `target_reply_id` bigint DEFAULT '0' COMMENT '回复的目标回复id',
    `reply_times` int NOT NULL DEFAULT '0' COMMENT '回答下的评论数量',
    `liked_times` int NOT NULL DEFAULT '0' COMMENT '点赞数量',
    `hidden` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否被隐藏，默认false',
    `anonymity` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否匿名，默认false',
    `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (`id`) USING BTREE,
    KEY `idx_question_id` (`question_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC COMMENT='互动问题的回答或评论';

4.2 开发接口功能

4.2.1 新增互动问题（C 端）

• 需求：在课程详情页，或者用户学习视频页面，都可以对当前课程提出疑问。

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@RestController
@RequestMapping("/questions")
@RequiredArgsConstructor
public class InteractionQuestionController {
    @ApiOperation("新增互动问题")
    @PostMapping
    public void saveQuestion(@Valid @RequestBody QuestionFormDTO questionDTO){
        questionService.saveQuestion(questionDTO);
    }
}

2. Service 层：

xxxxxxxxxx
@Override
@Transactional
public void saveQuestion(QuestionFormDTO questionDTO) {
    Long userId = UserContext.getUser();
    InteractionQuestion question = BeanUtils.toBean(questionDTO, InteractionQuestion.class);
    question.setUserId(userId);
    save(question);
}

4.2.2 修改互动问题（C 端）

• 需求：在课程详情页，用户可以对自己提出的问题做编辑，修改问题的相关信息。

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@ApiOperation("修改互动问题")
@PutMapping("{id}")
public void updateQuestion(@PathVariable("id") Long id, @RequestBody QuestionFormDTO questionDTO){
    questionService.updateQuestion(id, questionDTO);
}

2. Service 层：

xxxxxxxxxx
@Override
public void updateQuestion(Long id, QuestionFormDTO questionDTO) {
    if(StringUtils.isBlank(questionDTO.getTitle())              // 标题为空
       || StringUtils.isBlank(questionDTO.getDescription())     // 描述为空
       || questionDTO.getAnonymity() == null){                  // 匿名为空
        throw new BadRequestException("请求参数不能为空");
    }
    InteractionQuestion question = getById(id);
    if(question == null) {
        throw new BizIllegalException("该问题已被删除");
    }
    question.setTitle(questionDTO.getTitle());
    question.setDescription(questionDTO.getDescription());
    question.setAnonymity(questionDTO.getAnonymity());
    updateById(question);
}

4.2.3 分页查询问题（C 端）

• 需求：在课程详情页或视频学习页面，都可以分页查询课程相关的问题列表，数据较多采用分页查询。

1. Controller 层：

xxxxxxxxxx
package com.tianji.learning.controller;

@ApiOperation("分页查询问题")
@GetMapping("page")
public PageDTO<QuestionVO> queryQuestionPage(QuestionPageQuery query){
    return questionService.queryQuestionPage(query);
}

2. Service 层：

xxxxxxxxxx
private final InteractionReplyMapper replyMapper;
private final UserClient userClient;

@Override
public PageDTO<QuestionVO> queryQuestionPage(QuestionPageQuery query) {
    // 1. 判断课程 id 和小节 id 是否为空
    Long courseId = query.getCourseId();
    Long sectionId = query.getSectionId();
    if (courseId == null && sectionId == null) {
        throw new BadRequestException("课程id和小节id不能都为空");
    }
    // 2. 分页查询
    Page<InteractionQuestion> page = lambdaQuery()
        .select(InteractionQuestion.class, info -> !info.getProperty().equals("description"))
        .eq(query.getOnlyMine(), InteractionQuestion::getUserId, UserContext.getUser())
        .eq(courseId != null, InteractionQuestion::getCourseId, courseId)
        .eq(sectionId != null, InteractionQuestion::getSectionId, sectionId)
        .eq(InteractionQuestion::getHidden, false)
        .page(query.toMpPageDefaultSortByCreateTimeDesc());
    List<InteractionQuestion> records = page.getRecords();
    if (CollUtils.isEmpty(records)) {
        return PageDTO.empty(page);
    }
    
    // 3. 根据 id 查询提问者和最近一次回答的信息
    Set<Long> userIds = new HashSet<>();
    Set<Long> answerIds = new HashSet<>();
    // 3.1 得到提问者 id 和最近一次回答 id
    for (InteractionQuestion q : records) {
        if(!q.getAnonymity()) 
            userIds.add(q.getUserId());                 // 匿名问题直接忽略
        answerIds.add(q.getLatestAnswerId());
    }
    // 3.2 根据 id 查询最近一次回答的信息
    answerIds.remove(null);
    Map<Long, InteractionReply> replyMap = new HashMap<>(answerIds.size());
    if(CollUtils.isNotEmpty(answerIds)) {
        List<InteractionReply> replies = replyMapper.selectBatchIds(answerIds);
        for (InteractionReply reply : replies) {
            replyMap.put(reply.getId(), reply);
            if(!reply.getAnonymity())
                userIds.add(reply.getUserId());         // 匿名用户直接忽略
        }
    }
    // 3.3.根据 id 查询提问者的信息
    userIds.remove(null);
    Map<Long, UserDTO> userMap = new HashMap<>(userIds.size());
    if(CollUtils.isNotEmpty(userIds)) {
        List<UserDTO> users = userClient.queryUserByIds(userIds);
        userMap = users.stream().collect(Collectors.toMap(UserDTO::getId, u -> u));
    }
    
    // 4. 封装 VO 并返回
    List<QuestionVO> voList = new ArrayList<>(records.size());
    for (InteractionQuestion r : records) {
        // 4.1 将 PO 拷贝到 VO
        QuestionVO vo = BeanUtils.copyBean(r, QuestionVO.class);
        vo.setUserId(null);
        voList.add(vo);
        // 4.2 封装提问者的信息
        if(!r.getAnonymity()){
            UserDTO userDTO = userMap.get(r.getUserId());
            if (userDTO != null) {
                vo.setUserId(userDTO.getId());
                vo.setUserName(userDTO.getName());
                vo.setUserIcon(userDTO.getIcon());
            }
        }
        // 4.3 封装最近一次回答的信息
        InteractionReply reply = replyMap.get(r.getLatestAnswerId());
        if (reply != null) {
            vo.setLatestReplyContent(reply.getContent());
            if(!reply.getAnonymity()){                  // 匿名用户直接忽略
                UserDTO user = userMap.get(reply.getUserId());
                vo.setLatestReplyUser(user.getName());
            }

        }
    }
    return PageDTO.of(page, voList);
}