崔智尧

src-源文件/main/java/com/yf/exam/modules/paper/controller/PaperController.java

@@ -1,13 +1,19 @@
-package com.yf.exam.modules.paper.controller;
+package com.yf.exam.modules.paper.controller;  // 定义当前类所在的包路径
 
+// 引入分页查询结果的接口
 import com.baomidou.mybatisplus.core.metadata.IPage;
+// 引入统一的API响应封装类
 import com.yf.exam.core.api.ApiRest;
+// 引入基础控制器类，提供通用的API响应方法
 import com.yf.exam.core.api.controller.BaseController;
+// 引入各种DTO类，用于请求和响应数据传输
 import com.yf.exam.core.api.dto.BaseIdReqDTO;
 import com.yf.exam.core.api.dto.BaseIdRespDTO;
 import com.yf.exam.core.api.dto.BaseIdsReqDTO;
 import com.yf.exam.core.api.dto.PagingReqDTO;
+// 引入工具类，用于对象之间的属性拷贝
 import com.yf.exam.core.utils.BeanMapper;
+// 引入试卷相关的DTO类
 import com.yf.exam.modules.paper.dto.PaperDTO;
 import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
 import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO;
@@ -17,14 +23,22 @@ import com.yf.exam.modules.paper.dto.request.PaperQuQueryDTO;
 import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO;
 import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO;
 import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
+// 引入试卷实体类
 import com.yf.exam.modules.paper.entity.Paper;
+// 引入试卷相关的业务处理服务类
 import com.yf.exam.modules.paper.service.PaperService;
+// 引入用户工具类，获取当前登录用户信息
 import com.yf.exam.modules.user.UserUtils;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
+// 引入Shiro注解，用于角色权限管理
 import org.apache.shiro.authz.annotation.RequiresRoles;
+// 引入Spring的Bean工具类，用于属性复制
 import org.springframework.beans.BeanUtils;
+// 引入Spring的自动注入注解，用于自动注入服务
 import org.springframework.beans.factory.annotation.Autowired;
+// 引入Spring的Web注解，定义HTTP请求的映射方式
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
@@ -34,123 +48,126 @@ import org.springframework.web.bind.annotation.RestController;
 * <p>
 * 试卷控制器
 * </p>
-*
+* 提供有关试卷的操作，如分页查询、创建试卷、查看试卷详情等
 * @author 聪明笨狗
 * @since 2020-05-25 16:33
 */
-@Api(tags={"试卷"})
-@RestController
-@RequestMapping("/exam/api/paper/paper")
-public class PaperController extends BaseController {
+@Api(tags={"试卷"})  // Swagger API 文档注解，用于描述该接口属于试卷相关操作
+@RestController  // 标记为Spring的控制器，处理HTTP请求
+@RequestMapping("/exam/api/paper/paper")  // 定义请求路径的基础路径
+public class PaperController extends BaseController {  // 继承BaseController类，提供基本的API返回
 
-    @Autowired
+    @Autowired  // 自动注入PaperService，负责业务逻辑处理
     private PaperService baseService;
 
     /**
-     * 分页查找
-     * @param reqDTO
-     * @return
+     * 分页查找试卷列表
+     * @param reqDTO 包含分页信息和查询条件的请求数据
+     * @return 分页后的试卷列表
      */
-    @ApiOperation(value = "分页查找")
-    @RequestMapping(value = "/paging", method = { RequestMethod.POST})
+    @ApiOperation(value = "分页查找")  // Swagger操作注解，用于描述接口
+    @RequestMapping(value = "/paging", method = { RequestMethod.POST})  // 定义POST请求路径
     public ApiRest<IPage<PaperListRespDTO>> paging(@RequestBody PagingReqDTO<PaperListReqDTO> reqDTO) {
-        //分页查询并转换
+        // 调用业务层进行分页查询
         IPage<PaperListRespDTO> page = baseService.paging(reqDTO);
+        // 返回成功响应，并附带查询结果
         return super.success(page);
     }
 
-
-
     /**
      * 创建试卷
-     * @param reqDTO
-     * @return
+     * @param reqDTO 创建试卷所需的请求数据
+     * @return 返回创建成功后的试卷ID
      */
-    @ApiOperation(value = "创建试卷")
-    @RequestMapping(value = "/create-paper", method = { RequestMethod.POST})
+    @ApiOperation(value = "创建试卷")  // Swagger操作注解，用于描述接口
+    @RequestMapping(value = "/create-paper", method = { RequestMethod.POST})  // 定义POST请求路径
     public ApiRest<BaseIdRespDTO> save(@RequestBody PaperCreateReqDTO reqDTO) {
-        //复制参数
+        // 调用业务层创建试卷，传入当前用户ID和考试ID
         String paperId = baseService.createPaper(UserUtils.getUserId(), reqDTO.getExamId());
+        // 返回创建结果，包括试卷ID
         return super.success(new BaseIdRespDTO(paperId));
     }
 
     /**
-     * 批量删除
-     * @param reqDTO
-     * @return
+     * 获取试卷详情
+     * @param reqDTO 请求参数，包含试卷ID
+     * @return 返回试卷的详细信息
      */
-    @ApiOperation(value = "试卷详情")
-    @RequestMapping(value = "/paper-detail", method = { RequestMethod.POST})
+    @ApiOperation(value = "试卷详情")  // Swagger操作注解，用于描述接口
+    @RequestMapping(value = "/paper-detail", method = { RequestMethod.POST})  // 定义POST请求路径
     public ApiRest<ExamDetailRespDTO> paperDetail(@RequestBody BaseIdReqDTO reqDTO) {
-        //根据ID删除
+        // 调用业务层获取试卷详情
         ExamDetailRespDTO respDTO = baseService.paperDetail(reqDTO.getId());
+        // 返回成功响应，并附带试卷详情
         return super.success(respDTO);
     }
 
     /**
-     * 批量删除
-     * @param reqDTO
-     * @return
+     * 获取试题详情
+     * @param reqDTO 请求参数，包含试卷ID和试题ID
+     * @return 返回试题的详细信息
      */
-    @ApiOperation(value = "试题详情")
-    @RequestMapping(value = "/qu-detail", method = { RequestMethod.POST})
+    @ApiOperation(value = "试题详情")  // Swagger操作注解，用于描述接口
+    @RequestMapping(value = "/qu-detail", method = { RequestMethod.POST})  // 定义POST请求路径
     public ApiRest<PaperQuDetailDTO> quDetail(@RequestBody PaperQuQueryDTO reqDTO) {
-        //根据ID删除
+        // 调用业务层获取试题详情
         PaperQuDetailDTO respDTO = baseService.findQuDetail(reqDTO.getPaperId(), reqDTO.getQuId());
+        // 返回成功响应，并附带试题详情
         return super.success(respDTO);
     }
 
     /**
      * 填充答案
-     * @param reqDTO
-     * @return
+     * @param reqDTO 请求数据，包含填充的答案
+     * @return 返回操作成功的响应
      */
-    @ApiOperation(value = "填充答案")
-    @RequestMapping(value = "/fill-answer", method = { RequestMethod.POST})
+    @ApiOperation(value = "填充答案")  // Swagger操作注解，用于描述接口
+    @RequestMapping(value = "/fill-answer", method = { RequestMethod.POST})  // 定义POST请求路径
     public ApiRest<PaperQuDetailDTO> fillAnswer(@RequestBody PaperAnswerDTO reqDTO) {
-        //根据ID删除
+        // 调用业务层填充答案操作
         baseService.fillAnswer(reqDTO);
+        // 返回成功响应
         return super.success();
     }
 
-
     /**
      * 交卷操作
-     * @param reqDTO
-     * @return
+     * @param reqDTO 请求数据，包含试卷ID
+     * @return 返回交卷操作成功的响应
      */
-    @ApiOperation(value = "交卷操作")
-    @RequestMapping(value = "/hand-exam", method = { RequestMethod.POST})
+    @ApiOperation(value = "交卷操作")  // Swagger操作注解，用于描述接口
+    @RequestMapping(value = "/hand-exam", method = { RequestMethod.POST})  // 定义POST请求路径
     public ApiRest<PaperQuDetailDTO> handleExam(@RequestBody BaseIdReqDTO reqDTO) {
-        //根据ID删除
+        // 调用业务层进行交卷操作
         baseService.handExam(reqDTO.getId());
+        // 返回成功响应
         return super.success();
     }
 
-
     /**
-     * 批量删除
-     * @param reqDTO
-     * @return
+     * 获取试卷结果
+     * @param reqDTO 请求数据，包含试卷ID
+     * @return 返回试卷的考试结果
      */
-    @ApiOperation(value = "试卷详情")
-    @RequestMapping(value = "/paper-result", method = { RequestMethod.POST})
+    @ApiOperation(value = "试卷结果")  // Swagger操作注解，用于描述接口
+    @RequestMapping(value = "/paper-result", method = { RequestMethod.POST})  // 定义POST请求路径
     public ApiRest<ExamResultRespDTO> paperResult(@RequestBody BaseIdReqDTO reqDTO) {
-        //根据ID删除
+        // 调用业务层获取试卷的考试结果
         ExamResultRespDTO respDTO = baseService.paperResult(reqDTO.getId());
+        // 返回成功响应，并附带试卷结果
         return super.success(respDTO);
     }
 
-
     /**
      * 检测用户有没有中断的考试
-     * @return
+     * @return 返回用户未完成的考试信息
      */
-    @ApiOperation(value = "检测进行中的考试")
-    @RequestMapping(value = "/check-process", method = { RequestMethod.POST})
+    @ApiOperation(value = "检测进行中的考试")  // Swagger操作注解，用于描述接口
+    @RequestMapping(value = "/check-process", method = { RequestMethod.POST})  // 定义POST请求路径
     public ApiRest<PaperDTO> checkProcess() {
-        //复制参数
+        // 调用业务层检测用户是否有未完成的考试
         PaperDTO dto = baseService.checkProcess(UserUtils.getUserId());
+        // 返回成功响应，并附带考试进程数据
         return super.success(dto);
     }
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperDTO.java

@@ -1,79 +1,83 @@
-package com.yf.exam.modules.paper.dto;
+package com.yf.exam.modules.paper.dto;  // 定义当前类所在的包路径
 
+// 引入Dict注解，用于字典表的映射
 import com.yf.exam.core.annon.Dict;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入Serializable接口，用于对象序列化
 import java.io.Serializable;
+// 引入Date类，用于表示日期和时间
 import java.util.Date;
 
 /**
-* <p>
-* 试卷请求类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@ApiModel(value="试卷", description="试卷")
-public class PaperDTO implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
+ * <p>
+ * 试卷请求类
+ * </p>
+ * 该类用于传输试卷的基本信息，包含试卷的ID、考试规则、标题、时长、得分等字段。
+ * 提供了试卷的详细信息，通常在查询和展示试卷时使用。
+ * 
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷", description="试卷")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class PaperDTO implements Serializable {  // 实现Serializable接口，表示该类的对象可以被序列化
 
-    @ApiModelProperty(value = "试卷ID", required=true)
-    private String id;
+    private static final long serialVersionUID = 1L;  // 序列化版本ID，用于序列化和反序列化操作
 
-    @Dict(dictTable = "sys_user", dicText = "real_name", dicCode = "id")
-    @ApiModelProperty(value = "用户ID", required=true)
-    private String userId;
+    @ApiModelProperty(value = "试卷ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String id;  // 试卷ID
 
-    @Dict(dictTable = "sys_depart", dicText = "dept_name", dicCode = "id")
-    @ApiModelProperty(value = "部门ID", required=true)
-    private String departId;
+    @Dict(dictTable = "sys_user", dicText = "real_name", dicCode = "id")  // 字典表映射，映射用户表的姓名字段
+    @ApiModelProperty(value = "用户ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String userId;  // 用户ID
 
-    @ApiModelProperty(value = "规则ID", required=true)
-    private String examId;
+    @Dict(dictTable = "sys_depart", dicText = "dept_name", dicCode = "id")  // 字典表映射，映射部门表的部门名称字段
+    @ApiModelProperty(value = "部门ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String departId;  // 部门ID
 
-    @ApiModelProperty(value = "考试标题", required=true)
-    private String title;
+    @ApiModelProperty(value = "规则ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String examId;  // 规则ID，表示该试卷对应的考试规则
 
-    @ApiModelProperty(value = "考试时长", required=true)
-    private Integer totalTime;
+    @ApiModelProperty(value = "考试标题", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String title;  // 考试标题，表示试卷的名称
 
-    @ApiModelProperty(value = "用户时长", required=true)
-    private Integer userTime;
+    @ApiModelProperty(value = "考试时长", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer totalTime;  // 考试时长（单位：分钟）
 
-    @ApiModelProperty(value = "试卷总分", required=true)
-    private Integer totalScore;
+    @ApiModelProperty(value = "用户时长", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer userTime;  // 用户已使用的时间（单位：分钟）
 
-    @ApiModelProperty(value = "及格分", required=true)
-    private Integer qualifyScore;
+    @ApiModelProperty(value = "试卷总分", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer totalScore;  // 试卷总分
 
-    @ApiModelProperty(value = "客观分", required=true)
-    private Integer objScore;
+    @ApiModelProperty(value = "及格分", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer qualifyScore;  // 及格分数
 
-    @ApiModelProperty(value = "主观分", required=true)
-    private Integer subjScore;
+    @ApiModelProperty(value = "客观分", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer objScore;  // 客观题分数
 
-    @ApiModelProperty(value = "用户得分", required=true)
-    private Integer userScore;
+    @ApiModelProperty(value = "主观分", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer subjScore;  // 主观题分数
 
-    @ApiModelProperty(value = "是否包含简答题", required=true)
-    private Boolean hasSaq;
+    @ApiModelProperty(value = "用户得分", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer userScore;  // 用户得分
 
-    @ApiModelProperty(value = "试卷状态", required=true)
-    private Integer state;
+    @ApiModelProperty(value = "是否包含简答题", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Boolean hasSaq;  // 是否包含简答题，布尔类型，表示该试卷是否有简答题
 
-    @ApiModelProperty(value = "创建时间", required=true)
-    private Date createTime;
+    @ApiModelProperty(value = "试卷状态", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer state;  // 试卷状态，表示试卷的当前状态，如未开始、进行中、已结束等
 
-    @ApiModelProperty(value = "更新时间", required=true)
-    private Date updateTime;
+    @ApiModelProperty(value = "创建时间", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Date createTime;  // 创建时间，表示试卷的创建时间
 
-    @ApiModelProperty(value = "截止时间")
-    private Date limitTime;
+    @ApiModelProperty(value = "更新时间", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Date updateTime;  // 更新时间，表示试卷的最后更新时间
 
+    @ApiModelProperty(value = "截止时间")  // Swagger注解，描述该字段在API文档中的含义
+    private Date limitTime;  // 截止时间，表示考试的最后提交时间
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuAnswerDTO.java

@@ -1,48 +1,50 @@
-package com.yf.exam.modules.paper.dto;
+package com.yf.exam.modules.paper.dto;  // 定义当前类所在的包路径
 
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入Serializable接口，用于对象序列化
 import java.io.Serializable;
 
 /**
-* <p>
-* 试卷考题备选答案请求类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")
-public class PaperQuAnswerDTO implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
+ * <p>
+ * 试卷考题备选答案请求类
+ * </p>
+ * 该类用于表示试卷考题的备选答案，包含每个备选答案的ID、题目ID、选项标签、是否选中等信息。
+ * 适用于考题答案的请求传输。
+ * 
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class PaperQuAnswerDTO implements Serializable {  // 实现Serializable接口，表示该类的对象可以被序列化
 
-    @ApiModelProperty(value = "自增ID", required=true)
-    private String id;
+    private static final long serialVersionUID = 1L;  // 序列化版本ID，用于序列化和反序列化操作
 
-    @ApiModelProperty(value = "试卷ID", required=true)
-    private String paperId;
+    @ApiModelProperty(value = "自增ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String id;  // 自增ID，表示备选答案的唯一标识符
 
-    @ApiModelProperty(value = "回答项ID", required=true)
-    private String answerId;
+    @ApiModelProperty(value = "试卷ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String paperId;  // 试卷ID，表示该备选答案所属的试卷
 
-    @ApiModelProperty(value = "题目ID", required=true)
-    private String quId;
+    @ApiModelProperty(value = "回答项ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String answerId;  // 回答项ID，表示该备选答案的唯一标识符
 
-    @ApiModelProperty(value = "是否正确项", required=true)
-    private Boolean isRight;
+    @ApiModelProperty(value = "题目ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String quId;  // 题目ID，表示该备选答案所属的题目
 
-    @ApiModelProperty(value = "是否选中", required=true)
-    private Boolean checked;
+    @ApiModelProperty(value = "是否正确项", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Boolean isRight;  // 是否正确项，布尔值，表示该备选答案是否是正确答案
 
-    @ApiModelProperty(value = "排序", required=true)
-    private Integer sort;
+    @ApiModelProperty(value = "是否选中", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Boolean checked;  // 是否选中，布尔值，表示该备选答案是否已被选中
 
-    @ApiModelProperty(value = "选项标签", required=true)
-    private String abc;
+    @ApiModelProperty(value = "排序", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer sort;  // 排序，表示该备选答案在题目中的排序位置
 
+    @ApiModelProperty(value = "选项标签", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String abc;  // 选项标签，通常为 A、B、C、D 等，表示该备选答案的标识符
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/PaperQuDTO.java

@@ -1,54 +1,55 @@
-package com.yf.exam.modules.paper.dto;
+package com.yf.exam.modules.paper.dto;  // 定义当前类所在的包路径
 
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入Serializable接口，用于对象序列化
 import java.io.Serializable;
 
 /**
-* <p>
-* 试卷考题请求类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@ApiModel(value="试卷考题", description="试卷考题")
-public class PaperQuDTO implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
+ * <p>
+ * 试卷考题请求类
+ * </p>
+ * 该类用于表示试卷中的每一道题目，包含题目的基本信息，如题目ID、试卷ID、题目类型、是否答对、得分等。
+ * 
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷考题", description="试卷考题")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class PaperQuDTO implements Serializable {  // 实现Serializable接口，表示该类的对象可以被序列化
 
-    @ApiModelProperty(value = "ID", required=true)
-    private String id;
+    private static final long serialVersionUID = 1L;  // 序列化版本ID，用于序列化和反序列化操作
 
-    @ApiModelProperty(value = "试卷ID", required=true)
-    private String paperId;
+    @ApiModelProperty(value = "ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String id;  // 题目ID，唯一标识符
 
-    @ApiModelProperty(value = "题目ID", required=true)
-    private String quId;
+    @ApiModelProperty(value = "试卷ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String paperId;  // 试卷ID，表示该题目所属的试卷
 
-    @ApiModelProperty(value = "题目类型", required=true)
-    private Integer quType;
+    @ApiModelProperty(value = "题目ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String quId;  // 题目ID，唯一标识该题目
 
-    @ApiModelProperty(value = "是否已答", required=true)
-    private Boolean answered;
+    @ApiModelProperty(value = "题目类型", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer quType;  // 题目类型，表示题目的分类，如选择题、判断题、主观题等
 
-    @ApiModelProperty(value = "主观答案", required=true)
-    private String answer;
+    @ApiModelProperty(value = "是否已答", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Boolean answered;  // 是否已答，布尔值，表示该题目是否已被回答
 
-    @ApiModelProperty(value = "问题排序", required=true)
-    private Integer sort;
+    @ApiModelProperty(value = "主观答案", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String answer;  // 主观答案，表示对该题目的回答内容（适用于主观题）
 
-    @ApiModelProperty(value = "单题分分值", required=true)
-    private Integer score;
+    @ApiModelProperty(value = "问题排序", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer sort;  // 问题排序，表示该题目在试卷中的顺序
 
-    @ApiModelProperty(value = "实际得分(主观题)", required=true)
-    private Integer actualScore;
+    @ApiModelProperty(value = "单题分分值", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer score;  // 单题分值，表示该题目的满分
 
-    @ApiModelProperty(value = "是否答对", required=true)
-    private Boolean isRight;
+    @ApiModelProperty(value = "实际得分(主观题)", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer actualScore;  // 实际得分，表示用户在该题目中实际得到的分数（适用于主观题）
 
+    @ApiModelProperty(value = "是否答对", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Boolean isRight;  // 是否答对，布尔值，表示用户是否答对了该题目
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuAnswerExtDTO.java

@@ -1,29 +1,30 @@
-package com.yf.exam.modules.paper.dto.ext;
+package com.yf.exam.modules.paper.dto.ext;  // 定义该类所在的包路径
 
+// 引入试题答案DTO类，作为当前类的父类
 import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
 
 /**
 * <p>
 * 试卷考题备选答案请求类
 * </p>
-*
+* 该类用于描述试卷考题的备选答案信息，继承自PaperQuAnswerDTO，扩展了额外的字段，如图片和内容。
 * @author 聪明笨狗
 * @since 2020-05-25 17:31
 */
-@Data
-@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")
-public class PaperQuAnswerExtDTO extends PaperQuAnswerDTO {
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")  // Swagger注解，描述模型信息，生成API文档时使用
+public class PaperQuAnswerExtDTO extends PaperQuAnswerDTO {  // 继承自PaperQuAnswerDTO类，扩展了额外属性
 
-    private static final long serialVersionUID = 1L;
-
-    @ApiModelProperty(value = "试题图片", required=true)
-    private String image;
-
-    @ApiModelProperty(value = "答案内容", required=true)
-    private String content;
+    private static final long serialVersionUID = 1L;  // 序列化版本号，用于序列化和反序列化时的版本控制
 
+    @ApiModelProperty(value = "试题图片", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String image;  // 试题对应的图片内容
 
+    @ApiModelProperty(value = "答案内容", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String content;  // 备选答案的具体内容
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuDetailDTO.java

@@ -1,32 +1,35 @@
-package com.yf.exam.modules.paper.dto.ext;
+package com.yf.exam.modules.paper.dto.ext;  // 定义当前类所在的包路径
 
+// 引入试题DTO类，作为当前类的父类
 import com.yf.exam.modules.paper.dto.PaperQuDTO;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入List集合，用于存储多个备选答案
 import java.util.List;
 
 /**
 * <p>
 * 试卷考题请求类
 * </p>
-*
+* 该类用于描述试卷中每个考题的详细信息，继承自PaperQuDTO，扩展了试题的图片、内容和答案列表等字段。
 * @author 聪明笨狗
 * @since 2020-05-25 17:31
 */
-@Data
-@ApiModel(value="试卷题目详情类", description="试卷题目详情类")
-public class PaperQuDetailDTO extends PaperQuDTO {
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷题目详情类", description="试卷题目详情类")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class PaperQuDetailDTO extends PaperQuDTO {  // 继承自PaperQuDTO类，扩展了额外属性
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;  // 序列化版本号，用于序列化和反序列化时的版本控制
 
-    @ApiModelProperty(value = "图片", required=true)
-    private String image;
+    @ApiModelProperty(value = "图片", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String image;  // 题目的图片内容
 
-    @ApiModelProperty(value = "题目内容", required=true)
-    private String content;
+    @ApiModelProperty(value = "题目内容", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String content;  // 试题的具体内容
 
-    @ApiModelProperty(value = "答案内容", required=true)
-    List<PaperQuAnswerExtDTO> answerList;
+    @ApiModelProperty(value = "答案内容", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private List<PaperQuAnswerExtDTO> answerList;  // 存储该题目的备选答案，使用List集合存储多个答案
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperAnswerDTO.java

@@ -1,22 +1,25 @@
-package com.yf.exam.modules.paper.dto.request;
+package com.yf.exam.modules.paper.dto.request;  // 定义当前类所在的包路径
 
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入List集合，用于存储多个答案
 import java.util.List;
 
 /**
  * @author bool
+ * 查找试卷题目详情请求类，用于接收查找试卷题目详情的请求数据。
+ * 继承自PaperQuQueryDTO，扩展了回答列表和主观答案字段。
  */
-@Data
-@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")
-public class PaperAnswerDTO extends PaperQuQueryDTO {
-
-    @ApiModelProperty(value = "回答列表", required=true)
-    private List<String> answers;
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class PaperAnswerDTO extends PaperQuQueryDTO {  // 继承自PaperQuQueryDTO类，扩展了额外属性
 
-    @ApiModelProperty(value = "主观答案", required=true)
-    private String answer;
+    @ApiModelProperty(value = "回答列表", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private List<String> answers;  // 存储多个选择题答案的列表
 
+    @ApiModelProperty(value = "主观答案", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String answer;  // 存储主观题的答案内容
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperCreateReqDTO.java

@@ -1,22 +1,26 @@
-package com.yf.exam.modules.paper.dto.request;
+package com.yf.exam.modules.paper.dto.request;  // 定义当前类所在的包路径
 
+// 引入父类BaseDTO，用于继承基础字段和功能
 import com.yf.exam.core.api.dto.BaseDTO;
+// 引入Jackson注解，用于处理JSON序列化时忽略某些字段
 import com.fasterxml.jackson.annotation.JsonIgnore;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
 
 /**
  * @author bool
+ * 试卷创建请求类，用于接收试卷创建的请求数据，包含考试ID和用户ID等字段。
  */
-@Data
-@ApiModel(value="试卷创建请求类", description="试卷创建请求类")
-public class PaperCreateReqDTO extends BaseDTO {
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷创建请求类", description="试卷创建请求类")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class PaperCreateReqDTO extends BaseDTO {  // 继承自BaseDTO类，扩展了考试ID和用户ID字段
 
-    @JsonIgnore
-    private String userId;
-
-    @ApiModelProperty(value = "考试ID", required=true)
-    private String examId;
+    @JsonIgnore  // Jackson注解，表示在进行JSON序列化/反序列化时忽略该字段
+    private String userId;  // 存储用户ID，通常用于标识发起请求的用户，但在JSON序列化中不会被传递
 
+    @ApiModelProperty(value = "考试ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String examId;  // 存储考试ID，用于创建试卷时指定关联的考试
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperListReqDTO.java

@@ -1,39 +1,40 @@
-package com.yf.exam.modules.paper.dto.request;
+package com.yf.exam.modules.paper.dto.request;  // 定义当前类所在的包路径
 
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入Serializable接口，用于对象序列化
 import java.io.Serializable;
 
 /**
 * <p>
 * 试卷请求类
 * </p>
-*
+* 该类用于接收请求数据，包含用户ID、部门ID、规则ID、用户昵称和试卷状态等信息，
+* 用于查询试卷列表。
 * @author 聪明笨狗
 * @since 2020-05-25 17:31
 */
-@Data
-@ApiModel(value="试卷", description="试卷")
-public class PaperListReqDTO implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
-    @ApiModelProperty(value = "用户ID", required=true)
-    private String userId;
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷", description="试卷")  // Swagger注解，描述该类在API文档中的作用和说明
+public class PaperListReqDTO implements Serializable {  // 实现Serializable接口，支持对象的序列化
 
-    @ApiModelProperty(value = "部门ID", required=true)
-    private String departId;
+    private static final long serialVersionUID = 1L;  // 序列化版本号，用于序列化和反序列化时的版本控制
 
-    @ApiModelProperty(value = "规则ID", required=true)
-    private String examId;
+    @ApiModelProperty(value = "用户ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String userId;  // 存储请求发起者的用户ID，通常用于标识用户
 
-    @ApiModelProperty(value = "用户昵称", required=true)
-    private String realName;
+    @ApiModelProperty(value = "部门ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String departId;  // 存储请求者所在部门的ID，用于查询特定部门的试卷
 
-    @ApiModelProperty(value = "试卷状态", required=true)
-    private Integer state;
+    @ApiModelProperty(value = "规则ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String examId;  // 存储与试卷相关的考试规则ID，用于标识试卷属于哪种考试
 
+    @ApiModelProperty(value = "用户昵称", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String realName;  // 存储用户的真实姓名，用于标识请求者
 
+    @ApiModelProperty(value = "试卷状态", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private Integer state;  // 存储试卷的状态，可能的值如：未开始、进行中、已完成等
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/request/PaperQuQueryDTO.java

@@ -1,21 +1,25 @@
-package com.yf.exam.modules.paper.dto.request;
+package com.yf.exam.modules.paper.dto.request;  // 定义当前类所在的包路径
 
+// 引入父类BaseDTO，用于继承基础字段和功能
 import com.yf.exam.core.api.dto.BaseDTO;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
 
 /**
  * @author bool
+ * 查找试卷题目详情请求类，用于接收试卷和题目详情查询的请求数据。
+ * 包含试卷ID和题目ID字段。
  */
-@Data
-@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")
-public class PaperQuQueryDTO extends BaseDTO {
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class PaperQuQueryDTO extends BaseDTO {  // 继承自BaseDTO类，扩展了试卷ID和题目ID字段
 
-    @ApiModelProperty(value = "试卷ID", required=true)
-    private String paperId;
-
-    @ApiModelProperty(value = "题目ID", required=true)
-    private String quId;
+    @ApiModelProperty(value = "试卷ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String paperId;  // 存储试卷ID，用于查询特定试卷的题目详情
 
+    @ApiModelProperty(value = "题目ID", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String quId;  // 存储题目ID，用于查询指定试卷中的某一道题目
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamDetailRespDTO.java

@@ -1,38 +1,48 @@
-package com.yf.exam.modules.paper.dto.response;
+package com.yf.exam.modules.paper.dto.response;  // 定义当前类所在的包路径
 
+// 引入父类PaperDTO，用于继承基础字段和功能
 import com.yf.exam.modules.paper.dto.PaperDTO;
+// 引入PaperQuDTO类，用于表示试题的DTO
 import com.yf.exam.modules.paper.dto.PaperQuDTO;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入Calendar类，用于时间计算
 import java.util.Calendar;
+// 引入List集合，用于存储试题列表
 import java.util.List;
 
-@Data
-@ApiModel(value="考试详情", description="考试详情")
-public class ExamDetailRespDTO extends PaperDTO {
-
+/**
+ * <p>
+ * 考试详情响应类
+ * </p>
+ * 该类继承自PaperDTO，扩展了多个属性，包含单选题、多选题、判断题的列表，
+ * 以及计算剩余时间的方法，用于提供考试的详细信息。
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="考试详情", description="考试详情")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class ExamDetailRespDTO extends PaperDTO {  // 继承自PaperDTO，表示考试详情响应DTO
 
-    @ApiModelProperty(value = "单选题列表", required=true)
-    private List<PaperQuDTO> radioList;
+    @ApiModelProperty(value = "单选题列表", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private List<PaperQuDTO> radioList;  // 存储单选题的列表，使用PaperQuDTO表示单个试题
 
-    @ApiModelProperty(value = "多选题列表", required=true)
-    private List<PaperQuDTO> multiList;
+    @ApiModelProperty(value = "多选题列表", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private List<PaperQuDTO> multiList;  // 存储多选题的列表，使用PaperQuDTO表示单个试题
 
-    @ApiModelProperty(value = "判断题", required=true)
-    private List<PaperQuDTO> judgeList;
+    @ApiModelProperty(value = "判断题", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private List<PaperQuDTO> judgeList;  // 存储判断题的列表，使用PaperQuDTO表示单个试题
 
-
-    @ApiModelProperty(value = "剩余结束秒数", required=true)
-    public Long getLeftSeconds(){
+    @ApiModelProperty(value = "剩余结束秒数", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    public Long getLeftSeconds(){  // 计算剩余时间的方法，返回剩余的秒数
 
         // 结束时间
-        Calendar cl = Calendar.getInstance();
-        cl.setTime(this.getCreateTime());
-        cl.add(Calendar.MINUTE, getTotalTime());
+        Calendar cl = Calendar.getInstance();  // 获取当前时间的Calendar实例
+        cl.setTime(this.getCreateTime());  // 设置Calendar的时间为试卷的创建时间
+        cl.add(Calendar.MINUTE, getTotalTime());  // 在创建时间的基础上加上试卷的总时间（分钟）
 
-        return (cl.getTimeInMillis() - System.currentTimeMillis()) / 1000;
+        // 计算剩余时间（单位：秒）
+        return (cl.getTimeInMillis() - System.currentTimeMillis()) / 1000;  // 返回剩余时间（当前时间到结束时间的差值，以秒为单位）
     }
-
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/response/ExamResultRespDTO.java

@@ -1,18 +1,29 @@
-package com.yf.exam.modules.paper.dto.response;
+package com.yf.exam.modules.paper.dto.response;  // 定义当前类所在的包路径
 
+// 引入父类PaperDTO，用于继承基础字段和功能
 import com.yf.exam.modules.paper.dto.PaperDTO;
+// 引入PaperQuDetailDTO类，用于表示试题详细信息
 import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入List集合，用于存储试题列表
 import java.util.List;
 
-@Data
-@ApiModel(value="考试结果展示响应类", description="考试结果展示响应类")
-public class ExamResultRespDTO extends PaperDTO {
+/**
+ * <p>
+ * 考试结果展示响应类
+ * </p>
+ * 该类继承自PaperDTO，扩展了问题列表字段，用于展示考试结果的详细信息。
+ * 包含试题的详细信息列表，返回考试时各个问题的答案或状态。
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="考试结果展示响应类", description="考试结果展示响应类")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class ExamResultRespDTO extends PaperDTO {  // 继承自PaperDTO，表示考试结果展示响应DTO
 
-    @ApiModelProperty(value = "问题列表", required=true)
-    private List<PaperQuDetailDTO> quList;
+    @ApiModelProperty(value = "问题列表", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private List<PaperQuDetailDTO> quList;  // 存储试题详细信息的列表，使用PaperQuDetailDTO表示每个试题的详细数据
 
 }

src-源文件/main/java/com/yf/exam/modules/paper/dto/response/PaperListRespDTO.java

@@ -1,26 +1,29 @@
-package com.yf.exam.modules.paper.dto.response;
+package com.yf.exam.modules.paper.dto.response;  // 定义当前类所在的包路径
 
+// 引入父类PaperDTO，用于继承基本的试卷信息
 import com.yf.exam.modules.paper.dto.PaperDTO;
+// 引入Swagger注解，用于API文档生成
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
 
 /**
-* <p>
-* 试卷请求类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@ApiModel(value="试卷列表响应类", description="试卷列表响应类")
-public class PaperListRespDTO extends PaperDTO {
-
-    private static final long serialVersionUID = 1L;
-
-    @ApiModelProperty(value = "人员", required=true)
-    private String realName;
+ * <p>
+ * 试卷列表响应类
+ * </p>
+ * 该类继承自PaperDTO，扩展了人员（realName）字段，用于展示试卷列表响应数据。
+ * 包含试卷的基本信息以及相关人员信息。
+ * 
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@ApiModel(value="试卷列表响应类", description="试卷列表响应类")  // Swagger注解，用于描述该类在API文档中的作用和说明
+public class PaperListRespDTO extends PaperDTO {  // 继承自PaperDTO，表示试卷列表响应DTO
 
+    private static final long serialVersionUID = 1L;  // 序列化版本ID，用于序列化和反序列化操作
 
+    @ApiModelProperty(value = "人员", required=true)  // Swagger注解，描述该字段在API文档中的含义，并标注该字段为必填项
+    private String realName;  // 存储人员姓名，用于表示与该试卷相关的人员信息
 }

src-源文件/main/java/com/yf/exam/modules/paper/entity/Paper.java

@@ -1,125 +1,104 @@
-package com.yf.exam.modules.paper.entity;
+package com.yf.exam.modules.paper.entity;  // 定义当前类所在的包路径
 
+// 引入MyBatis Plus的相关注解
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.baomidou.mybatisplus.extension.activerecord.Model;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 引入Date类，用于时间相关的字段
 import java.util.Date;
 
 /**
-* <p>
-* 试卷实体类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@TableName("el_paper")
-public class Paper extends Model<Paper> {
-
-    private static final long serialVersionUID = 1L;
+ * <p>
+ * 试卷实体类
+ * </p>
+ * 该类对应数据库中的 `el_paper` 表，用于表示试卷的相关信息。
+ * 
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@TableName("el_paper")  // MyBatis Plus注解，指定该实体类对应的数据库表名
+public class Paper extends Model<Paper> {  // 继承MyBatis Plus的Model类，提供了CRUD等基础操作
+
+    private static final long serialVersionUID = 1L;  // 序列化版本ID，用于序列化和反序列化操作
 
     /**
      * 试卷ID
      */
-    @TableId(value = "id", type = IdType.ASSIGN_ID)
-    private String id;
+    @TableId(value = "id", type = IdType.ASSIGN_ID)  // MyBatis Plus注解，指定主键字段及其生成策略
+    private String id;  // 试卷ID，唯一标识符
 
     /**
      * 用户ID
      */
-    @TableField("user_id")
-    private String userId;
+    @TableField("user_id")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private String userId;  // 用户ID，表示创建该试卷的用户
 
     /**
      * 部门ID
      */
-    @TableField("depart_id")
-    private String departId;
+    @TableField("depart_id")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private String departId;  // 部门ID，表示该试卷所属的部门
 
     /**
      * 规则ID
      */
-    @TableField("exam_id")
-    private String examId;
+    @TableField("exam_id")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private String examId;  // 规则ID，表示该试卷所属的考试规则
 
     /**
      * 考试标题
      */
-    private String title;
+    private String title;  // 考试标题，表示试卷的名称或标题
 
     /**
      * 考试时长
      */
-    @TableField("total_time")
-    private Integer totalTime;
+    @TableField("total_time")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer totalTime;  // 考试时长，单位为分钟
 
     /**
      * 用户时长
      */
-    @TableField("user_time")
-    private Integer userTime;
+    @TableField("user_time")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer userTime;  // 用户实际用时，单位为分钟
 
     /**
      * 试卷总分
      */
-    @TableField("total_score")
-    private Integer totalScore;
+    @TableField("total_score")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer totalScore;  // 试卷的总分数
 
     /**
      * 及格分
      */
-    @TableField("qualify_score")
-    private Integer qualifyScore;
+    @TableField("qualify_score")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer qualifyScore;  // 及格分数，表示通过该试卷的最低分数
 
     /**
      * 客观分
      */
-    @TableField("obj_score")
-    private Integer objScore;
+    @TableField("obj_score")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer objScore;  // 客观题部分的得分
 
     /**
      * 主观分
      */
-    @TableField("subj_score")
-    private Integer subjScore;
+    @TableField("subj_score")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer subjScore;  // 主观题部分的得分
 
     /**
      * 用户得分
      */
-    @TableField("user_score")
-    private Integer userScore;
+    @TableField("user_score")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer userScore;  // 用户在该试卷上的得分
 
     /**
      * 是否包含简答题
      */
-    @TableField("has_saq")
-    private Boolean hasSaq;
-
-    /**
-     * 试卷状态
-     */
-    private Integer state;
-
-    /**
-     * 创建时间
-     */
-    @TableField("create_time")
-    private Date createTime;
+    @TableField("has_saq")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
    
-    /**
-     * 更新时间
-     */
-    @TableField("update_time")
-    private Date updateTime;
-
-    /**
-     * 截止时间
-     */
-    @TableField("limit_time")
-    private Date limitTime;
-}

src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQu.java

@@ -1,80 +1,82 @@
-package com.yf.exam.modules.paper.entity;
+package com.yf.exam.modules.paper.entity;  // 定义当前类所在的包路径
 
+// 引入MyBatis Plus的相关注解
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.baomidou.mybatisplus.extension.activerecord.Model;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
 
 /**
-* <p>
-* 试卷考题实体类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@TableName("el_paper_qu")
-public class PaperQu extends Model<PaperQu> {
+ * <p>
+ * 试卷考题实体类
+ * </p>
+ * 该类对应数据库中的 `el_paper_qu` 表，用于表示与试卷相关的考题信息。
+ * 
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@TableName("el_paper_qu")  // MyBatis Plus注解，指定该实体类对应的数据库表名
+public class PaperQu extends Model<PaperQu> {  // 继承MyBatis Plus的Model类，提供了基础的CRUD等操作
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;  // 序列化版本ID，用于序列化和反序列化操作
 
     /**
      * ID
      */
-    @TableId(value = "id", type = IdType.ASSIGN_ID)
-    private String id;
+    @TableId(value = "id", type = IdType.ASSIGN_ID)  // MyBatis Plus注解，指定主键字段及其生成策略
+    private String id;  // 题目ID，唯一标识符
 
     /**
      * 试卷ID
      */
-    @TableField("paper_id")
-    private String paperId;
+    @TableField("paper_id")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private String paperId;  // 试卷ID，表示该题目所属的试卷ID
 
     /**
      * 题目ID
      */
-    @TableField("qu_id")
-    private String quId;
+    @TableField("qu_id")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private String quId;  // 题目ID，唯一标识符
 
     /**
      * 题目类型
      */
-    @TableField("qu_type")
-    private Integer quType;
+    @TableField("qu_type")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer quType;  // 题目类型，表示该题目属于哪种类型（例如单选题、多选题、主观题等）
 
     /**
      * 是否已答
      */
-    private Boolean answered;
+    private Boolean answered;  // 是否已经回答，布尔值，表示该题目是否已经被回答
 
     /**
      * 主观答案
      */
-    private String answer;
+    private String answer;  // 主观题的答案，保存用户的回答内容
 
     /**
      * 问题排序
      */
-    private Integer sort;
+    private Integer sort;  // 问题在试卷中的排序，决定题目的显示顺序
 
     /**
      * 单题分分值
      */
-    private Integer score;
+    private Integer score;  // 每道题的分值，表示该题目的得分值
 
     /**
      * 实际得分(主观题)
      */
-    @TableField("actual_score")
-    private Integer actualScore;
+    @TableField("actual_score")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Integer actualScore;  // 主观题的实际得分，可能与用户给出的答案相关
 
     /**
      * 是否答对
      */
-    @TableField("is_right")
-    private Boolean isRight;
-
+    @TableField("is_right")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Boolean isRight;  // 是否答对，布尔值，表示用户是否答对了该题目
 }

src-源文件/main/java/com/yf/exam/modules/paper/entity/PaperQuAnswer.java

@@ -1,68 +1,71 @@
-package com.yf.exam.modules.paper.entity;
+package com.yf.exam.modules.paper.entity;  // 定义当前类所在的包路径
 
+// 引入MyBatis Plus的相关注解
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.baomidou.mybatisplus.extension.activerecord.Model;
+// 引入Lombok注解，用于自动生成getter、setter等方法
 import lombok.Data;
 
 /**
-* <p>
-* 试卷考题备选答案实体类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 17:31
-*/
-@Data
-@TableName("el_paper_qu_answer")
-public class PaperQuAnswer extends Model<PaperQuAnswer> {
+ * <p>
+ * 试卷考题备选答案实体类
+ * </p>
+ * 该类对应数据库中的 `el_paper_qu_answer` 表，用于表示试卷考题的备选答案。
+ * 
+ * @author 聪明笨狗
+ * @since 2020-05-25 17:31
+ */
+@Data  // Lombok注解，自动生成getter、setter、toString、equals和hashCode方法
+@TableName("el_paper_qu_answer")  // MyBatis Plus注解，指定该实体类对应的数据库表名
+public class PaperQuAnswer extends Model<PaperQuAnswer> {  // 继承MyBatis Plus的Model类，提供了基础的CRUD等操作
 
+    private static final long serialVersionUID = 1L;  // 序列化版本ID，用于序列化和反序列化操作
 
     /**
      * 自增ID
      */
-    @TableId(value = "id", type = IdType.ASSIGN_ID)
-    private String id;
+    @TableId(value = "id", type = IdType.ASSIGN_ID)  // MyBatis Plus注解，指定主键字段及其生成策略
+    private String id;  // 唯一标识符ID，数据库中的主键
 
     /**
      * 试卷ID
      */
-    @TableField("paper_id")
-    private String paperId;
+    @TableField("paper_id")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private String paperId;  // 该备选答案对应的试卷ID
 
     /**
      * 回答项ID
      */
-    @TableField("answer_id")
-    private String answerId;
+    @TableField("answer_id")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private String answerId;  // 该备选答案的唯一标识符ID
 
     /**
      * 题目ID
      */
-    @TableField("qu_id")
-    private String quId;
+    @TableField("qu_id")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private String quId;  // 该备选答案所属的题目ID
 
     /**
      * 是否正确项
      */
-    @TableField("is_right")
-    private Boolean isRight;
+    @TableField("is_right")  // MyBatis Plus注解，指定字段与数据库表字段的映射关系
+    private Boolean isRight;  // 是否是正确答案，布尔值（true 表示正确，false 表示错误）
 
     /**
      * 是否选中
      */
-    private Boolean checked;
+    private Boolean checked;  // 该备选答案是否被选中，布尔值（true 表示已选中，false 表示未选中）
 
     /**
      * 排序
      */
-    private Integer sort;
+    private Integer sort;  // 备选答案的排序，决定该答案在选项中的位置
 
     /**
      * 选项标签
      */
-    private String abc;
-    
+    private String abc;  // 备选答案的标签，通常为A、B、C、D等，用于显示选项
 }

src-源文件/main/java/com/yf/exam/modules/paper/enums/ExamState.java

@@ -1,33 +1,38 @@
-package com.yf.exam.modules.paper.enums;
-
+package com.yf.exam.modules.paper.enums;  // 定义当前类所在的包路径
 
 /**
- * 考试状态
+ * <p>
+ * 考试状态枚举接口
+ * </p>
+ * 该接口定义了考试的不同状态，作为常量使用，帮助系统在处理考试过程中进行状态标识。
+ * 
  * @author bool
  * @date 2019-10-30 13:11
  */
 public interface ExamState {
 
-
     /**
      * 考试中
+     * 代表考试正在进行中，通常表示考试尚未结束，学生可以继续答题。
      */
     Integer ENABLE = 0;
 
     /**
      * 待阅卷
+     * 代表考试已经结束，但还没有开始批阅试卷，通常表示考试已经提交，等待教师或系统自动阅卷。
      */
     Integer DISABLED = 1;
 
     /**
      * 已完成
+     * 代表考试已经完成，阅卷完成，结果已公布，但没有开始考试。
      */
     Integer READY_START = 2;
 
     /**
      * 已结束
+     * 代表考试已经结束，不再接受任何操作，考试时间已超出，无法继续答题。
      */
     Integer OVERDUE = 3;
 
-    
 }

src-源文件/main/java/com/yf/exam/modules/paper/enums/PaperState.java

@@ -1,33 +1,38 @@
-package com.yf.exam.modules.paper.enums;
-
+package com.yf.exam.modules.paper.enums;  // 定义当前类所在的包路径
 
 /**
- * 试卷状态
+ * <p>
+ * 试卷状态枚举接口
+ * </p>
+ * 该接口定义了试卷的不同状态，作为常量使用，帮助系统在处理试卷过程中进行状态标识。
+ * 
  * @author bool
  * @date 2019-10-30 13:11
  */
 public interface PaperState {
 
-
     /**
      * 考试中
+     * 代表试卷正在进行中，学生正在参与考试，答题环节尚未结束。
      */
     Integer ING = 0;
 
     /**
      * 待阅卷
+     * 代表考试已经结束，试卷已经提交，正在等待阅卷（人工或系统自动阅卷）。
      */
     Integer WAIT_OPT = 1;
 
     /**
      * 已完成
+     * 代表试卷已完成，包括考试、阅卷等所有环节，成绩已经确定。
      */
     Integer FINISHED = 2;
 
     /**
      * 弃考
+     * 代表学生中途放弃考试，考试未完成，可能是由于学生主动退出或其他原因（如时间到期）导致考试中止。
      */
     Integer BREAK = 3;
 
-    
 }

src-源文件/main/java/com/yf/exam/modules/paper/job/BreakExamJob.java

@@ -1,45 +1,61 @@
-package com.yf.exam.modules.paper.job;
-
-import com.yf.exam.ability.job.service.JobService;
-import com.yf.exam.modules.paper.service.PaperService;
-import lombok.extern.log4j.Log4j2;
-import org.quartz.Job;
-import org.quartz.JobDetail;
-import org.quartz.JobExecutionContext;
-import org.quartz.JobExecutionException;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
+package com.yf.exam.modules.paper.job;  // 定义类所在的包路径
+
+import com.yf.exam.ability.job.service.JobService;  // 导入 JobService 类，用于获取任务数据
+import com.yf.exam.modules.paper.service.PaperService;  // 导入 PaperService 类，用于处理试卷相关的业务逻辑
+import lombok.extern.log4j.Log4j2;  // 引入 log4j2 日志工具
+import org.quartz.Job;  // 导入 Quartz 作业接口
+import org.quartz.JobDetail;  // 导入 Quartz JobDetail 类
+import org.quartz.JobExecutionContext;  // 导入 Quartz JobExecutionContext 类
+import org.quartz.JobExecutionException;  // 导入 Quartz JobExecutionException 类
+import org.springframework.beans.factory.annotation.Autowired;  // 引入 Spring 注解，用于自动注入依赖
+import org.springframework.stereotype.Component;  // 引入 Spring 组件注解，标识为 Spring Bean
 
 /**
  * 超时自动交卷任务
+ * <p>
+ * 该类是一个 Quartz 定时任务，用于在考试时间到期后强制交卷。
+ * 它在定时任务触发时调用 PaperService 进行强制交卷操作。
+ * </p>
+ * 
  * @author bool
  */
-@Log4j2
-@Component
+@Log4j2  // 启用 log4j2 日志记录
+@Component  // 标识该类为一个 Spring 组件，Spring 会自动将其注册为 Bean
 public class BreakExamJob implements Job {
 
+    // 自动注入 PaperService，用于处理与试卷相关的业务逻辑
     @Autowired
     private PaperService paperService;
 
+    /**
+     * 定时任务执行的方法
+     * 
+     * <p>
+     * Quartz 会在定时任务触发时调用此方法。该方法获取任务的详细信息，
+     * 并通过 PaperService 强制提交超时的考试。
+     * </p>
+     * 
+     * @param jobExecutionContext 包含了 Quartz 定时任务的上下文信息
+     * @throws JobExecutionException 如果任务执行过程中出现异常，将抛出该异常
+     */
     @Override
     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
 
-        JobDetail detail = jobExecutionContext.getJobDetail();
-        String name = detail.getKey().getName();
-        String group = detail.getKey().getGroup();
+        // 从 jobExecutionContext 中获取任务的详细信息
+        JobDetail detail = jobExecutionContext.getJobDetail();  // 获取任务详情
+        String name = detail.getKey().getName();  // 获取任务名称
+        String group = detail.getKey().getGroup();  // 获取任务分组
+        // 获取任务的附加数据，通常是任务触发时的相关参数
         String data = String.valueOf(detail.getJobDataMap().get(JobService.TASK_DATA));
 
+        // 打印任务执行日志，便于调试和跟踪
         log.info("++++++++++定时任务：处理到期的交卷");
         log.info("++++++++++jobName:{}", name);
         log.info("++++++++++jobGroup:{}", group);
         log.info("++++++++++taskData:{}", data);
 
-
-        // 强制交卷
+        // 调用 PaperService 进行强制交卷操作
+        // data 参数通常是考试 ID 或者某种标识符，用于识别需要交卷的考试
         paperService.handExam(data);
-
     }
-
-
-
 }

src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperMapper.java

@@ -1,39 +1,46 @@
-package com.yf.exam.modules.paper.mapper;
+package com.yf.exam.modules.paper.mapper;  // 定义类所在的包路径
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.yf.exam.modules.paper.dto.PaperDTO;
-import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;
-import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
-import com.yf.exam.modules.paper.entity.Paper;
-import org.apache.ibatis.annotations.Param;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;  // 引入 MyBatis-Plus 的 BaseMapper
+import com.baomidou.mybatisplus.core.metadata.IPage;  // 引入分页结果接口 IPage
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;  // 引入分页插件 Page
+import com.yf.exam.modules.paper.dto.PaperDTO;  // 引入 DTO 类，表示试卷数据传输对象
+import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;  // 引入请求 DTO 类，表示查询试卷时的请求参数
+import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;  // 引入响应 DTO 类，表示查询试卷时的响应结果
+import com.yf.exam.modules.paper.entity.Paper;  // 引入实体类，表示试卷数据表中的记录
+import org.apache.ibatis.annotations.Param;  // 引入 MyBatis 注解，用于指定 SQL 查询中的参数
 
 import java.util.List;
 
 /**
-* <p>
-* 试卷Mapper
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 16:33
-*/
-public interface PaperMapper extends BaseMapper<Paper> {
+ * <p>
+ * 试卷Mapper接口，用于操作试卷数据表
+ * </p>
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 16:33
+ */
+public interface PaperMapper extends BaseMapper<Paper> {  // 继承 MyBatis-Plus 提供的 BaseMapper，自动实现 CRUD 操作
 
     /**
      * 查找试卷分页
-     * @param page
-     * @param query
-     * @return
+     * <p>
+     * 根据分页参数 `Page` 和查询条件 `PaperListReqDTO` 返回试卷的分页结果。
+     * </p>
+     * 
+     * @param page 分页参数，包含当前页、每页大小等
+     * @param query 查询条件，通常包含用户 ID、考试 ID 等信息
+     * @return 返回一个分页结果 `IPage<PaperListRespDTO>`，包含了试卷数据和分页信息
      */
     IPage<PaperListRespDTO> paging(Page page, @Param("query") PaperListReqDTO query);
 
-
     /**
      * 试卷列表响应类
-     * @param query
-     * @return
+     * <p>
+     * 根据查询条件返回试卷的列表数据，通常用于返回所有试卷的列表。
+     * </p>
+     * 
+     * @param query 查询条件，通常是试卷的基本信息，如试卷 ID、考试 ID 等
+     * @return 返回一个试卷列表 `List<PaperListRespDTO>`，每一项是试卷的响应 DTO
      */
     List<PaperListRespDTO> list(@Param("query") PaperDTO query);
 }

src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuAnswerMapper.java

@@ -1,27 +1,33 @@
-package com.yf.exam.modules.paper.mapper;
+package com.yf.exam.modules.paper.mapper;  // 指定该类所在的包路径
 
+// 导入BaseMapper接口，提供通用的CRUD操作
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;  
+// 导入PaperQuAnswerExtDTO类，表示试卷考题备选答案的扩展数据传输对象
 import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;  
+// 导入PaperQuAnswer实体类，表示试卷考题备选答案的数据模型
 import com.yf.exam.modules.paper.entity.PaperQuAnswer;  
+// 导入MyBatis的注解，指定方法参数在SQL中的名称
 import org.apache.ibatis.annotations.Param;  
 
+// 导入List接口，表示返回类型为List集合，用于存储多个备选答案
 import java.util.List;  
 
 /**
 * <p>
-* 试卷考题备选答案Mapper
+* 试卷考题备选答案Mapper接口
 * </p>
+* 该接口用于处理试卷考题备选答案的数据库操作，继承自MyBatis-Plus的BaseMapper，提供通用的CRUD方法。
 * 
 * @author 聪明笨狗
 * @since 2020-05-25 16:33
 */
-public interface PaperQuAnswerMapper extends BaseMapper<PaperQuAnswer> {
+public interface PaperQuAnswerMapper extends BaseMapper<PaperQuAnswer> {  // 继承自BaseMapper接口，提供了所有的基本CRUD操作
 
     /**
      * 查找试卷试题答案列表
-     * @param paperId
-     * @param quId
-     * @return
+     * @param paperId 试卷ID，标识要查询的试卷
+     * @param quId 题目ID，标识要查询的题目
+     * @return 返回与试卷ID和题目ID相关的备选答案列表，包含更多的答案细节
      */
-    List<PaperQuAnswerExtDTO> list(@Param("paperId") String paperId, @Param("quId") String quId);
+    List<PaperQuAnswerExtDTO> list(@Param("paperId") String paperId, @Param("quId") String quId);  // 根据试卷ID和题目ID查询对应的备选答案列表
 }

src-源文件/main/java/com/yf/exam/modules/paper/mapper/PaperQuMapper.java

@@ -1,42 +1,46 @@
-package com.yf.exam.modules.paper.mapper;
+package com.yf.exam.modules.paper.mapper;  // 定义该类所在的包路径
 
+// 导入BaseMapper接口，提供MyBatis-Plus的通用CRUD操作
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;  
+// 导入PaperQuDetailDTO类，表示试卷考题详细数据传输对象
 import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;  
+// 导入PaperQu实体类，表示试卷考题的数据模型
 import com.yf.exam.modules.paper.entity.PaperQu;  
+// 导入MyBatis的@Param注解，用于方法参数与SQL查询中的参数进行映射
 import org.apache.ibatis.annotations.Param;  
 
+// 导入List接口，用于返回多个试题
 import java.util.List;  
 
 /**
 * <p>
-* 试卷考题Mapper
+* 试卷考题Mapper接口
 * </p>
+* 该接口用于处理与试卷考题相关的数据库操作，继承自MyBatis-Plus的BaseMapper，提供通用的CRUD操作。
 * 
 * @author 聪明笨狗
 * @since 2020-05-25 16:33
 */
-public interface PaperQuMapper extends BaseMapper<PaperQu> {
+public interface PaperQuMapper extends BaseMapper<PaperQu> {  // 继承自BaseMapper接口，提供通用的CRUD操作
 
     /**
      * 统计客观分
-     * @param paperId
-     * @return
+     * @param paperId 试卷ID，用于查询指定试卷的客观分数
+     * @return 返回试卷的客观分数总和
      */
-    int sumObjective(@Param("paperId") String paperId);
+    int sumObjective(@Param("paperId") String paperId);  // 根据试卷ID统计所有客观题的分数总和
 
     /**
      * 统计主观分
-     * @param paperId
-     * @return
+     * @param paperId 试卷ID，用于查询指定试卷的主观分数
+     * @return 返回试卷的主观分数总和
      */
-    int sumSubjective(@Param("paperId") String paperId);
+    int sumSubjective(@Param("paperId") String paperId);  // 根据试卷ID统计所有主观题的分数总和
 
     /**
      * 找出全部试题列表
-     * @param paperId
-     * @return
+     * @param paperId 试卷ID，用于查询指定试卷的所有试题
+     * @return 返回试卷中的所有试题列表，类型为PaperQuDetailDTO
      */
-    List<PaperQuDetailDTO> listByPaper(@Param("paperId") String paperId);
+    List<PaperQuDetailDTO> listByPaper(@Param("paperId") String paperId);  // 根据试卷ID查询所有试题的详细信息
 }
-
-

src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuAnswerService.java

@@ -1,18 +1,20 @@
+// 导入所需的包
 package com.yf.exam.modules.paper.service;
 
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.service.IService;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;
-import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
-import com.yf.exam.modules.paper.entity.PaperQuAnswer;
+import com.baomidou.mybatisplus.core.metadata.IPage;  // 用于分页查询
+import com.baomidou.mybatisplus.extension.service.IService;  // 用于继承通用服务接口
+import com.yf.exam.core.api.dto.PagingReqDTO;  // 分页请求DTO
+import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;  // 试卷问题答案DTO
+import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;  // 扩展的试卷问题答案DTO
+import com.yf.exam.modules.paper.entity.PaperQuAnswer;  // 试卷问题答案实体类
 
-import java.util.List;
+import java.util.List;  // 导入List类，用于处理集合数据
 
 /**
 * <p>
 * 试卷考题备选答案业务类
 * </p>
+* 该接口定义了与试卷考题备选答案相关的业务操作
 *
 * @author 聪明笨狗
 * @since 2020-05-25 16:33
@@ -21,24 +23,24 @@ public interface PaperQuAnswerService extends IService<PaperQuAnswer> {
 
     /**
     * 分页查询数据
-    * @param reqDTO
-    * @return
+    * @param reqDTO 分页请求DTO，包含查询的分页信息和条件
+    * @return 返回分页查询结果，包含 PaperQuAnswerDTO 对象的数据
     */
     IPage<PaperQuAnswerDTO> paging(PagingReqDTO<PaperQuAnswerDTO> reqDTO);
 
     /**
-     * 查找试卷试题答案列表
-     * @param paperId
-     * @param quId
-     * @return
+     * 查找试卷试题的答案列表
+     * @param paperId 试卷ID，用于定位试卷
+     * @param quId 试题ID，用于定位具体的试题
+     * @return 返回该试卷和试题的所有答案列表，数据类型为 PaperQuAnswerExtDTO
      */
     List<PaperQuAnswerExtDTO> listForExam(String paperId, String quId);
 
     /**
-     * 查找答案列表，用来填充
-     * @param paperId
-     * @param quId
-     * @return
+     * 查找答案列表，用来填充试卷答案
+     * @param paperId 试卷ID，用于定位试卷
+     * @param quId 试题ID，用于定位具体试题的答案
+     * @return 返回对应试题的答案列表，数据类型为 PaperQuAnswer 实体
      */
     List<PaperQuAnswer> listForFill(String paperId, String quId);
 }

src-源文件/main/java/com/yf/exam/modules/paper/service/PaperQuService.java

@@ -1,18 +1,20 @@
+// 导入所需的包
 package com.yf.exam.modules.paper.service;
 
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.service.IService;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.modules.paper.dto.PaperQuDTO;
-import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
-import com.yf.exam.modules.paper.entity.PaperQu;
+import com.baomidou.mybatisplus.core.metadata.IPage;  // 用于分页查询
+import com.baomidou.mybatisplus.extension.service.IService;  // 用于继承通用服务接口
+import com.yf.exam.core.api.dto.PagingReqDTO;  // 分页请求DTO
+import com.yf.exam.modules.paper.dto.PaperQuDTO;  // 试卷问题DTO
+import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;  // 试卷问题详情DTO
+import com.yf.exam.modules.paper.entity.PaperQu;  // 试卷问题实体类
 
-import java.util.List;
+import java.util.List;  // 导入List类，用于处理集合数据
 
 /**
 * <p>
 * 试卷考题业务类
 * </p>
+* 该接口定义了与试卷考题相关的业务操作
 *
 * @author 聪明笨狗
 * @since 2020-05-25 16:33
@@ -21,50 +23,50 @@ public interface PaperQuService extends IService<PaperQu> {
 
     /**
     * 分页查询数据
-    * @param reqDTO
-    * @return
+    * @param reqDTO 分页请求DTO，包含查询的分页信息和条件
+    * @return 返回分页查询结果，包含 PaperQuDTO 对象的数据
     */
     IPage<PaperQuDTO> paging(PagingReqDTO<PaperQuDTO> reqDTO);
 
     /**
      * 根据试卷找出题目列表
-     * @param paperId
-     * @return
+     * @param paperId 试卷ID，用于定位试卷
+     * @return 返回该试卷的所有题目列表，数据类型为 PaperQuDTO
      */
     List<PaperQuDTO> listByPaper(String paperId);
 
     /**
-     * 查找详情
-     * @param paperId
-     * @param quId
-     * @return
+     * 查找试卷中某个问题的详细信息
+     * @param paperId 试卷ID
+     * @param quId 试题ID，用于定位具体的试题
+     * @return 返回该试卷和试题的详细信息，数据类型为 PaperQu
      */
     PaperQu findByKey(String paperId, String quId);
 
     /**
-     * 根据组合索引更新
-     * @param qu
+     * 根据组合索引更新试题
+     * @param qu 试题实体，用于更新试卷中的试题
      */
     void updateByKey(PaperQu qu);
 
     /**
-     * 统计客观分
-     * @param paperId
-     * @return
+     * 统计试卷中所有客观题的总分
+     * @param paperId 试卷ID
+     * @return 返回该试卷客观题的总分
      */
     int sumObjective(String paperId);
 
     /**
-     * 统计主观分
-     * @param paperId
-     * @return
+     * 统计试卷中所有主观题的总分
+     * @param paperId 试卷ID
+     * @return 返回该试卷主观题的总分
      */
     int sumSubjective(String paperId);
 
     /**
-     * 找出全部试题列表
-     * @param paperId
-     * @return
+     * 查找试卷的全部试题列表（用于展示结果）
+     * @param paperId 试卷ID
+     * @return 返回该试卷的详细试题列表，数据类型为 PaperQuDetailDTO
      */
     List<PaperQuDetailDTO> listForPaperResult(String paperId);
 }

src-源文件/main/java/com/yf/exam/modules/paper/service/PaperService.java

@@ -1,21 +1,23 @@
+// 导入所需的包
 package com.yf.exam.modules.paper.service;
 
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.service.IService;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.modules.paper.dto.PaperDTO;
-import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
-import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO;
-import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;
-import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO;
-import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO;
-import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
-import com.yf.exam.modules.paper.entity.Paper;
+import com.baomidou.mybatisplus.core.metadata.IPage;  // 用于分页查询
+import com.baomidou.mybatisplus.extension.service.IService;  // 用于继承通用服务接口
+import com.yf.exam.core.api.dto.PagingReqDTO;  // 分页请求DTO
+import com.yf.exam.modules.paper.dto.PaperDTO;  // 试卷DTO
+import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;  // 试卷题目详情DTO
+import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO;  // 提交答案请求DTO
+import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;  // 试卷列表请求DTO
+import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO;  // 考试详情响应DTO
+import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO;  // 考试结果响应DTO
+import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;  // 试卷列表响应DTO
+import com.yf.exam.modules.paper.entity.Paper;  // 试卷实体类
 
 /**
 * <p>
 * 试卷业务类
 * </p>
+* 该接口定义了与试卷相关的所有业务操作
 *
 * @author 聪明笨狗
 * @since 2020-05-25 16:33
@@ -24,60 +26,57 @@ public interface PaperService extends IService<Paper> {
 
     /**
      * 创建试卷
-     * @param userId
-     * @param examId
-     * @return
+     * @param userId 用户ID，表示试卷创建者
+     * @param examId 考试ID，表示该试卷属于哪个考试
+     * @return 返回创建的试卷ID
      */
     String createPaper(String userId, String examId);
 
-
     /**
-     * 查找详情
-     * @param paperId
-     * @return
+     * 查找试卷详情
+     * @param paperId 试卷ID，表示要查找的试卷
+     * @return 返回试卷的详细信息，数据类型为 ExamDetailRespDTO
      */
     ExamDetailRespDTO paperDetail(String paperId);
 
     /**
-     * 考试结果
-     * @param paperId
-     * @return
+     * 获取考试结果
+     * @param paperId 试卷ID，表示要查询结果的试卷
+     * @return 返回该试卷的考试结果，数据类型为 ExamResultRespDTO
      */
     ExamResultRespDTO paperResult(String paperId);
 
     /**
-     * 查找题目详情
-     * @param paperId
-     * @param quId
-     * @return
+     * 查找试卷题目详情
+     * @param paperId 试卷ID
+     * @param quId 题目ID，表示要查询的具体题目
+     * @return 返回该试卷和题目的详细信息，数据类型为 PaperQuDetailDTO
      */
     PaperQuDetailDTO findQuDetail(String paperId, String quId);
 
     /**
-     * 填充答案
-     * @param reqDTO
+     * 填充试卷答案
+     * @param reqDTO 填写答案的请求DTO，包含试卷答案信息
      */
     void fillAnswer(PaperAnswerDTO reqDTO);
 
     /**
-     * 交卷操作
-     * @param paperId
-     * @return
+     * 提交试卷（交卷）
+     * @param paperId 试卷ID，表示要交卷的试卷
      */
     void handExam(String paperId);
 
     /**
-     * 试卷列表响应类
-     * @param reqDTO
-     * @return
+     * 分页查询试卷列表
+     * @param reqDTO 分页请求DTO，包含分页信息和查询条件
+     * @return 返回分页后的试卷列表，数据类型为 IPage<PaperListRespDTO>
      */
     IPage<PaperListRespDTO> paging(PagingReqDTO<PaperListReqDTO> reqDTO);
 
     /**
-     * 检测是否有进行中的考试
-     * @param userId
-     * @return
+     * 检查用户是否有正在进行的考试
+     * @param userId 用户ID，用于查找该用户是否有未完成的考试
+     * @return 返回该用户正在进行的考试试卷信息，数据类型为 PaperDTO
      */
     PaperDTO checkProcess(String userId);
-
 }

src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuAnswerServiceImpl.java

@@ -1,61 +1,95 @@
-package com.yf.exam.modules.paper.service.impl;
+package com.yf.exam.modules.paper.service.impl;  // 指定该类所在的包路径
 
+// 导入FastJSON库，用于处理JSON格式数据的转换
 import com.alibaba.fastjson.JSON;  
 import com.alibaba.fastjson.TypeReference;  
+// 导入MyBatis-Plus的条件查询构造器
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;  
+// 导入分页接口
 import com.baomidou.mybatisplus.core.metadata.IPage;  
+// 导入分页Page类
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;  
+// 导入MyBatis-Plus的服务实现类
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;  
+// 导入分页请求DTO，用于分页查询
 import com.yf.exam.core.api.dto.PagingReqDTO;  
+// 导入试卷考题备选答案DTO类
 import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;  
+// 导入试卷考题备选答案扩展DTO类
 import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;  
+// 导入试卷考题备选答案实体类
 import com.yf.exam.modules.paper.entity.PaperQuAnswer;  
+// 导入试卷考题备选答案Mapper接口
 import com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper;  
+// 导入试卷考题备选答案服务接口
 import com.yf.exam.modules.paper.service.PaperQuAnswerService;  
+// 导入Spring的Service注解，表示这是一个服务实现类
 import org.springframework.stereotype.Service;  
 
-import java.util.List;
+import java.util.List;  // 导入List接口，用于返回多个结果
 
 /**
 * <p>
-* 语言设置 服务实现类
+* 试卷考题备选答案 服务实现类
 * </p>
+* 该类实现了PaperQuAnswerService接口，处理与试卷考题备选答案相关的业务逻辑。
 * 
 * @author 聪明笨狗
 * @since 2020-05-25 16:33
 */
-@Service
-public class PaperQuAnswerServiceImpl extends ServiceImpl<PaperQuAnswerMapper, PaperQuAnswer> implements PaperQuAnswerService {
+@Service  // 标注为Spring的服务类
+public class PaperQuAnswerServiceImpl extends ServiceImpl<PaperQuAnswerMapper, PaperQuAnswer> implements PaperQuAnswerService {  // 继承ServiceImpl类，提供基本的数据库操作功能
 
+    /**
+     * 分页查询试卷考题备选答案
+     * @param reqDTO 分页请求参数，包括当前页和页面大小
+     * @return 分页后的试卷考题备选答案列表
+     */
     @Override
     public IPage<PaperQuAnswerDTO> paging(PagingReqDTO<PaperQuAnswerDTO> reqDTO) {
 
-        //创建分页对象
+        // 创建分页对象
         IPage<PaperQuAnswer> query = new Page<>(reqDTO.getCurrent(), reqDTO.getSize());
 
-        //查询条件
+        // 查询条件，可以根据需要添加更多过滤条件
         QueryWrapper<PaperQuAnswer> wrapper = new QueryWrapper<>();
 
-        //获得数据
+        // 执行分页查询操作
         IPage<PaperQuAnswer> page = this.page(query, wrapper);
-        //转换结果
+
+        // 将查询结果转换为DTO对象，返回分页后的结果
         IPage<PaperQuAnswerDTO> pageData = JSON.parseObject(JSON.toJSONString(page), new TypeReference<Page<PaperQuAnswerDTO>>(){});
-        return pageData;
+        
+        return pageData;  // 返回分页结果
     }
 
+    /**
+     * 根据试卷ID和题目ID查询试题的备选答案列表
+     * @param paperId 试卷ID
+     * @param quId 题目ID
+     * @return 试卷考题备选答案的扩展DTO列表
+     */
     @Override
     public List<PaperQuAnswerExtDTO> listForExam(String paperId, String quId) {
+        // 调用Mapper中的list方法，查询并返回试题的备选答案列表
         return baseMapper.list(paperId, quId);
     }
 
+    /**
+     * 查询填空题的备选答案
+     * @param paperId 试卷ID
+     * @param quId 题目ID
+     * @return 填空题的备选答案列表
+     */
     @Override
     public List<PaperQuAnswer> listForFill(String paperId, String quId) {
-        //查询条件
+        // 创建查询条件
         QueryWrapper<PaperQuAnswer> wrapper = new QueryWrapper<>();
-        wrapper.lambda()
-                .eq(PaperQuAnswer::getPaperId, paperId)
-                .eq(PaperQuAnswer::getQuId, quId);
+        wrapper.lambda()  // 使用Lambda表达式，进行条件构造
+                .eq(PaperQuAnswer::getPaperId, paperId)  // 通过试卷ID过滤
+                .eq(PaperQuAnswer::getQuId, quId);  // 通过题目ID过滤
 
+        // 查询并返回符合条件的结果列表
         return this.list(wrapper);
     }
 }

src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperQuServiceImpl.java

@@ -1,94 +1,150 @@
-package com.yf.exam.modules.paper.service.impl;
+package com.yf.exam.modules.paper.service.impl;  // 指定该类所在的包路径
 
+// 导入FastJSON库，用于处理JSON格式数据的转换
 import com.alibaba.fastjson.JSON;  
 import com.alibaba.fastjson.TypeReference;  
+// 导入MyBatis-Plus的条件查询构造器
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;  
+// 导入分页接口
 import com.baomidou.mybatisplus.core.metadata.IPage;  
+// 导入分页Page类
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;  
+// 导入MyBatis-Plus的服务实现类
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;  
+// 导入分页请求DTO，用于分页查询
 import com.yf.exam.core.api.dto.PagingReqDTO;  
+// 导入BeanMapper工具类，用于对象间的转换
 import com.yf.exam.core.utils.BeanMapper;  
+// 导入试卷考题DTO类
 import com.yf.exam.modules.paper.dto.PaperQuDTO;  
+// 导入试卷考题详情DTO类
 import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;  
+// 导入试卷考题实体类
 import com.yf.exam.modules.paper.entity.PaperQu;  
+// 导入试卷考题Mapper接口
 import com.yf.exam.modules.paper.mapper.PaperQuMapper;  
+// 导入试卷考题服务接口
 import com.yf.exam.modules.paper.service.PaperQuService;  
+// 导入Spring的Service注解，表示这是一个服务实现类
 import org.springframework.stereotype.Service;  
 
-import java.util.List;
+import java.util.List;  // 导入List接口，用于返回多个结果
 
 /**
 * <p>
-* 语言设置 服务实现类
+* 试卷考题 服务实现类
 * </p>
+* 该类实现了PaperQuService接口，处理与试卷考题相关的业务逻辑。
 * 
 * @author 聪明笨狗
 * @since 2020-05-25 16:33
 */
-@Service
-public class PaperQuServiceImpl extends ServiceImpl<PaperQuMapper, PaperQu> implements PaperQuService {
-
+@Service  // 标注为Spring的服务类
+public class PaperQuServiceImpl extends ServiceImpl<PaperQuMapper, PaperQu> implements PaperQuService {  // 继承ServiceImpl类，提供基本的数据库操作功能
+
+    /**
+     * 分页查询试卷考题
+     * @param reqDTO 分页请求参数，包括当前页和页面大小
+     * @return 分页后的试卷考题列表
+     */
     @Override
     public IPage<PaperQuDTO> paging(PagingReqDTO<PaperQuDTO> reqDTO) {
 
-        //创建分页对象
+        // 创建分页对象
         IPage<PaperQu> query = new Page<>(reqDTO.getCurrent(), reqDTO.getSize());
 
-        //查询条件
+        // 查询条件
         QueryWrapper<PaperQu> wrapper = new QueryWrapper<>();
 
-        //获得数据
+        // 执行分页查询操作
         IPage<PaperQu> page = this.page(query, wrapper);
-        //转换结果
+
+        // 将查询结果转换为DTO对象，返回分页后的结果
         IPage<PaperQuDTO> pageData = JSON.parseObject(JSON.toJSONString(page), new TypeReference<Page<PaperQuDTO>>(){});
-        return pageData;
+        
+        return pageData;  // 返回分页结果
     }
 
+    /**
+     * 根据试卷ID查询试卷考题列表
+     * @param paperId 试卷ID
+     * @return 试卷考题DTO列表
+     */
     @Override
     public List<PaperQuDTO> listByPaper(String paperId) {
 
-        //查询条件
+        // 查询条件
         QueryWrapper<PaperQu> wrapper = new QueryWrapper<>();
-        wrapper.lambda().eq(PaperQu::getPaperId, paperId)
-                .orderByAsc(PaperQu::getSort);
+        wrapper.lambda().eq(PaperQu::getPaperId, paperId)  // 通过试卷ID过滤
+                .orderByAsc(PaperQu::getSort);  // 按照题目排序字段升序排列
 
+        // 执行查询，获取试卷考题列表
         List<PaperQu> list = this.list(wrapper);
+        
+        // 使用BeanMapper工具类将实体对象列表转换为DTO对象列表
         return BeanMapper.mapList(list, PaperQuDTO.class);
     }
 
+    /**
+     * 根据试卷ID和题目ID查找单个试卷考题
+     * @param paperId 试卷ID
+     * @param quId 题目ID
+     * @return 找到的试卷考题对象
+     */
     @Override
     public PaperQu findByKey(String paperId, String quId) {
-        //查询条件
+        // 查询条件
         QueryWrapper<PaperQu> wrapper = new QueryWrapper<>();
-        wrapper.lambda().eq(PaperQu::getPaperId, paperId)
-                .eq(PaperQu::getQuId, quId);
+        wrapper.lambda().eq(PaperQu::getPaperId, paperId)  // 通过试卷ID过滤
+                .eq(PaperQu::getQuId, quId);  // 通过题目ID过滤
 
-        return this.getOne(wrapper, false);
+        // 获取匹配的单个试卷考题对象
+        return this.getOne(wrapper, false);  // 返回查询到的结果，false表示未查询到时返回null
     }
 
+    /**
+     * 根据试卷ID和题目ID更新试卷考题
+     * @param qu 需要更新的试卷考题对象
+     */
     @Override
     public void updateByKey(PaperQu qu) {
 
-        //查询条件
+        // 查询条件
         QueryWrapper<PaperQu> wrapper = new QueryWrapper<>();
-        wrapper.lambda().eq(PaperQu::getPaperId, qu.getPaperId())
-                .eq(PaperQu::getQuId, qu.getQuId());
+        wrapper.lambda().eq(PaperQu::getPaperId, qu.getPaperId())  // 通过试卷ID过滤
+                .eq(PaperQu::getQuId, qu.getQuId());  // 通过题目ID过滤
 
-        this.update(qu, wrapper);
+        // 执行更新操作
+        this.update(qu, wrapper);  // 更新满足条件的试卷考题
     }
 
+    /**
+     * 统计试卷中的客观题分数
+     * @param paperId 试卷ID
+     * @return 客观题的总分
+     */
     @Override
     public int sumObjective(String paperId) {
-        return baseMapper.sumObjective(paperId);
+        return baseMapper.sumObjective(paperId);  // 调用Mapper方法，统计客观题总分
     }
 
+    /**
+     * 统计试卷中的主观题分数
+     * @param paperId 试卷ID
+     * @return 主观题的总分
+     */
     @Override
     public int sumSubjective(String paperId) {
-        return baseMapper.sumSubjective(paperId);
+        return baseMapper.sumSubjective(paperId);  // 调用Mapper方法，统计主观题总分
     }
 
+    /**
+     * 根据试卷ID查询试卷考题的详细信息
+     * @param paperId 试卷ID
+     * @return 试卷考题详细信息列表
+     */
     @Override
     public List<PaperQuDetailDTO> listForPaperResult(String paperId) {
-        return baseMapper.listByPaper(paperId);
+        return baseMapper.listByPaper(paperId);  // 调用Mapper方法，获取试卷考题详细信息
     }
 }

src-源文件/main/java/com/yf/exam/modules/paper/service/impl/PaperServiceImpl.java

@@ -1,103 +1,167 @@
+// 定义包名，表示该类属于com.yf.exam.modules.paper.service.impl包下
 package com.yf.exam.modules.paper.service.impl;
 
+// 导入MyBatis Plus框架的核心类，用于构建查询条件
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+// 导入MyBatis Plus框架的分页功能相关类
 import com.baomidou.mybatisplus.core.metadata.IPage;
+// 导入MyBatis Plus框架的工具类，用于生成唯一ID
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+// 导入MyBatis Plus框架的服务实现类
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入项目中定义的作业组枚举
 import com.yf.exam.ability.job.enums.JobGroup;
+// 导入项目中定义的作业前缀枚举
 import com.yf.exam.ability.job.enums.JobPrefix;
+// 导入项目中的作业服务接口
 import com.yf.exam.ability.job.service.JobService;
+// 导入项目中定义的API错误码类
 import com.yf.exam.core.api.ApiError;
+// 导入项目中定义的DTO类，用于分页请求
 import com.yf.exam.core.api.dto.PagingReqDTO;
+// 导入项目中的服务异常类
 import com.yf.exam.core.exception.ServiceException;
+// 导入项目中定义的Bean映射工具类
 import com.yf.exam.core.utils.BeanMapper;
+// 导入项目中定义的Cron表达式工具类
 import com.yf.exam.core.utils.CronUtils;
+// 导入项目中定义的考试DTO类
 import com.yf.exam.modules.exam.dto.ExamDTO;
+// 导入项目中定义的考试题库DTO类
 import com.yf.exam.modules.exam.dto.ExamRepoDTO;
+// 导入项目中定义的扩展考试题库DTO类
 import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO;
+// 导入项目中的考试服务接口
 import com.yf.exam.modules.exam.service.ExamRepoService;
+// 导入项目中的考试服务接口
 import com.yf.exam.modules.exam.service.ExamService;
+// 导入项目中定义的试卷DTO类
 import com.yf.exam.modules.paper.dto.PaperDTO;
+// 导入项目中定义的试卷题目DTO类
 import com.yf.exam.modules.paper.dto.PaperQuDTO;
+// 导入项目中定义的扩展试卷题目答案DTO类
 import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
+// 导入项目中定义的试卷题目详情DTO类
 import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
+// 导入项目中定义的试卷答案DTO类
 import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO;
+// 导入项目中定义的试卷列表请求DTO类
 import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;
+// 导入项目中定义的试卷列表响应DTO类
 import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO;
+// 导入项目中定义的考试结果响应DTO类
 import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO;
+// 导入项目中定义的试卷列表响应DTO类
 import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
+// 导入项目中定义的试卷实体类
 import com.yf.exam.modules.paper.entity.Paper;
+// 导入项目中定义的试卷题目实体类
 import com.yf.exam.modules.paper.entity.PaperQu;
+// 导入项目中定义的试卷题目答案实体类
 import com.yf.exam.modules.paper.entity.PaperQuAnswer;
+// 导入项目中定义的考试状态枚举
 import com.yf.exam.modules.paper.enums.ExamState;
+// 导入项目中定义的试卷状态枚举
 import com.yf.exam.modules.paper.enums.PaperState;
+// 导入项目中定义的强制交卷作业类
 import com.yf.exam.modules.paper.job.BreakExamJob;
+// 导入项目中定义的试卷Mapper接口
 import com.yf.exam.modules.paper.mapper.PaperMapper;
+// 导入项目中定义的试卷题目服务接口
 import com.yf.exam.modules.paper.service.PaperQuAnswerService;
+// 导入项目中定义的试卷题目服务接口
 import com.yf.exam.modules.paper.service.PaperQuService;
+// 导入项目中定义的试卷服务接口
 import com.yf.exam.modules.paper.service.PaperService;
+// 导入项目中定义的题目实体类
 import com.yf.exam.modules.qu.entity.Qu;
+// 导入项目中定义的题目答案实体类
 import com.yf.exam.modules.qu.entity.QuAnswer;
+// 导入项目中定义的题目类型枚举
 import com.yf.exam.modules.qu.enums.QuType;
+// 导入项目中定义的题目服务接口
 import com.yf.exam.modules.qu.service.QuAnswerService;
+// 导入项目中定义的题目服务接口
 import com.yf.exam.modules.qu.service.QuService;
+// 导入项目中定义的系统用户实体类
 import com.yf.exam.modules.sys.user.entity.SysUser;
+// 导入项目中定义的系统用户服务接口
 import com.yf.exam.modules.sys.user.service.SysUserService;
+// 导入项目中定义的用户书籍服务接口
 import com.yf.exam.modules.user.book.service.UserBookService;
+// 导入项目中定义的用户考试服务接口
 import com.yf.exam.modules.user.exam.service.UserExamService;
+// 导入Apache Commons Lang库中的StringUtils类，用于字符串操作
 import org.apache.commons.lang3.StringUtils;
+// 导入Spring框架中的注解，用于自动注入依赖
 import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架中的注解，用于声明服务组件
 import org.springframework.stereotype.Service;
+// 导入Spring框架中的注解，用于声明事务管理
 import org.springframework.transaction.annotation.Transactional;
+// 导入Spring框架中的类，用于工具操作
 import org.springframework.util.CollectionUtils;
 
+// 导入Java.util包下的类，用于集合操作
 import java.util.*;
 
+// 定义语言设置服务实现类，继承自ServiceImpl，并实现PaperService接口
 /**
-* <p>
-* 语言设置 服务实现类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 16:33
-*/
+ * <p>
+ * 语言设置 服务实现类
+ * </p>
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 16:33
+ */
 @Service
 public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements PaperService {
 
-
+    // 自动注入系统用户服务
     @Autowired
     private SysUserService sysUserService;
 
+    // 自动注入考试服务
     @Autowired
     private ExamService examService;
 
+    // 自动注入题目服务
     @Autowired
     private QuService quService;
 
+    // 自动注入题目答案服务
     @Autowired
     private QuAnswerService quAnswerService;
 
+    // 自动注入试卷服务
     @Autowired
     private PaperService paperService;
 
+    // 自动注入试卷题目服务
     @Autowired
     private PaperQuService paperQuService;
 
+    // 自动注入试卷题目答案服务
     @Autowired
     private PaperQuAnswerService paperQuAnswerService;
 
+    // 自动注入用户书籍服务
     @Autowired
     private UserBookService userBookService;
 
+    // 自动注入考试题库服务
     @Autowired
     private ExamRepoService examRepoService;
 
+    // 自动注入用户考试服务
     @Autowired
     private UserExamService userExamService;
 
+    // 自动注入作业服务
     @Autowired
     private JobService jobService;
 
+    // 定义展示的选项，如ABC这样的选项列表
     /**
      * 展示的选项，ABC这样
      */
@@ -106,68 +170,83 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
             ,"Y","Z"
     });
 
-
-
-
-
+    // 声明创建试卷的方法，使用事务管理，如果发生异常则回滚
+    /**
+     * 创建试卷的方法
+     * @param userId 用户ID
+     * @param examId 考试ID
+     * @return 返回试卷ID
+     */
     @Transactional(rollbackFor = Exception.class)
     @Override
     public String createPaper(String userId, String examId) {
 
-        // 校验是否有正在考试的试卷
+        // 构建查询条件，查询是否有正在考试的试卷
         QueryWrapper<Paper> wrapper = new QueryWrapper<>();
         wrapper.lambda()
                 .eq(Paper::getUserId, userId)
                 .eq(Paper::getState, PaperState.ING);
 
+        // 统计符合条件的试卷数量
         int exists = this.count(wrapper);
 
-
+        // 如果存在正在考试的试卷，则抛出服务异常
         if (exists > 0) {
             throw new ServiceException(ApiError.ERROR_20010002);
         }
 
-        // 查找考试
+        // 根据考试ID查询考试信息
         ExamDTO exam = examService.findById(examId);
 
+        // 如果考试信息不存在，则抛出服务异常
         if(exam == null){
             throw new ServiceException(1, "考试不存在！");
         }
 
+        // 如果考试状态不正确，则抛出服务异常
         if(!ExamState.ENABLE.equals(exam.getState())){
             throw new ServiceException(1, "考试状态不正确！");
         }
 
-        // 考试题目列表
+        // 根据考试ID生成试卷题目列表
+
           List<PaperQu> quList = this.generateByRepo(examId);
 
+    // 如果题目列表为空，则抛出服务异常
     if(CollectionUtils.isEmpty(quList)){
         throw new ServiceException(1, "规则不正确，无对应的考题！");
     }
 
-        //保存试卷内容
+    // 保存试卷内容，并返回试卷ID
     Paper paper = this.savePaper(userId, exam, quList);
 
-        // 强制交卷任务
+    // 添加强制交卷任务
     String jobName = JobPrefix.BREAK_EXAM + paper.getId();
     jobService.addCronJob(BreakExamJob.class, jobName, CronUtils.dateToCron(paper.getLimitTime()), paper.getId());
 
     return paper.getId();
-    }
-
-    @Override
-    public ExamDetailRespDTO paperDetail(String paperId) {
+}
 
+// 声明查询试卷详情的方法
+/**
+ * 查询试卷详情的方法
+ * @param paperId 试卷ID
+ * @return 返回考试详情响应DTO
+ */
+@Override
+public ExamDetailRespDTO paperDetail(String paperId) {
 
+    // 创建考试详情响应DTO对象
     ExamDetailRespDTO respDTO = new ExamDetailRespDTO();
 
-        // 试题基本信息
+    // 根据试卷ID查询试卷基本信息，并复制到响应DTO中
     Paper paper = paperService.getById(paperId);
     BeanMapper.copy(paper, respDTO);
 
-        // 查找题目列表
+    // 根据试卷ID查询题目列表
     List<PaperQuDTO> list = paperQuService.listByPaper(paperId);
 
+    // 分类题目列表
     List<PaperQuDTO> radioList = new ArrayList<>();
     List<PaperQuDTO> multiList = new ArrayList<>();
     List<PaperQuDTO> judgeList = new ArrayList<>();
@@ -183,69 +262,87 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
         }
     }
 
+    // 设置分类后的题目列表到响应DTO中
     respDTO.setRadioList(radioList);
     respDTO.setMultiList(multiList);
     respDTO.setJudgeList(judgeList);
     return respDTO;
-    }
+}
 
-    @Override
-    public ExamResultRespDTO paperResult(String paperId) {
+// 声明查询试卷结果的方法
+/**
+ * 查询试卷结果的方法
+ * @param paperId 试卷ID
+ * @return 返回考试结果响应DTO
+ */
+@Override
+public ExamResultRespDTO paperResult(String paperId) {
 
+    // 创建考试结果响应DTO对象
     ExamResultRespDTO respDTO = new ExamResultRespDTO();
 
-        // 试题基本信息
+    // 根据试卷ID查询试卷基本信息，并复制到响应DTO中
     Paper paper = paperService.getById(paperId);
     BeanMapper.copy(paper, respDTO);
 
+    // 根据试卷ID查询题目列表
     List<PaperQuDetailDTO> quList = paperQuService.listForPaperResult(paperId);
     respDTO.setQuList(quList);
 
     return respDTO;
-    }
+}
 
-    @Override
-    public PaperQuDetailDTO findQuDetail(String paperId, String quId) {
+// 声明查询题目详情的方法
+/**
+ * 查询题目详情的方法
+ * @param paperId 试卷ID
+ * @param quId 题目ID
+ * @return 返回题目详情DTO
+ */
+@Override
+public PaperQuDetailDTO findQuDetail(String paperId, String quId) {
 
+    // 创建题目详情DTO对象
     PaperQuDetailDTO respDTO = new PaperQuDetailDTO();
-        // 问题
+    // 根据题目ID查询题目信息
     Qu qu = quService.getById(quId);
 
-        // 基本信息
+    // 根据试卷ID和题目ID查询试卷题目信息，并复制到响应DTO中
     PaperQu paperQu = paperQuService.findByKey(paperId, quId);
     BeanMapper.copy(paperQu, respDTO);
     respDTO.setContent(qu.getContent());
     respDTO.setImage(qu.getImage());
 
-        // 答案列表
+    // 根据试卷ID和题目ID查询答案列表，并设置到响应DTO中
     List<PaperQuAnswerExtDTO> list = paperQuAnswerService.listForExam(paperId, quId);
     respDTO.setAnswerList(list);
 
     return respDTO;
-    }
-
+}
 
-    /**
-     * 题库组题方式产生题目列表
-     * @param examId
-     * @return
+// 声明题库组题方式产生题目列表的私有方法
+/**
+ * 题库组题方式产生题目列表的方法
+ * @param examId 考试ID
+ * @return 返回题目列表
  */
-    private List<PaperQu> generateByRepo(String examId){
+private List<PaperQu> generateByRepo(String examId){
 
-        // 查找规则指定的题库
+    // 查询规则指定的题库
     List<ExamRepoExtDTO> list = examRepoService.listByExam(examId);
 
-        //最终的题目列表
+    // 最终的题目列表
     List<PaperQu> quList = new ArrayList<>();
 
-        //排除ID，避免题目重复
+    // 排除ID，避免题目重复
     List<String> excludes = new ArrayList<>();
     excludes.add("none");
 
+    // 如果题库列表不为空，则进行题目抽取
     if (!CollectionUtils.isEmpty(list)) {
         for (ExamRepoExtDTO item : list) {
 
-                // 单选题
+            // 抽取单选题
             if(item.getRadioCount() > 0){
                 List<Qu> radioList = quService.listByRandom(item.getRepoId(), QuType.RADIO, excludes, item.getRadioCount());
                 for (Qu qu : radioList) {
@@ -255,7 +352,7 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
                 }
             }
 
-                //多选题
+            // 抽取多选题
             if(item.getMultiCount() > 0) {
                 List<Qu> multiList = quService.listByRandom(item.getRepoId(), QuType.MULTI, excludes,
                         item.getMultiCount());
@@ -266,7 +363,7 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
                 }
             }
 
-                // 判断题
+            // 抽取判断题
             if(item.getJudgeCount() > 0) {
                 List<Qu> judgeList = quService.listByRandom(item.getRepoId(), QuType.JUDGE, excludes,
                         item.getJudgeCount());
@@ -279,58 +376,60 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
         }
     }
     return quList;
-    }
-
-
+}
 
-    /**
-     * 填充试题题目信息
-     * @param repo
-     * @param qu
-     * @return
+// 声明填充试题题目信息的私有方法
+/**
+ * 填充试题题目信息的方法
+ * @param repo 考试题库DTO
+ * @param qu 题目实体
+ * @return 返回试卷题目实体
  */
-    private PaperQu processPaperQu(ExamRepoDTO repo, Qu qu) {
+private PaperQu processPaperQu(ExamRepoDTO repo, Qu qu) {
 
-        //保存试题信息
+    // 创建试卷题目实体
     PaperQu paperQu = new PaperQu();
     paperQu.setQuId(qu.getId());
     paperQu.setAnswered(false);
     paperQu.setIsRight(false);
     paperQu.setQuType(qu.getQuType());
 
+    // 设置单选题分数
     if (QuType.RADIO.equals(qu.getQuType())) {
         paperQu.setScore(repo.getRadioScore());
         paperQu.setActualScore(repo.getRadioScore());
     }
 
+    // 设置多选题分数
     if (QuType.MULTI.equals(qu.getQuType())) {
         paperQu.setScore(repo.getMultiScore());
         paperQu.setActualScore(repo.getMultiScore());
     }
 
+    // 设置判断题分数
     if (QuType.JUDGE.equals(qu.getQuType())) {
         paperQu.setScore(repo.getJudgeScore());
         paperQu.setActualScore(repo.getJudgeScore());
     }
 
     return paperQu;
-    }
-
+}
 
-    /**
-     * 保存试卷
-     * @param userId
-     * @param exam
-     * @param quList
-     * @return
+// 声明保存试卷的私有方法
+/**
+ * 保存试卷的方法
+ * @param userId 用户ID
+ * @param exam 考试DTO
+ * @param quList 题目列表
+ * @return 返回试卷实体
  */
-    private Paper savePaper(String userId, ExamDTO exam, List<PaperQu> quList) {
+private Paper savePaper(String userId, ExamDTO exam, List<PaperQu> quList) {
 
 
-        // 查找用户
+    // 根据用户ID查询用户信息
     SysUser user = sysUserService.getById(userId);
 
-        //保存试卷基本信息
+    // 创建试卷基本信息，并设置属性
     Paper paper = new Paper();
     paper.setDepartId(user.getDepartId());
     paper.setExamId(exam.getId());
@@ -345,45 +444,51 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
     paper.setState(PaperState.ING);
     paper.setHasSaq(false);
 
-        // 截止时间
+    // 计算截止时间
     Calendar cl = Calendar.getInstance();
     cl.setTimeInMillis(System.currentTimeMillis());
     cl.add(Calendar.MINUTE, exam.getTotalTime());
     paper.setLimitTime(cl.getTime());
 
+    // 保存试卷基本信息
     paperService.save(paper);
 
+    // 如果题目列表不为空，则保存试卷题目列表
     if (!CollectionUtils.isEmpty(quList)) {
         this.savePaperQu(paper.getId(), quList);
     }
 
     return paper;
-    }
-
-
+}
 
-    /**
-     * 保存试卷试题列表
-     * @param paperId
-     * @param quList
+// 声明保存试卷试题列表的私有方法
+/**
+ * 保存试卷试题列表的方法
+ * @param paperId 试卷ID
+ * @param quList 题目列表
  */
-    private void savePaperQu(String paperId, List<PaperQu> quList){
+private void savePaperQu(String paperId, List<PaperQu> quList){
 
+    // 创建批量保存的题目列表和答案列表
     List<PaperQu> batchQuList = new ArrayList<>();
     List<PaperQuAnswer> batchAnswerList = new ArrayList<>();
 
+      // 初始化排序号
     int sort = 0;
     for (PaperQu item : quList) {
 
+        // 设置试卷ID和排序号，并生成ID
         item.setPaperId(paperId);
         item.setSort(sort);
         item.setId(IdWorker.getIdStr());
 
-            //回答列表
+        // 查询题目的答案列表
         List<QuAnswer> answerList = quAnswerService.listAnswerByRandom(item.getQuId());
 
+        // 如果答案列表不为空，则进行处理
         if (!CollectionUtils.isEmpty(answerList)) {
 
+            // 初始化答案排序号
             int ii = 0;
             for (QuAnswer answer : answerList) {
                 PaperQuAnswer paperQuAnswer = new PaperQuAnswer();
@@ -400,51 +505,57 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
             }
         }
 
+        // 添加到批量保存的题目列表中
         batchQuList.add(item);
         sort++;
     }
 
-        //添加问题
+    // 批量添加题目
     paperQuService.saveBatch(batchQuList);
 
-        //批量添加问题答案
+    // 批量添加答案
     paperQuAnswerService.saveBatch(batchAnswerList);
-    }
-
-    @Transactional(rollbackFor = Exception.class)
-    @Override
-    public void fillAnswer(PaperAnswerDTO reqDTO) {
+}
 
+// 声明填充答案的方法，使用事务管理
+/**
+ * 填充答案的方法
+ * @param reqDTO 试卷答案DTO
+ */
+@Transactional(rollbackFor = Exception.class)
+@Override
+public void fillAnswer(PaperAnswerDTO reqDTO) {
 
-        // 未作答
+    // 如果答案列表为空且答案字符串也为空，则直接返回
     if(CollectionUtils.isEmpty(reqDTO.getAnswers())
             && StringUtils.isBlank(reqDTO.getAnswer())){
         return;
     }
 
-        //查找答案列表
+    // 查询答案列表
     List<PaperQuAnswer> list = paperQuAnswerService.listForFill(reqDTO.getPaperId(), reqDTO.getQuId());
 
-        //是否正确
+    // 初始化是否正确的标记
     boolean right = true;
 
-        //更新正确答案
+    // 更新正确答案
     for (PaperQuAnswer item : list) {
 
+        // 设置答案是否被选中
         if (reqDTO.getAnswers().contains(item.getId())) {
             item.setChecked(true);
         } else {
             item.setChecked(false);
         }
 
-            //有一个对不上就是错的
+        // 如果有一个答案不正确，则标记为错误
         if (item.getIsRight()!=null && !item.getIsRight().equals(item.getChecked())) {
             right = false;
         }
         paperQuAnswerService.updateById(item);
     }
 
-        //修改为已回答
+    // 修改为已回答
     PaperQu qu = new PaperQu();
     qu.setQuId(reqDTO.getQuId());
     qu.setPaperId(reqDTO.getPaperId());
@@ -454,29 +565,34 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
 
     paperQuService.updateByKey(qu);
 
-    }
+}
 
-    @Transactional(rollbackFor = Exception.class)
-    @Override
-    public void handExam(String paperId) {
+// 声明交卷的方法，使用事务管理
+/**
+ * 交卷的方法
+ * @param paperId 试卷ID
+ */
+@Transactional(rollbackFor = Exception.class)
+@Override
+public void handExam(String paperId) {
 
-        //获取试卷信息
+    // 获取试卷信息
     Paper paper = paperService.getById(paperId);
 
-        //如果不是正常的，抛出异常
+    // 如果试卷状态不正确，则抛出服务异常
     if(!PaperState.ING.equals(paper.getState())){
         throw new ServiceException(1, "试卷状态不正确！");
     }
 
-        // 客观分
+    // 计算客观题分数
     int objScore = paperQuService.sumObjective(paperId);
     paper.setObjScore(objScore);
     paper.setUserScore(objScore);
 
-        // 主观分，因为要阅卷，所以给0
+    // 设置主观题分数为0
     paper.setSubjScore(0);
 
-        // 待阅卷
+    // 如果有主观题，则设置状态为待阅卷
     if(paper.getHasSaq()) {
         paper.setState(PaperState.WAIT_OPT);
     }else {
@@ -484,11 +600,12 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
         // 同步保存考试成绩
         userExamService.joinResult(paper.getUserId(), paper.getExamId(), objScore, objScore>=paper.getQualifyScore());
 
+        // 设置状态为已完成
         paper.setState(PaperState.FINISHED);
     }
     paper.setUpdateTime(new Date());
 
-        //计算考试时长
+    // 计算考试时长
     Calendar cl = Calendar.getInstance();
     cl.setTimeInMillis(System.currentTimeMillis());
     int userTime = (int)((System.currentTimeMillis() - paper.getCreateTime().getTime()) / 1000 / 60);
@@ -497,15 +614,14 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
     }
     paper.setUserTime(userTime);
 
-        //更新试卷
+    // 更新试卷信息
     paperService.updateById(paper);
 
-
     // 终止定时任务
     String name = JobPrefix.BREAK_EXAM + paperId;
     jobService.deleteJob(name, JobGroup.SYSTEM);
 
-        //把打错的问题加入错题本
+    // 把打错的问题加入错题本
     List<PaperQuDTO> list = paperQuService.listByPaper(paperId);
     for(PaperQuDTO qu: list){
         // 主观题和对的都不加入错题库
@@ -515,28 +631,42 @@ public class PaperServiceImpl extends ServiceImpl<PaperMapper, Paper> implements
         //加入错题本
         new Thread(() -> userBookService.addBook(paper.getExamId(), qu.getQuId())).run();
     }
-    }
+}
 
-    @Override
-    public IPage<PaperListRespDTO> paging(PagingReqDTO<PaperListReqDTO> reqDTO) {
+// 声明分页查询试卷列表的方法
+/**
+ * 分页查询试卷列表的方法
+ * @param reqDTO 分页请求DTO
+ * @return 返回分页响应
+ */
+@Override
+public IPage<PaperListRespDTO> paging(PagingReqDTO<PaperListReqDTO> reqDTO) {
     return baseMapper.paging(reqDTO.toPage(), reqDTO.getParams());
-    }
-
+}
 
-    @Override
-    public PaperDTO checkProcess(String userId) {
+// 声明检查考试进度的方法
+/**
+ * 检查考试进度的方法
+ * @param userId 用户ID
+ * @return 返回试卷DTO
+ */
+@Override
+public PaperDTO checkProcess(String userId) {
 
+    // 构建查询条件，查询是否有正在进行的考试
     QueryWrapper<Paper> wrapper = new QueryWrapper<>();
     wrapper.lambda()
             .eq(Paper::getUserId, userId)
             .eq(Paper::getState, PaperState.ING);
 
+    // 查询正在进行的考试
     Paper paper = this.getOne(wrapper, false);
 
+    // 如果存在正在进行的考试，则返回试卷DTO
     if (paper != null) {
         return BeanMapper.map(paper, PaperDTO.class);
     }
 
+    // 如果不存在正在进行的考试，则返回null
     return null;
-    }
 }

src-源文件/main/java/com/yf/exam/modules/qu/controller/QuController.java

@@ -1,137 +1,129 @@
+// 导入所需的包
 package com.yf.exam.modules.qu.controller;
 
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.google.common.collect.Lists;
-import com.yf.exam.core.api.ApiRest;
-import com.yf.exam.core.api.controller.BaseController;
-import com.yf.exam.core.api.dto.BaseIdReqDTO;
-import com.yf.exam.core.api.dto.BaseIdRespDTO;
-import com.yf.exam.core.api.dto.BaseIdsReqDTO;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.core.exception.ServiceException;
-import com.yf.exam.core.utils.BeanMapper;
-import com.yf.exam.core.utils.excel.ExportExcel;
-import com.yf.exam.core.utils.excel.ImportExcel;
-import com.yf.exam.modules.qu.dto.QuDTO;
-import com.yf.exam.modules.qu.dto.export.QuExportDTO;
-import com.yf.exam.modules.qu.dto.ext.QuDetailDTO;
-import com.yf.exam.modules.qu.dto.request.QuQueryReqDTO;
-import com.yf.exam.modules.qu.entity.Qu;
-import com.yf.exam.modules.qu.service.QuService;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
-import org.apache.shiro.authz.annotation.RequiresRoles;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.util.CollectionUtils;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.ResponseBody;
-import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.multipart.MultipartFile;
-
-import javax.servlet.http.HttpServletResponse;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.List;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;  // 用于构建查询条件
+import com.baomidou.mybatisplus.core.metadata.IPage;  // 用于分页
+import com.google.common.collect.Lists;  // 用于操作列表
+import com.yf.exam.core.api.ApiRest;  // API响应封装类
+import com.yf.exam.core.api.controller.BaseController;  // 基础控制器类
+import com.yf.exam.core.api.dto.BaseIdReqDTO;  // 基础ID请求DTO
+import com.yf.exam.core.api.dto.BaseIdRespDTO;  // 基础ID响应DTO
+import com.yf.exam.core.api.dto.BaseIdsReqDTO;  // 基础ID数组请求DTO
+import com.yf.exam.core.api.dto.PagingReqDTO;  // 分页请求DTO
+import com.yf.exam.core.exception.ServiceException;  // 自定义服务异常
+import com.yf.exam.core.utils.BeanMapper;  // Bean映射工具
+import com.yf.exam.core.utils.excel.ExportExcel;  // 导出Excel工具
+import com.yf.exam.core.utils.excel.ImportExcel;  // 导入Excel工具
+import com.yf.exam.modules.qu.dto.QuDTO;  // 问题DTO
+import com.yf.exam.modules.qu.dto.export.QuExportDTO;  // 问题导出DTO
+import com.yf.exam.modules.qu.dto.ext.QuDetailDTO;  // 问题详情DTO
+import com.yf.exam.modules.qu.dto.request.QuQueryReqDTO;  // 问题查询请求DTO
+import com.yf.exam.modules.qu.entity.Qu;  // 问题实体类
+import com.yf.exam.modules.qu.service.QuService;  // 问题服务类
+import io.swagger.annotations.Api;  // Swagger API注释
+import io.swagger.annotations.ApiOperation;  // Swagger API操作注释
+import org.apache.commons.lang3.StringUtils;  // 字符串操作工具类
+import org.apache.poi.openxml4j.exceptions.InvalidFormatException;  // 用于处理Excel格式异常
+import org.apache.shiro.authz.annotation.RequiresRoles;  // Shiro权限控制注解
+import org.springframework.beans.factory.annotation.Autowired;  // 自动注入依赖
+import org.springframework.util.CollectionUtils;  // 集合工具类
+import org.springframework.web.bind.annotation.RequestBody;  // 请求体注解
+import org.springframework.web.bind.annotation.RequestMapping;  // 请求映射注解
+import org.springframework.web.bind.annotation.RequestMethod;  // 请求方法类型注解
+import org.springframework.web.bind.annotation.RequestParam;  // 请求参数注解
+import org.springframework.web.bind.annotation.ResponseBody;  // 响应体注解
+import org.springframework.web.bind.annotation.RestController;  // REST控制器注解
+import org.springframework.web.multipart.MultipartFile;  // 用于处理文件上传
+
+import javax.servlet.http.HttpServletResponse;  // 用于处理HTTP响应
+import java.io.IOException;  // IO异常处理
+import java.util.Arrays;  // 数组工具类
+import java.util.List;  // 列表工具类
 
 /**
 * <p>
 * 问题题目控制器
 * </p>
+* 该控制器类负责管理题目相关的操作，包括添加、修改、删除、查询等
 *
 * @author 聪明笨狗
 * @since 2020-05-25 13:25
 */
-@Api(tags={"问题题目"})
-@RestController
-@RequestMapping("/exam/api/qu/qu")
+@Api(tags={"问题题目"})  // Swagger注解，表示该控制器处理"问题题目"相关的请求
+@RestController  // Spring注解，表示这是一个RESTful API控制器
+@RequestMapping("/exam/api/qu/qu")  // 设置基础路径
 public class QuController extends BaseController {
 
     @Autowired
-    private QuService baseService;
+    private QuService baseService;  // 自动注入问题服务类
 
     /**
-     * 添加或修改
+     * 添加或修改问题题目
      *
-     * @param reqDTO
-     * @return
+     * @param reqDTO 请求的详细数据，包含问题题目的详细信息
+     * @return 返回操作结果
      */
-    @RequiresRoles("sa")
-    @ApiOperation(value = "添加或修改")
-    @RequestMapping(value = "/save", method = {RequestMethod.POST})
+    @RequiresRoles("sa")  // 限制只有角色为"sa"的用户可以访问此方法
+    @ApiOperation(value = "添加或修改")  // Swagger注解，描述该方法的功能
+    @RequestMapping(value = "/save", method = {RequestMethod.POST})  // POST请求，表示保存操作
     public ApiRest<BaseIdRespDTO> save(@RequestBody QuDetailDTO reqDTO) {
-        baseService.save(reqDTO);
-        return super.success();
+        baseService.save(reqDTO);  // 调用服务层保存或更新问题数据
+        return super.success();  // 返回成功响应
     }
 
     /**
-     * 批量删除
+     * 批量删除问题题目
      *
-     * @param reqDTO
-     * @return
+     * @param reqDTO 请求的ID数组，包含要删除的题目ID列表
+     * @return 返回操作结果
      */
-    @RequiresRoles("sa")
-    @ApiOperation(value = "批量删除")
-    @RequestMapping(value = "/delete", method = {RequestMethod.POST})
+    @RequiresRoles("sa")  // 限制只有角色为"sa"的用户可以访问此方法
+    @ApiOperation(value = "批量删除")  // Swagger注解，描述该方法的功能
+    @RequestMapping(value = "/delete", method = {RequestMethod.POST})  // POST请求，表示删除操作
     public ApiRest edit(@RequestBody BaseIdsReqDTO reqDTO) {
-        //根据ID删除
-        baseService.delete(reqDTO.getIds());
-        return super.success();
+        baseService.delete(reqDTO.getIds());  // 调用服务层进行批量删除
+        return super.success();  // 返回成功响应
     }
 
     /**
-     * 查找详情
+     * 查找问题题目详情
      *
-     * @param reqDTO
-     * @return
+     * @param reqDTO 请求的ID数据，包含要查找的题目ID
+     * @return 返回问题题目的详细信息
      */
-    @ApiOperation(value = "查找详情")
-    @RequestMapping(value = "/detail", method = {RequestMethod.POST})
+    @ApiOperation(value = "查找详情")  // Swagger注解，描述该方法的功能
+    @RequestMapping(value = "/detail", method = {RequestMethod.POST})  // POST请求，表示获取详情操作
     public ApiRest<QuDetailDTO> detail(@RequestBody BaseIdReqDTO reqDTO) {
-        QuDetailDTO dto = baseService.detail(reqDTO.getId());
-        return super.success(dto);
+        QuDetailDTO dto = baseService.detail(reqDTO.getId());  // 调用服务层获取问题题目详情
+        return super.success(dto);  // 返回问题详情
     }
 
     /**
-     * 分页查找
+     * 分页查询问题题目
      *
-     * @param reqDTO
-     * @return
+     * @param reqDTO 分页请求数据，包含查询条件和分页参数
+     * @return 返回分页结果
      */
-    @RequiresRoles("sa")
-    @ApiOperation(value = "分页查找")
-    @RequestMapping(value = "/paging", method = {RequestMethod.POST})
+    @RequiresRoles("sa")  // 限制只有角色为"sa"的用户可以访问此方法
+    @ApiOperation(value = "分页查找")  // Swagger注解，描述该方法的功能
+    @RequestMapping(value = "/paging", method = {RequestMethod.POST})  // POST请求，表示分页查询操作
     public ApiRest<IPage<QuDTO>> paging(@RequestBody PagingReqDTO<QuQueryReqDTO> reqDTO) {
-
-        //分页查询并转换
-        IPage<QuDTO> page = baseService.paging(reqDTO);
-
-        return super.success(page);
+        IPage<QuDTO> page = baseService.paging(reqDTO);  // 调用服务层进行分页查询
+        return super.success(page);  // 返回分页结果
     }
 
-
     /**
-     * 导出excel文件
+     * 导出问题题目的Excel文件
      */
-    @RequiresRoles("sa")
-    @ResponseBody
-    @RequestMapping(value = "/export")
+    @RequiresRoles("sa")  // 限制只有角色为"sa"的用户可以访问此方法
+    @ResponseBody  // 标明返回内容直接作为响应体
+    @RequestMapping(value = "/export")  // 导出请求路径
     public ApiRest exportFile(HttpServletResponse response, @RequestBody QuQueryReqDTO reqDTO) {
-
-
-        // 导出文件名
-        String fileName = "导出的试题-" + System.currentTimeMillis() + ".xlsx";
-
+        String fileName = "导出的试题-" + System.currentTimeMillis() + ".xlsx";  // 设置导出的文件名
         try {
-
             int no = 0;
             String quId = "";
-            List<QuExportDTO> list = baseService.listForExport(reqDTO);
+            List<QuExportDTO> list = baseService.listForExport(reqDTO);  // 获取导出数据
             for (QuExportDTO item : list) {
                 if (!quId.equals(item.getQId())) {
                     quId = item.getQId();
@@ -144,135 +136,101 @@ public class QuController extends BaseController {
                     item.setQImage("");
                     item.setQVideo("");
                 }
-                item.setNo(String.valueOf(no));
+                item.setNo(String.valueOf(no));  // 设置题目序号
             }
-            new ExportExcel("试题", QuExportDTO.class).setDataList(list).write(response, fileName).dispose();
-            return super.success();
+            new ExportExcel("试题", QuExportDTO.class).setDataList(list).write(response, fileName).dispose();  // 导出数据到Excel文件
+            return super.success();  // 返回成功响应
         } catch (Exception e) {
-            return failure(e.getMessage());
+            return failure(e.getMessage());  // 捕获异常并返回失败响应
         }
     }
 
     /**
-     * 导入Excel
+     * 导入问题题目的Excel文件
      *
-     * @param file
-     * @return
+     * @param file 上传的Excel文件
+     * @return 返回操作结果
      */
-    @RequiresRoles("sa")
-    @ResponseBody
-    @RequestMapping(value = "/import")
+    @RequiresRoles("sa")  // 限制只有角色为"sa"的用户可以访问此方法
+    @ResponseBody  // 标明返回内容直接作为响应体
+    @RequestMapping(value = "/import")  // 导入请求路径
     public ApiRest importFile(@RequestParam("file") MultipartFile file) {
-
         try {
-
-            ImportExcel ei = new ImportExcel(file, 1, 0);
-            List<QuExportDTO> list = ei.getDataList(QuExportDTO.class);
-
-            // 校验数据
-            this.checkExcel(list);
-
-            // 导入数据条数
-            baseService.importExcel(list);
-
-            // 导入成功
-            return super.success();
-
-        } catch (IOException e) {
-
-        } catch (InvalidFormatException e) {
-
-        } catch (IllegalAccessException e) {
-
-        } catch (InstantiationException e) {
-
+            ImportExcel ei = new ImportExcel(file, 1, 0);  // 创建导入Excel对象
+            List<QuExportDTO> list = ei.getDataList(QuExportDTO.class);  // 获取Excel中的数据列表
+            this.checkExcel(list);  // 校验数据
+            baseService.importExcel(list);  // 调用服务层进行导入操作
+            return super.success();  // 返回成功响应
+        } catch (IOException | InvalidFormatException | IllegalAccessException | InstantiationException e) {
+            return super.failure();  // 捕获各种异常并返回失败响应
         }
-
-        return super.failure();
     }
 
     /**
-     * 校验Excel
+     * 校验Excel文件中的数据
      *
-     * @param list
-     * @throws Exception
+     * @param list 导入的题目数据列表
+     * @throws ServiceException 可能抛出服务异常
      */
     private void checkExcel(List<QuExportDTO> list) throws ServiceException {
-
-        // 约定第三行开始导入
+        // 校验Excel数据的逻辑，检查每一行数据的有效性
         int line = 3;
         StringBuffer sb = new StringBuffer();
-
         if (CollectionUtils.isEmpty(list)) {
-            throw new ServiceException(1, "您导入的数据似乎是一个空表格！");
+            throw new ServiceException(1, "您导入的数据似乎是一个空表格！");  // 如果表格为空，抛出异常
         }
-
         Integer quNo = null;
         for (QuExportDTO item : list) {
-
-            System.out.println(item.getNo());
             if (StringUtils.isBlank(item.getNo())) {
                 line++;
                 continue;
             }
-
-            System.out.println(item.getQContent());
             Integer no;
-
             try {
-                no = Integer.parseInt(item.getNo());
+                no = Integer.parseInt(item.getNo());  // 转换题目序号
             } catch (Exception e) {
                 line++;
                 continue;
             }
-
             if (no == null) {
                 sb.append("第" + line + "行，题目序号不能为空！<br>");
             }
-
+            // 校验题目内容和其他字段是否为空
             if (quNo == null || !quNo.equals(no)) {
-
                 if (item.getQuType() == null) {
                     sb.append("第" + line + "行，题目类型不能为空<br>");
                 }
-
                 if (StringUtils.isBlank(item.getQContent())) {
                     sb.append("第" + line + "行，题目内容不能为空<br>");
                 }
-
                 if (CollectionUtils.isEmpty(item.getRepoList())) {
                     sb.append("第" + line + "行，题目必须包含一个题库<br>");
                 }
             }
-
             if (StringUtils.isBlank(item.getAIsRight())) {
                 sb.append("第" + line + "行，选项是否正确不能为空<br>");
             }
-
             if (StringUtils.isBlank(item.getAContent()) && StringUtils.isBlank(item.getAImage())) {
                 sb.append("第" + line + "行，选项内容和选项图片必须有一个不为空<br>");
             }
-
             quNo = no;
             line++;
         }
-
-        // 存在错误
         if (!"".equals(sb.toString())) {
-            throw new ServiceException(1, sb.toString());
+            throw new ServiceException(1, sb.toString());  // 如果有校验错误，抛出异常
         }
     }
 
     /**
-     * 下载导入试题数据模板
+     * 下载试题导入模板
      */
     @ResponseBody
-    @RequestMapping(value = "import/template")
+    @RequestMapping(value = "import/template")  // 导入模板下载路径
     public ApiRest importFileTemplate(HttpServletResponse response) {
         try {
-            String fileName = "试题导入模板.xlsx";
-            List<QuExportDTO> list = Lists.newArrayList();
-
+            String fileName = "试题导入模板.xlsx";  // 设置文件名
+            List<QuExportDTO> list = Lists.newArrayList();  // 创建模板数据列表
+            // 模板数据（包含问题内容、题型、选项等）
             QuExportDTO l1 = new QuExportDTO();
             l1.setNo("正式导入，请删除此说明行：数字，相同的数字表示同一题的序列");
             l1.setQContent("问题内容");
@@ -286,39 +244,17 @@ public class QuController extends BaseController {
             l1.setAIsRight("只能填写0或1，0表示否，1表示是");
             l1.setAAnalysis("这个项是正确的");
 
-
-            QuExportDTO l2 = new QuExportDTO();
-            l2.setQContent("找出以下可以被2整除的数（多选）");
-            l2.setQAnalysis("最基本的数学题，不做过多解析");
-            l2.setQuType("2");
-            l2.setNo("1");
-            l2.setAIsRight("1");
-            l2.setAContent("数字：2");
-            l2.setAAnalysis("2除以2=1，对的");
-
-            QuExportDTO l3 = new QuExportDTO();
-            l3.setNo("1");
-            l3.setAIsRight("0");
-            l3.setAContent("数字：3");
-            l3.setAAnalysis("3除以2=1.5，不能被整除");
-
-            QuExportDTO l4 = new QuExportDTO();
-            l4.setNo("1");
-            l4.setAIsRight("1");
-            l4.setAContent("数字：6");
-            l4.setAAnalysis("6除以2=3，对的");
-
-
-
+            // 添加模板示例数据
             list.add(l1);
             list.add(l2);
             list.add(l3);
             list.add(l4);
 
+            // 导出模板文件
             new ExportExcel("试题数据", QuExportDTO.class, 1).setDataList(list).write(response, fileName).dispose();
-            return super.success();
+            return super.success();  // 返回成功响应
         } catch (Exception e) {
-            return super.failure("导入模板下载失败！失败信息："+e.getMessage());
+            return super.failure("导入模板下载失败！失败信息："+e.getMessage());  // 返回失败响应
         }
     }
 }

src-源文件/main/java/com/yf/exam/modules/qu/dto/QuAnswerDTO.java

@@ -1,42 +1,66 @@
 package com.yf.exam.modules.qu.dto;
 
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
+import io.swagger.annotations.ApiModel;  // Swagger注解，用于生成API文档
+import io.swagger.annotations.ApiModelProperty;  // Swagger注解，用于描述API模型的属性
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
-import java.io.Serializable;
+import java.io.Serializable;  // 可序列化接口
 
 /**
 * <p>
 * 候选答案请求类
 * </p>
 *
+* 该类用于封装候选答案的请求信息，包含每个答案的具体内容、是否正确、答案分析等信息。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
+@Data  // Lombok注解，自动生成getter、setter等方法
 @ApiModel(value="候选答案", description="候选答案")
 public class QuAnswerDTO implements Serializable {
 
-    private static final long serialVersionUID = 1L;
-
-
-    @ApiModelProperty(value = "答案ID", required=true)
-    private String id;
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
 
-    @ApiModelProperty(value = "问题ID", required=true)
-    private String quId;
+    /**
+     * 答案ID
+     * 用于唯一标识每个候选答案，通常由数据库自动生成。
+     */
+    @ApiModelProperty(value = "答案ID", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String id;  // 答案ID
 
-    @ApiModelProperty(value = "是否正确", required=true)
-    private Boolean isRight;
+    /**
+     * 题目ID
+     * 该字段表示该答案对应的题目ID。
+     */
+    @ApiModelProperty(value = "问题ID", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String quId;  // 题目ID
 
-    @ApiModelProperty(value = "选项图片", required=true)
-    private String image;
+    /**
+     * 是否正确
+     * 标记该答案是否为正确答案，`true`表示正确，`false`表示错误。
+     */
+    @ApiModelProperty(value = "是否正确", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private Boolean isRight;  // 是否正确
 
-    @ApiModelProperty(value = "答案内容", required=true)
-    private String content;
+    /**
+     * 选项图片
+     * 存储与该答案相关的图片URL，通常用于多媒体题目选项。
+     */
+    @ApiModelProperty(value = "选项图片", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String image;  // 选项图片URL
 
-    @ApiModelProperty(value = "答案分析", required=true)
-    private String analysis;
+    /**
+     * 答案内容
+     * 该字段用于存储该答案的文本内容，通常为答案的描述或选项文本。
+     */
+    @ApiModelProperty(value = "答案内容", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String content;  // 答案内容
 
+    /**
+     * 答案分析
+     * 用于对该答案进行详细解析，解释为什么该答案正确或错误。
+     */
+    @ApiModelProperty(value = "答案分析", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String analysis;  // 答案分析
 }

src-源文件/main/java/com/yf/exam/modules/qu/dto/QuDTO.java

@@ -1,53 +1,88 @@
 package com.yf.exam.modules.qu.dto;
 
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
+import io.swagger.annotations.ApiModel;  // Swagger注解，用于生成API文档
+import io.swagger.annotations.ApiModelProperty;  // Swagger注解，用于描述API模型的属性
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
-import java.io.Serializable;
-import java.util.Date;
+import java.io.Serializable;  // 可序列化接口
+import java.util.Date;  // 日期类型
 
 /**
 * <p>
 * 问题题目请求类
 * </p>
 *
+* 该类用于封装问题题目的基本信息，包括题目的类型、难度、内容、解析等。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
+@Data  // Lombok注解，自动生成getter、setter等方法
 @ApiModel(value="问题题目", description="问题题目")
 public class QuDTO implements Serializable {
 
-    private static final long serialVersionUID = 1L;
-
-
-    @ApiModelProperty(value = "题目ID", required=true)
-    private String id;
-
-    @ApiModelProperty(value = "题目类型", required=true)
-    private Integer quType;
-
-    @ApiModelProperty(value = "1普通,2较难", required=true)
-    private Integer level;
-
-    @ApiModelProperty(value = "题目图片", required=true)
-    private String image;
-
-    @ApiModelProperty(value = "题目内容", required=true)
-    private String content;
-
-
-    @ApiModelProperty(value = "创建时间", required=true)
-    private Date createTime;
-
-    @ApiModelProperty(value = "更新时间", required=true)
-    private Date updateTime;
-
-    @ApiModelProperty(value = "题目备注", required=true)
-    private String remark;
-
-    @ApiModelProperty(value = "整题解析", required=true)
-    private String analysis;
-    
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
+
+    /**
+     * 题目ID
+     * 每个题目都拥有唯一的ID，用于标识题目。
+     */
+    @ApiModelProperty(value = "题目ID", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String id;  // 题目ID
+
+    /**
+     * 题目类型
+     * 该字段用于标识题目的类型，例如选择题、填空题、判断题等。
+     */
+    @ApiModelProperty(value = "题目类型", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private Integer quType;  // 题目类型
+
+    /**
+     * 题目难度
+     * 用于表示题目的难易程度。1表示普通，2表示较难，可能有更多级别。
+     */
+    @ApiModelProperty(value = "1普通,2较难", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private Integer level;  // 题目难度
+
+    /**
+     * 题目图片
+     * 该字段存储与题目相关的图片URL，可以是题目内容的辅助说明。
+     */
+    @ApiModelProperty(value = "题目图片", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String image;  // 题目图片URL
+
+    /**
+     * 题目内容
+     * 存储题目的具体内容，描述问题的文本部分。
+     */
+    @ApiModelProperty(value = "题目内容", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String content;  // 题目内容
+
+    /**
+     * 创建时间
+     * 标识题目创建的时间，通常由系统自动生成。
+     */
+    @ApiModelProperty(value = "创建时间", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private Date createTime;  // 创建时间
+
+    /**
+     * 更新时间
+     * 记录题目最后一次更新时间，通常由系统自动更新。
+     */
+    @ApiModelProperty(value = "更新时间", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private Date updateTime;  // 更新时间
+
+    /**
+     * 题目备注
+     * 可选字段，用于记录关于题目的额外备注信息。
+     */
+    @ApiModelProperty(value = "题目备注", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String remark;  // 题目备注
+
+    /**
+     * 整题解析
+     * 提供该题目的完整解析，帮助用户理解解题思路及过程。
+     */
+    @ApiModelProperty(value = "整题解析", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String analysis;  // 整题解析
 }

src-源文件/main/java/com/yf/exam/modules/qu/dto/QuRepoDTO.java

@@ -1,38 +1,58 @@
 package com.yf.exam.modules.qu.dto;
 
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
+import io.swagger.annotations.ApiModel;  // Swagger注解，用于生成API文档
+import io.swagger.annotations.ApiModelProperty;  // Swagger注解，用于描述API模型的属性
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
-import java.io.Serializable;
+import java.io.Serializable;  // 可序列化接口
 
 /**
 * <p>
 * 试题题库请求类
 * </p>
 *
+* 该类用于封装题库与题目之间的关联信息，包含题目的ID、题库ID、题目类型等信息。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
+@Data  // Lombok注解，自动生成getter、setter等方法
 @ApiModel(value="试题题库", description="试题题库")
 public class QuRepoDTO implements Serializable {
 
-    private static final long serialVersionUID = 1L;
-
-
-    private String id;
-
-    @ApiModelProperty(value = "试题", required=true)
-    private String quId;
-
-    @ApiModelProperty(value = "归属题库", required=true)
-    private String repoId;
-
-    @ApiModelProperty(value = "题目类型", required=true)
-    private Integer quType;
-
-    @ApiModelProperty(value = "排序", required=true)
-    private Integer sort;
-
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
+
+    /**
+     * 试题ID
+     * 唯一标识一道试题。
+     */
+    private String id;  // 试题ID
+
+    /**
+     * 题目ID
+     * 与题目ID进行关联，表示该试题属于某个具体题目。
+     */
+    @ApiModelProperty(value = "试题", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String quId;  // 题目ID
+
+    /**
+     * 题库ID
+     * 标识该题目所属的题库。
+     */
+    @ApiModelProperty(value = "归属题库", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private String repoId;  // 题库ID
+
+    /**
+     * 题目类型
+     * 表示该题目在题库中的类型，例如选择题、填空题等。
+     */
+    @ApiModelProperty(value = "题目类型", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private Integer quType;  // 题目类型
+
+    /**
+     * 排序
+     * 表示该题目在题库中的显示顺序，数字越小，顺序越靠前。
+     */
+    @ApiModelProperty(value = "排序", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private Integer sort;  // 排序
 }

src-源文件/main/java/com/yf/exam/modules/qu/dto/export/QuExportDTO.java

@@ -1,45 +1,59 @@
 package com.yf.exam.modules.qu.dto.export;
 
-import com.yf.exam.core.utils.excel.annotation.ExcelField;
-import com.yf.exam.core.utils.excel.fieldtype.ListType;
-import lombok.Data;
+import com.yf.exam.core.utils.excel.annotation.ExcelField;  // Excel导出注解
+import com.yf.exam.core.utils.excel.fieldtype.ListType;  // 用于处理List类型字段的特殊注解
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter、toString等方法
 
-import java.util.List;
+import java.util.List;  // 用于表示列表类型的字段
 
 /**
  * 用于导出的数据结构
+ * 
+ * 该类是导出试题相关数据时所使用的DTO（数据传输对象），包含了题目序号、题目内容、题目解析、选项内容等信息。
+ * 主要用于Excel导出时的数据映射。
+ * 
  * @author bool
  */
-@Data
+@Data  // Lombok注解，自动生成getter、setter等方法
 public class QuExportDTO {
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
 
     /**
-     *
+     * 题目ID
      */
-    private String qId;
-
-    @ExcelField(title="题目序号", align=2, sort=1)
-    private String no;
-    @ExcelField(title="题目类型", align=2, sort=2)
-    private String quType;
-    @ExcelField(title="题目内容", align=2, sort=3)
-    private String qContent;
-    @ExcelField(title="整体解析", align=2, sort=4)
-    private String qAnalysis;
-    @ExcelField(title="题目图片", align=2, sort=5)
-    private String qImage;
-    @ExcelField(title="题目视频", align=2, sort=6)
-    private String qVideo;
-    @ExcelField(title="所属题库", align=2, sort=7, fieldType = ListType.class)
-    private List<String> repoList;
-    @ExcelField(title="是否正确项", align=2, sort=8)
-    private String aIsRight;
-    @ExcelField(title="选项内容", align=2, sort=9)
-    private String aContent;
-    @ExcelField(title="选项解析", align=2, sort=10)
-    private String aAnalysis;
-    @ExcelField(title="选项图片", align=2, sort=11)
-    private String aImage;
+    private String qId;  // 题目的唯一标识符
+
+    @ExcelField(title="题目序号", align=2, sort=1)  // 导出Excel时的列标题和排序，align为居中对齐，sort为排序位置
+    private String no;  // 题目序号，表示题目的编号
+
+    @ExcelField(title="题目类型", align=2, sort=2)  // Excel导出列的标题和排序
+    private String quType;  // 题目类型，可能是单选题、多选题等
+
+    @ExcelField(title="题目内容", align=2, sort=3)  // Excel导出列的标题和排序
+    private String qContent;  // 题目内容，包含问题的具体描述
+
+    @ExcelField(title="整体解析", align=2, sort=4)  // Excel导出列的标题和排序
+    private String qAnalysis;  // 整个题目的解析说明
+
+    @ExcelField(title="题目图片", align=2, sort=5)  // Excel导出列的标题和排序
+    private String qImage;  // 题目图片，存储图片URL或路径
+
+    @ExcelField(title="题目视频", align=2, sort=6)  // Excel导出列的标题和排序
+    private String qVideo;  // 题目视频，存储视频URL或路径
+
+    @ExcelField(title="所属题库", align=2, sort=7, fieldType = ListType.class)  // 题库列表，支持导出多个题库
+    private List<String> repoList;  // 题目所属的题库列表
+
+    @ExcelField(title="是否正确项", align=2, sort=8)  // Excel导出列的标题和排序
+    private String aIsRight;  // 是否为正确选项（0或1）
+
+    @ExcelField(title="选项内容", align=2, sort=9)  // Excel导出列的标题和排序
+    private String aContent;  // 选项内容，表示答案的具体内容
+
+    @ExcelField(title="选项解析", align=2, sort=10)  // Excel导出列的标题和排序
+    private String aAnalysis;  // 选项解析，说明该选项的正确性或相关分析
+
+    @ExcelField(title="选项图片", align=2, sort=11)  // Excel导出列的标题和排序
+    private String aImage;  // 选项图片，存储图片URL或路径
 }

src-源文件/main/java/com/yf/exam/modules/qu/dto/export/QuImportDTO.java

@@ -1,23 +1,56 @@
 package com.yf.exam.modules.qu.dto.export;
 
-import com.yf.exam.modules.qu.dto.QuAnswerDTO;
-import lombok.Data;
+import com.yf.exam.modules.qu.dto.QuAnswerDTO;  // 导入的选项答案DTO
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter、toString等方法
 
-import java.util.List;
+import java.util.List;  // 用于表示列表类型的字段
 
 /**
  * 用于导出的数据结构
+ * 
+ * 该类用于导入试题数据时的DTO（数据传输对象），包含了题目类型、题目内容、解析、题目图片等信息。
+ * 同时还包含了该题目的多个答案选项。
+ * 
  * @author bool
  */
-@Data
+@Data  // Lombok注解，自动生成getter、setter等方法
 public class QuImportDTO {
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
 
-    private String quType;
-    private String qContent;
-    private String qAnalysis;
-    private String qImage;
-    private String repoName;
-    private List<QuAnswerDTO> answerList;
+    /**
+     * 题目类型
+     * 例如：1代表单选题，2代表多选题，3代表判断题，4代表主观题等
+     */
+    private String quType;  // 题目类型，表示题目的类别
+
+    /**
+     * 题目内容
+     * 例如：问题的具体描述
+     */
+    private String qContent;  // 题目内容，表示题目的实际问题
+
+    /**
+     * 题目解析
+     * 例如：题目解析或解释说明
+     */
+    private String qAnalysis;  // 题目解析，解释题目的答案或相关说明
+
+    /**
+     * 题目图片
+     * 例如：题目相关的图片URL
+     */
+    private String qImage;  // 题目图片，存储图片URL或路径
+
+    /**
+     * 题库名称
+     * 例如：题目所属的题库名称
+     */
+    private String repoName;  // 题目所属的题库名称
+
+    /**
+     * 答案选项列表
+     * 该字段存储了该题目的多个答案选项及其相关信息。
+     */
+    private List<QuAnswerDTO> answerList;  // 答案选项列表，包含该题目的所有答案选项
 }

src-源文件/main/java/com/yf/exam/modules/qu/dto/ext/QuDetailDTO.java

@@ -1,33 +1,43 @@
 package com.yf.exam.modules.qu.dto.ext;
 
-import com.yf.exam.modules.qu.dto.QuAnswerDTO;
-import com.yf.exam.modules.qu.dto.QuDTO;
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
+import com.yf.exam.modules.qu.dto.QuAnswerDTO;  // 引入选项答案DTO
+import com.yf.exam.modules.qu.dto.QuDTO;  // 引入问题题目DTO
+import io.swagger.annotations.ApiModel;  // Swagger注解，用于生成API文档
+import io.swagger.annotations.ApiModelProperty;  // Swagger注解，用于描述API模型的属性
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
-import java.util.List;
+import java.util.List;  // 用于表示列表类型的字段
 
 /**
 * <p>
 * 问题题目请求类
 * </p>
 *
+* 该类用于表示问题的详细信息，继承自 `QuDTO`，包括题目的详细信息如备选项、题库列表等。
+* 主要用于在前后端交互时，传递包含问题详细信息的请求或响应数据。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
+@Data  // Lombok注解，自动生成getter、setter等方法
 @ApiModel(value="问题题目详情", description="问题题目详情")
 public class QuDetailDTO extends QuDTO {
 
-    private static final long serialVersionUID = 1L;
-    
-    
-    @ApiModelProperty(value = "备选项列表", required=true)
-    private List<QuAnswerDTO> answerList;
-
-    @ApiModelProperty(value = "题库列表", required=true)
-    private List<String> repoIds;
-
-    
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
+    
+    /**
+     * 备选项列表
+     * 该字段包含了该题目的所有答案选项列表。
+     * 每个选项都包含了选项内容、是否为正确答案、解析等信息。
+     */
+    @ApiModelProperty(value = "备选项列表", required=true)  // Swagger注解，用于生成文档
+    private List<QuAnswerDTO> answerList;  // 备选项列表，包含该题目的所有答案选项
+
+    /**
+     * 题库列表
+     * 该字段包含了该题目所属的多个题库ID。
+     * 用于标识该题目属于哪些题库，可能有多个题库关联。
+     */
+    @ApiModelProperty(value = "题库列表", required=true)  // Swagger注解，用于生成文档
+    private List<String> repoIds;  // 题库列表，存储题库ID的列表
 }

src-源文件/main/java/com/yf/exam/modules/qu/dto/request/QuQueryReqDTO.java

@@ -1,38 +1,54 @@
 package com.yf.exam.modules.qu.dto.request;
 
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
+import io.swagger.annotations.ApiModel;  // Swagger注解，用于生成API文档
+import io.swagger.annotations.ApiModelProperty;  // Swagger注解，用于描述API模型的属性
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
-import java.io.Serializable;
-import java.util.List;
+import java.io.Serializable;  // 可序列化接口
+import java.util.List;  // 用于表示列表类型的字段
 
 /**
 * <p>
 * 问题题目请求类
 * </p>
 *
+* 该类用于封装前端请求查询题目的参数。通过该请求类，前端可以传递多个查询条件，
+* 如题目类型、题库ID、题目内容等，以便进行题目的筛选和查询。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
+@Data  // Lombok注解，自动生成getter、setter等方法
 @ApiModel(value="题目查询请求类", description="题目查询请求类")
 public class QuQueryReqDTO implements Serializable {
 
-    private static final long serialVersionUID = 1L;
-
-
-    @ApiModelProperty(value = "题目类型")
-    private Integer quType;
-
-    @ApiModelProperty(value = "归属题库")
-    private List<String> repoIds;
-
-    @ApiModelProperty(value = "题目内容")
-    private String content;
-
-    @ApiModelProperty(value = "排除ID列表")
-    private List<String> excludes;
-
-    
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
+
+    /**
+     * 题目类型
+     * 用于指定查询的题目类型。例如，单选题、多选题、判断题等。
+     */
+    @ApiModelProperty(value = "题目类型")  // Swagger注解，描述字段信息
+    private Integer quType;  // 题目类型，通常是数字表示不同题型
+
+    /**
+     * 归属题库
+     * 用于指定题目所属的题库ID列表。如果该字段不为空，查询会限制在指定的题库中。
+     */
+    @ApiModelProperty(value = "归属题库")  // Swagger注解，描述字段信息
+    private List<String> repoIds;  // 题库ID列表，题目可以归属于多个题库
+
+    /**
+     * 题目内容
+     * 用于进行模糊查询，匹配包含特定内容的题目。
+     */
+    @ApiModelProperty(value = "题目内容")  // Swagger注解，描述字段信息
+    private String content;  // 题目内容，支持模糊查询
+
+    /**
+     * 排除ID列表
+     * 用于指定在查询中排除的题目ID列表，这些ID的题目不会出现在查询结果中。
+     */
+    @ApiModelProperty(value = "排除ID列表")  // Swagger注解，描述字段信息
+    private List<String> excludes;  // 排除的题目ID列表
 }

src-源文件/main/java/com/yf/exam/modules/qu/dto/request/QuRepoBatchReqDTO.java

@@ -1,34 +1,47 @@
 package com.yf.exam.modules.qu.dto.request;
 
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
+import io.swagger.annotations.ApiModel;  // Swagger注解，用于生成API文档
+import io.swagger.annotations.ApiModelProperty;  // Swagger注解，用于描述API模型的属性
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
-import java.io.Serializable;
-import java.util.List;
+import java.io.Serializable;  // 可序列化接口
+import java.util.List;  // 用于表示列表类型的字段
 
 /**
 * <p>
-* 问题题目请求类
+* 试题题库批量操作请求类
 * </p>
 *
+* 该类用于封装前端请求批量操作题目和题库关联的参数。
+* 通过该请求类，前端可以执行批量新增或移除题目与题库的关联操作。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
+@Data  // Lombok注解，自动生成getter、setter等方法
 @ApiModel(value="试题题库批量操作类", description="试题题库批量操作类")
 public class QuRepoBatchReqDTO implements Serializable {
 
-    private static final long serialVersionUID = 1L;
-
-
-    @ApiModelProperty(value = "题目ID", required=true)
-    private List<String> quIds;
-
-    @ApiModelProperty(value = "题目类型", required=true)
-    private List<String> repoIds;
-
-    @ApiModelProperty(value = "是否移除，否就新增；是就移除", required=true)
-    private Boolean remove;
-    
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
+
+    /**
+     * 题目ID列表
+     * 用于指定要操作的题目ID集合，可以是多个题目。
+     */
+    @ApiModelProperty(value = "题目ID", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private List<String> quIds;  // 要操作的题目ID列表
+
+    /**
+     * 题库ID列表
+     * 用于指定题目与之关联的题库ID集合，可以是多个题库。
+     */
+    @ApiModelProperty(value = "题目类型", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private List<String> repoIds;  // 题库ID列表
+
+    /**
+     * 是否移除标志
+     * 如果为 `true`，表示从题库中移除题目；如果为 `false`，表示新增题目到题库中。
+     */
+    @ApiModelProperty(value = "是否移除，否就新增；是就移除", required=true)  // Swagger注解，描述字段信息，标明该字段是必填项
+    private Boolean remove;  // `true`表示移除，`false`表示新增
 }

src-源文件/main/java/com/yf/exam/modules/qu/entity/Qu.java

@@ -1,75 +1,85 @@
 package com.yf.exam.modules.qu.entity;
 
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import com.baomidou.mybatisplus.extension.activerecord.Model;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.IdType;  // MyBatis Plus注解，指定ID生成策略
+import com.baomidou.mybatisplus.annotation.TableField;  // MyBatis Plus注解，指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId;  // MyBatis Plus注解，指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName;  // MyBatis Plus注解，指定表名
+import com.baomidou.mybatisplus.extension.activerecord.Model;  // MyBatis Plus扩展的活动记录模式类
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
-import java.util.Date;
+import java.util.Date;  // 日期类型
 
 /**
 * <p>
 * 问题题目实体类
 * </p>
 *
+* 该类用于映射问题题目的数据结构，通过MyBatis-Plus框架进行数据库操作。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
-@TableName("el_qu")
+@Data  // Lombok注解，自动生成getter、setter等方法
+@TableName("el_qu")  // MyBatis Plus注解，指定与数据库表的映射关系
 public class Qu extends Model<Qu> {
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
 
     /**
      * 题目ID
+     * 主键，唯一标识一道题目。
      */
-    @TableId(value = "id", type = IdType.ASSIGN_ID)
-    private String id;
+    @TableId(value = "id", type = IdType.ASSIGN_ID)  // MyBatis Plus注解，指定主键生成策略为自定义ID
+    private String id;  // 题目ID
 
     /**
      * 题目类型
+     * 表示该题目是选择题、判断题等类型。
      */
-    @TableField("qu_type")
-    private Integer quType;
+    @TableField("qu_type")  // MyBatis Plus注解，指定字段名与数据库表字段名映射
+    private Integer quType;  // 题目类型
 
     /**
-     * 1普通,2较难
+     * 题目难度
+     * 1表示普通，2表示较难。
      */
-    private Integer level;
+    private Integer level;  // 题目难度，1普通，2较难
 
     /**
      * 题目图片
+     * 题目相关的图片资源，存储图片URL或路径。
      */
-    private String image;
+    private String image;  // 题目图片
 
     /**
      * 题目内容
+     * 存储题目的实际内容，例如选择题或填空题的文本。
      */
-    private String content;
+    private String content;  // 题目内容
 
     /**
      * 创建时间
+     * 记录该题目创建的时间戳。
      */
-    @TableField("create_time")
-    private Date createTime;
+    @TableField("create_time")  // MyBatis Plus注解，映射数据库中的字段
+    private Date createTime;  // 创建时间
 
     /**
      * 更新时间
+     * 记录该题目最后更新时间戳。
      */
-    @TableField("update_time")
-    private Date updateTime;
+    @TableField("update_time")  // MyBatis Plus注解，映射数据库中的字段
+    private Date updateTime;  // 更新时间
 
     /**
      * 题目备注
+     * 对题目附加的说明或备注。
      */
-    private String remark;
+    private String remark;  // 题目备注
 
     /**
      * 整题解析
+     * 对该题目的详细解析，包括答案解析、解题思路等。
      */
-    private String analysis;
-    
+    private String analysis;  // 整题解析
 }

src-源文件/main/java/com/yf/exam/modules/qu/entity/QuAnswer.java

@@ -1,58 +1,64 @@
 package com.yf.exam.modules.qu.entity;
 
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import com.baomidou.mybatisplus.extension.activerecord.Model;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.IdType;  // MyBatis Plus注解，指定ID生成策略
+import com.baomidou.mybatisplus.annotation.TableField;  // MyBatis Plus注解，指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId;  // MyBatis Plus注解，指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName;  // MyBatis Plus注解，指定表名
+import com.baomidou.mybatisplus.extension.activerecord.Model;  // MyBatis Plus扩展的活动记录模式类
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
 /**
 * <p>
 * 候选答案实体类
 * </p>
 *
+* 该类用于映射候选答案的数据结构，通过MyBatis-Plus框架进行数据库操作。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
-@TableName("el_qu_answer")
+@Data  // Lombok注解，自动生成getter、setter等方法
+@TableName("el_qu_answer")  // MyBatis Plus注解，指定与数据库表的映射关系
 public class QuAnswer extends Model<QuAnswer> {
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
 
     /**
      * 答案ID
+     * 主键，唯一标识一个答案。
      */
-    @TableId(value = "id", type = IdType.ASSIGN_ID)
-    private String id;
+    @TableId(value = "id", type = IdType.ASSIGN_ID)  // MyBatis Plus注解，指定主键生成策略为自定义ID
+    private String id;  // 答案ID
 
     /**
      * 问题ID
+     * 关联的题目ID，表示这个答案是属于哪道题目的。
      */
-    @TableField("qu_id")
-    private String quId;
+    @TableField("qu_id")  // MyBatis Plus注解，指定字段名与数据库表字段名映射
+    private String quId;  // 问题ID
 
     /**
      * 是否正确
+     * 该答案是否为正确答案，true表示正确，false表示错误。
      */
-    @TableField("is_right")
-    private Boolean isRight;
+    @TableField("is_right")  // MyBatis Plus注解，映射数据库中的字段
+    private Boolean isRight;  // 是否正确
 
     /**
      * 选项图片
+     * 答案相关的图片资源，存储图片URL或路径。
      */
-    private String image;
+    private String image;  // 选项图片
 
     /**
      * 答案内容
+     * 存储该选项的文本内容。
      */
-    private String content;
-
+    private String content;  // 答案内容
 
     /**
      * 答案分析
+     * 对该答案的详细分析，包括为什么是正确或错误的解析。
      */
-    private String analysis;
-    
+    private String analysis;  // 答案分析
 }

src-源文件/main/java/com/yf/exam/modules/qu/entity/QuRepo.java

@@ -1,50 +1,59 @@
 package com.yf.exam.modules.qu.entity;
 
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import com.baomidou.mybatisplus.extension.activerecord.Model;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.IdType;  // MyBatis Plus注解，指定ID生成策略
+import com.baomidou.mybatisplus.annotation.TableField;  // MyBatis Plus注解，指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId;  // MyBatis Plus注解，指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName;  // MyBatis Plus注解，指定表名
+import com.baomidou.mybatisplus.extension.activerecord.Model;  // MyBatis Plus扩展的活动记录模式类
+import lombok.Data;  // Lombok注解，用于自动生成getter、setter等方法
 
 /**
 * <p>
 * 试题题库实体类
 * </p>
 *
+* 该类用于映射试题和题库之间的关系，表示一道题目属于某个题库，并可能具有排序。
+* 
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Data
-@TableName("el_qu_repo")
+@Data  // Lombok注解，自动生成getter、setter等方法
+@TableName("el_qu_repo")  // MyBatis Plus注解，指定与数据库表的映射关系
 public class QuRepo extends Model<QuRepo> {
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;  // 序列化版本UID
 
-    @TableId(value = "id", type = IdType.ASSIGN_ID)
-    private String id;
+    /**
+     * 试题题库关系ID
+     * 主键，唯一标识一条题目与题库的关联记录。
+     */
+    @TableId(value = "id", type = IdType.ASSIGN_ID)  // MyBatis Plus注解，指定主键生成策略为自定义ID
+    private String id;  // 试题题库关系ID
 
     /**
-     * 试题
+     * 试题ID
+     * 关联的题目ID，表示某道题目属于哪个题库。
      */
-    @TableField("qu_id")
-    private String quId;
+    @TableField("qu_id")  // MyBatis Plus注解，指定字段名与数据库表字段名映射
+    private String quId;  // 试题ID
 
     /**
-     * 归属题库
+     * 题库ID
+     * 关联的题库ID，表示该题目属于哪个题库。
      */
-    @TableField("repo_id")
-    private String repoId;
+    @TableField("repo_id")  // MyBatis Plus注解，指定字段名与数据库表字段名映射
+    private String repoId;  // 题库ID
 
     /**
      * 题目类型
+     * 用于描述该题目所属的类型（例如：选择题、填空题等）。
      */
-    @TableField("qu_type")
-    private Integer quType;
+    @TableField("qu_type")  // MyBatis Plus注解，映射数据库中的字段
+    private Integer quType;  // 题目类型
 
     /**
      * 排序
+     * 用于对题库中的题目进行排序。
      */
-    private Integer sort;
-    
+    private Integer sort;  // 排序
 }

src-源文件/main/java/com/yf/exam/modules/qu/enums/QuType.java

@@ -1,8 +1,10 @@
 package com.yf.exam.modules.qu.enums;
 
-
 /**
- * 题目类型
+ * 题目类型接口
+ * 
+ * 该接口定义了不同类型的题目标识常量，适用于题库系统中对题目类型的区分。
+ * 
  * @author bool 
  * @date 2019-10-30 13:11
  */
@@ -10,16 +12,19 @@ public interface QuType {
 
     /**
      * 单选题
+     * 表示一道题目是单选题，用户只能选择一个答案。
      */
     Integer RADIO = 1;
 
     /**
      * 多选题
+     * 表示一道题目是多选题，用户可以选择多个答案。
      */
     Integer MULTI = 2;
 
     /**
      * 判断题
+     * 表示一道题目是判断题，通常是选择“正确”或“错误”两种答案。
      */
     Integer JUDGE = 3;
     

src-源文件/main/java/com/yf/exam/modules/qu/mapper/QuAnswerMapper.java

@@ -4,13 +4,13 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.yf.exam.modules.qu.entity.QuAnswer;
 
 /**
-* <p>
-* 候选答案Mapper
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 13:23
-*/
+ * <p>
+ * 候选答案Mapper
+ * </p>
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 13:23
+ */
 public interface QuAnswerMapper extends BaseMapper<QuAnswer> {
 
 }

src-源文件/main/java/com/yf/exam/modules/qu/mapper/QuMapper.java

@@ -1,15 +1,15 @@
-package com.yf.exam.modules.qu.mapper;
+package com.yf.exam.modules.qu.mapper; // 定义包名，用于存放与问题题目相关的 Mapper 类
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.yf.exam.modules.qu.dto.QuDTO;
-import com.yf.exam.modules.qu.dto.export.QuExportDTO;
-import com.yf.exam.modules.qu.dto.request.QuQueryReqDTO;
-import com.yf.exam.modules.qu.entity.Qu;
-import org.apache.ibatis.annotations.Param;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 的 BaseMapper，用于提供通用的 CRUD 方法
+import com.baomidou.mybatisplus.core.metadata.IPage; // 导入分页接口 IPage，用于处理分页结果
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入分页插件的 Page 类，用于分页查询
+import com.yf.exam.modules.qu.dto.QuDTO; // 导入 QuDTO 数据传输对象，用于封装题目数据
+import com.yf.exam.modules.qu.dto.export.QuExportDTO; // 导入 QuExportDTO 用于题目导出的数据结构
+import com.yf.exam.modules.qu.dto.request.QuQueryReqDTO; // 导入 QuQueryReqDTO 用于封装查询条件
+import com.yf.exam.modules.qu.entity.Qu; // 导入 Qu 实体类，表示题目表的对应数据
+import org.apache.ibatis.annotations.Param; // 导入 MyBatis 的 Param 注解，用于 SQL 查询中的参数传递
 
-import java.util.List;
+import java.util.List; // 导入 List，用于返回多个对象的集合
 
 /**
 * <p>
@@ -19,38 +19,34 @@ import java.util.List;
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-public interface QuMapper extends BaseMapper<Qu> {
-
-
+public interface QuMapper extends BaseMapper<Qu> { // QuMapper 继承自 BaseMapper，提供基本的 CRUD 操作
 
     /**
      * 随机抽取题库的数据
-     * @param repoId
-     * @param quType
-     * @param level
+     * @param repoId 题库ID
+     * @param quType 题目类型
+     * @param level 题目难度
      * @param excludes 要排除的ID列表
-     * @param size
-     * @return
+     * @param size 抽取题目的数量
+     * @return 随机抽取的题目列表
      */
-    List<Qu> listByRandom(@Param("repoId") String repoId,
-                          @Param("quType") Integer quType,
-                          @Param("excludes") List<String> excludes,
-                          @Param("size") Integer size);
+    List<Qu> listByRandom(@Param("repoId") String repoId, // 题库ID
+                          @Param("quType") Integer quType, // 题目类型
+                          @Param("excludes") List<String> excludes, // 要排除的题目ID列表
+                          @Param("size") Integer size); // 抽取的题目数量
 
     /**
      * 查找导出列表
-     * @param query
-     * @return
+     * @param query 查询条件对象
+     * @return 返回符合条件的题目列表，用于导出
      */
-    List<QuExportDTO> listForExport(@Param("query") QuQueryReqDTO query);
+    List<QuExportDTO> listForExport(@Param("query") QuQueryReqDTO query); // 根据查询条件查找导出数据
 
     /**
      * 分页查找
-     * @param page
-     * @param query
-     * @return
+     * @param page 分页参数，包含当前页和每页大小
+     * @param query 查询条件对象
+     * @return 返回分页的题目数据
      */
-    IPage<QuDTO> paging(Page page, @Param("query") QuQueryReqDTO query);
-
-
+    IPage<QuDTO> paging(Page page, @Param("query") QuQueryReqDTO query); // 分页查询题目数据，返回 QuDTO 类型的数据
 }

src-源文件/main/java/com/yf/exam/modules/qu/mapper/QuRepoMapper.java

@@ -1,7 +1,7 @@
-package com.yf.exam.modules.qu.mapper;
+package com.yf.exam.modules.qu.mapper; // 定义包名，用于存放与试题题库相关的 Mapper 类
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.yf.exam.modules.qu.entity.QuRepo;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 的 BaseMapper，用于提供通用的 CRUD 方法
+import com.yf.exam.modules.qu.entity.QuRepo; // 导入 QuRepo 实体类，表示试题题库表的数据
 
 /**
 * <p>
@@ -11,6 +11,5 @@ import com.yf.exam.modules.qu.entity.QuRepo;
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-public interface QuRepoMapper extends BaseMapper<QuRepo> {
-
+public interface QuRepoMapper extends BaseMapper<QuRepo> { // QuRepoMapper 继承自 BaseMapper，提供基本的 CRUD 操作
 }

src-源文件/main/java/com/yf/exam/modules/qu/service/QuAnswerService.java

@@ -10,7 +10,7 @@ import java.util.List;
 
 /**
 * <p>
-* 候选答案业务类
+* 候选答案业务类接口，定义了与试题答案相关的业务操作
 * </p>
 *
 * @author 聪明笨狗
@@ -19,30 +19,30 @@ import java.util.List;
 public interface QuAnswerService extends IService<QuAnswer> {
 
     /**
-    * 分页查询数据
-    * @param reqDTO
-    * @return
+    * 分页查询答案数据
+    * @param reqDTO 请求的分页和查询参数
+    * @return 分页的答案数据
     */
     IPage<QuAnswerDTO> paging(PagingReqDTO<QuAnswerDTO> reqDTO);
 
     /**
-     * 根据题目ID查询答案并随机
-     * @param quId
-     * @return
+     * 根据题目ID查询答案，并进行随机排序
+     * @param quId 题目ID
+     * @return 随机排序后的答案列表
      */
     List<QuAnswer> listAnswerByRandom(String quId);
 
     /**
-     * 根据问题查找答案
-     * @param quId
-     * @return
+     * 根据题目ID查询所有的答案
+     * @param quId 题目ID
+     * @return 该题目的答案列表
      */
     List<QuAnswerDTO> listByQu(String quId);
 
     /**
-     * 保存试题
-     * @param quId
-     * @param list
+     * 保存所有选项数据
+     * @param quId 题目ID
+     * @param list 题目的所有答案选项
      */
     void saveAll(String quId, List<QuAnswerDTO> list);
 }

src-源文件/main/java/com/yf/exam/modules/qu/service/QuRepoService.java

@@ -1,58 +1,65 @@
+// 定义包名，表示该接口属于com.yf.exam.modules.qu.service包下
 package com.yf.exam.modules.qu.service;
 
+// 导入MyBatis Plus框架的分页功能相关类
 import com.baomidou.mybatisplus.core.metadata.IPage;
+// 导入MyBatis Plus框架的服务接口
 import com.baomidou.mybatisplus.extension.service.IService;
+// 导入项目中定义的分页请求DTO类
 import com.yf.exam.core.api.dto.PagingReqDTO;
+// 导入项目中定义的题库DTO类
 import com.yf.exam.modules.qu.dto.QuRepoDTO;
+// 导入项目中定义的批量请求DTO类
 import com.yf.exam.modules.qu.dto.request.QuRepoBatchReqDTO;
+// 导入项目中定义的题库实体类
 import com.yf.exam.modules.qu.entity.QuRepo;
-
+// 导入Java.util包下的List接口，用于操作列表
 import java.util.List;
 
 /**
-* <p>
-* 试题题库业务类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 13:23
-*/
+ * <p>
+ * 试题题库业务接口，定义了题库相关的业务操作
+ * </p>
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 13:23
+ */
 public interface QuRepoService extends IService<QuRepo> {
 
     /**
-    * 分页查询数据
-    * @param reqDTO
-    * @return
+     * 分页查询题库数据的方法
+     * @param reqDTO 分页请求DTO，包含分页信息和查询条件
+     * @return 返回分页响应，包含题库数据和分页信息
      */
     IPage<QuRepoDTO> paging(PagingReqDTO<QuRepoDTO> reqDTO);
 
     /**
-     * 保存全部列表
-     * @param quId
-     * @param quType
-     * @param ids
+     * 保存全部列表的方法，用于保存题目与题库的关系
+     * @param quId 题目ID
+     * @param quType 题目类型
+     * @param ids 题库ID列表
      */
     void saveAll(String quId, Integer quType, List<String> ids);
 
     /**
-     * 根据问题查找题库
-     * @param quId
-     * @return
+     * 根据题目查找题库的方法
+     * @param quId 题目ID
+     * @return 返回与题目关联的题库ID列表
      */
     List<String> listByQu(String quId);
 
     /**
-     * 根据题库查找题目ID列表
-     * @param repoId
-     * @param quType
-     * @param rand
-     * @return
+     * 根据题库查找题目ID列表的方法
+     * @param repoId 题库ID
+     * @param quType 题目类型
+     * @param rand 是否随机选择
+     * @return 返回题目ID列表
      */
     List<String> listByRepo(String repoId, Integer quType, boolean rand);
 
     /**
-     * 批量操作
-     * @param reqDTO
+     * 批量操作的方法，用于执行批量业务操作
+     * @param reqDTO 批量请求DTO，包含批量操作信息
      */
     void batchAction(QuRepoBatchReqDTO reqDTO);
 

src-源文件/main/java/com/yf/exam/modules/qu/service/QuService.java

@@ -1,46 +1,55 @@
+// 定义包名，表示该接口属于com.yf.exam.modules.qu.service包下
 package com.yf.exam.modules.qu.service;
 
+// 导入MyBatis Plus框架的分页功能相关类
 import com.baomidou.mybatisplus.core.metadata.IPage;
+// 导入MyBatis Plus框架的服务接口
 import com.baomidou.mybatisplus.extension.service.IService;
+// 导入项目中定义的分页请求DTO类
 import com.yf.exam.core.api.dto.PagingReqDTO;
+// 导入项目中定义的题目DTO类
 import com.yf.exam.modules.qu.dto.QuDTO;
+// 导入项目中定义的题目导出DTO类
 import com.yf.exam.modules.qu.dto.export.QuExportDTO;
+// 导入项目中定义的扩展题目详情DTO类
 import com.yf.exam.modules.qu.dto.ext.QuDetailDTO;
+// 导入项目中定义的题目查询请求DTO类
 import com.yf.exam.modules.qu.dto.request.QuQueryReqDTO;
+// 导入项目中定义的题目实体类
 import com.yf.exam.modules.qu.entity.Qu;
-
+// 导入Java.util包下的List接口，用于操作列表
 import java.util.List;
 
 /**
-* <p>
-* 问题题目业务类
-* </p>
-*
-* @author 聪明笨狗
-* @since 2020-05-25 13:23
-*/
+ * <p>
+ * 问题题目业务接口，定义了题目相关的业务操作
+ * </p>
+ *
+ * @author 聪明笨狗
+ * @since 2020-05-25 13:23
+ */
 public interface QuService extends IService<Qu> {
 
     /**
-     * 分页查询数据
-     * @param reqDTO
-     * @return
+     * 分页查询题目数据的方法
+     * @param reqDTO 分页请求DTO，包含分页信息和查询条件
+     * @return 返回分页响应，包含题目数据和分页信息
      */
     IPage<QuDTO> paging(PagingReqDTO<QuQueryReqDTO> reqDTO);
 
     /**
-     * 删除试题
-     * @param ids
+     * 删除题目的方法
+     * @param ids 题目ID列表
      */
     void delete(List<String> ids);
 
     /**
-     * 随机抽取题库的数据
-     * @param repoId
-     * @param quType
+     * 随机抽取题库中的数据的方法
+     * @param repoId 题库ID
+     * @param quType 题目类型
      * @param excludes 要排除的ID列表
-     * @param size
-     * @return
+     * @param size 抽取的数量
+     * @return 返回随机抽取的题目列表
      */
     List<Qu> listByRandom(String repoId,
                           Integer quType,
@@ -48,29 +57,29 @@ public interface QuService extends IService<Qu> {
                           Integer size);
 
     /**
-     * 问题详情
-     * @param id
-     * @return
+     * 查询题目详情的方法
+     * @param id 题目ID
+     * @return 返回题目详情DTO
      */
     QuDetailDTO detail(String id);
 
     /**
-     * 保存试题
-     * @param reqDTO
+     * 保存题目的方法
+     * @param reqDTO 题目详情DTO
      */
     void save(QuDetailDTO reqDTO);
 
     /**
-     * 查找导出列表
-     * @param query
-     * @return
+     * 查找导出列表的方法
+     * @param query 题目查询请求DTO
+     * @return 返回题目导出列表
      */
     List<QuExportDTO> listForExport(QuQueryReqDTO query);
 
     /**
-     * 导入Excel
-     * @param dtoList
-     * @return
+     * 导入Excel数据的方法
+     * @param dtoList 题目导出DTO列表
+     * @return 返回导入的结果，影响的行数
      */
     int importExcel(List<QuExportDTO> dtoList);
 }

src-源文件/main/java/com/yf/exam/modules/qu/service/impl/QuAnswerServiceImpl.java

@@ -1,24 +1,24 @@
-package com.yf.exam.modules.qu.service.impl;
-
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.TypeReference;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.core.utils.BeanMapper;
-import com.yf.exam.modules.qu.dto.QuAnswerDTO;
-import com.yf.exam.modules.qu.entity.QuAnswer;
-import com.yf.exam.modules.qu.mapper.QuAnswerMapper;
-import com.yf.exam.modules.qu.service.QuAnswerService;
-import com.yf.exam.modules.qu.utils.ImageCheckUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-import java.util.ArrayList;
-import java.util.List;
+package com.yf.exam.modules.qu.service.impl; // 定义包名，表示这是实现类部分，专注于处理与试题答案相关的逻辑
+
+import com.alibaba.fastjson.JSON; // 导入 fastjson 库，用于 JSON 序列化和反序列化
+import com.alibaba.fastjson.TypeReference; // 导入 fastjson 库的 TypeReference，用于处理泛型类型
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入 MyBatis-Plus 的 QueryWrapper，用于构造查询条件
+import com.baomidou.mybatisplus.core.metadata.IPage; // 导入 MyBatis-Plus 的 IPage 接口，用于分页查询
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入 MyBatis-Plus 的分页 Page 类
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 导入 MyBatis-Plus 的 ServiceImpl 基类
+import com.yf.exam.core.api.dto.PagingReqDTO; // 导入分页请求数据传输对象类
+import com.yf.exam.core.utils.BeanMapper; // 导入 BeanMapper 工具类，用于对象之间的映射
+import com.yf.exam.modules.qu.dto.QuAnswerDTO; // 导入试题答案的 DTO 类
+import com.yf.exam.modules.qu.entity.QuAnswer; // 导入试题答案的实体类
+import com.yf.exam.modules.qu.mapper.QuAnswerMapper; // 导入试题答案的 Mapper 接口
+import com.yf.exam.modules.qu.service.QuAnswerService; // 导入试题答案的服务接口
+import com.yf.exam.modules.qu.utils.ImageCheckUtils; // 导入图片校验工具类
+import org.springframework.beans.factory.annotation.Autowired; // 导入 Spring 的注解，自动注入依赖
+import org.springframework.stereotype.Service; // 导入 Spring 的服务注解，标识这是一个服务类
+import org.springframework.util.CollectionUtils; // 导入 Spring 的集合工具类，用于检查集合是否为空
+
+import java.util.ArrayList; // 导入 ArrayList，用于动态数组
+import java.util.List; // 导入 List 接口，作为列表类型
 
 /**
 * <p>
@@ -28,65 +28,77 @@ import java.util.List;
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Service
+@Service // 表示这是一个服务类，Spring 会自动扫描并管理该类
 public class QuAnswerServiceImpl extends ServiceImpl<QuAnswerMapper, QuAnswer> implements QuAnswerService {
 
     @Autowired
-    private ImageCheckUtils imageCheckUtils;
+    private ImageCheckUtils imageCheckUtils; // 自动注入图片校验工具类，用于校验图片地址是否合法
 
     @Override
     public IPage<QuAnswerDTO> paging(PagingReqDTO<QuAnswerDTO> reqDTO) {
-
-        //创建分页对象
+        // 创建分页对象，传入当前页和每页大小
         IPage<QuAnswer> query = new Page<>(reqDTO.getCurrent(), reqDTO.getSize());
 
-        //查询条件
+        // 创建查询条件包装器
         QueryWrapper<QuAnswer> wrapper = new QueryWrapper<>();
 
-        //获得数据
+        // 执行分页查询，获取分页结果
         IPage<QuAnswer> page = this.page(query, wrapper);
-        //转换结果
+        
+        // 将查询结果转换为 QuAnswerDTO 类型的分页结果
         IPage<QuAnswerDTO> pageData = JSON.parseObject(JSON.toJSONString(page), new TypeReference<Page<QuAnswerDTO>>(){});
         return pageData;
     }
 
     @Override
     public List<QuAnswer> listAnswerByRandom(String quId) {
+        // 创建查询条件包装器
         QueryWrapper<QuAnswer> wrapper = new QueryWrapper<>();
+        // 设置查询条件，过滤出与 quId 相同的记录
         wrapper.lambda().eq(QuAnswer::getQuId, quId);
+        // 使用 SQL 的随机排序来随机获取答案
         wrapper.last(" ORDER BY RAND() ");
 
+        // 执行查询并返回结果
         return this.list(wrapper);
     }
 
     @Override
     public List<QuAnswerDTO> listByQu(String quId) {
+        // 创建查询条件包装器
         QueryWrapper<QuAnswer> wrapper = new QueryWrapper<>();
+        // 设置查询条件，过滤出与 quId 相同的记录
         wrapper.lambda().eq(QuAnswer::getQuId, quId);
 
+        // 执行查询，获取答案列表
         List<QuAnswer> list = this.list(wrapper);
         if(!CollectionUtils.isEmpty(list)){
+            // 将 QuAnswer 实体对象列表转换为 QuAnswerDTO 对象列表
             return BeanMapper.mapList(list, QuAnswerDTO.class);
         }
 
+        // 如果没有找到记录，返回 null
         return null;
     }
 
-
     /**
      * 查找已存在的列表
-     * @param quId
-     * @return
+     * @param quId 试题ID
+     * @return 已存在答案的 ID 列表
      */
     public List<String> findExistsList(String quId) {
-        //返回结果
+        // 创建空的结果列表
         List<String> ids = new ArrayList<>();
 
+        // 创建查询条件包装器
         QueryWrapper<QuAnswer> wrapper = new QueryWrapper();
+        // 设置查询条件，过滤出与 quId 相同的记录
         wrapper.lambda().eq(QuAnswer::getQuId, quId);
+        // 执行查询，获取答案列表
         List<QuAnswer> list = this.list(wrapper);
 
         if (!CollectionUtils.isEmpty(list)) {
+            // 将已有的答案 ID 添加到结果列表
             for (QuAnswer item : list) {
                 ids.add(item.getId());
             }
@@ -96,49 +108,49 @@ public class QuAnswerServiceImpl extends ServiceImpl<QuAnswerMapper, QuAnswer> i
 
     @Override
     public void saveAll(String quId, List<QuAnswerDTO> list) {
-
-        //最终要保存的列表
+        // 创建保存的答案列表
         List<QuAnswer> saveList = new ArrayList<>();
 
-        //已存在的标签列表
+        // 获取已有的答案 ID 列表
         List<String> ids = this.findExistsList(quId);
 
+        // 如果答案列表不为空，则进行处理
         if(!CollectionUtils.isEmpty(list)){
             for(QuAnswerDTO item: list){
 
-                // 校验图片地址
+                // 校验选项图片地址是否合法
                 imageCheckUtils.checkImage(item.getImage(), "选项图片地址错误！");
 
-                //标签ID
+                // 获取答案 ID
                 String id = item.getId();
                 QuAnswer answer = new QuAnswer();
+                // 将 DTO 转换为实体类
                 BeanMapper.copy(item, answer);
-                answer.setQuId(quId);
+                answer.setQuId(quId); // 设置试题 ID
 
-                //补全ID避免新增
+                // 如果该答案已存在，则从 IDs 列表中移除
                 if(ids.contains(id)){
                     ids.remove(id);
                 }
 
+                // 添加答案到保存列表
                 saveList.add(answer);
             }
 
-            //保存标签列表
+            // 如果有待保存的答案，则批量保存或更新
             if(!CollectionUtils.isEmpty(saveList)) {
                 this.saveOrUpdateBatch(saveList);
             }
 
-            //删除已移除
+            // 如果有被移除的答案，则批量删除
             if(!ids.isEmpty()){
                 this.removeByIds(ids);
             }
         }else{
-
+            // 如果答案列表为空，则删除所有与该试题 ID 相关的答案
             QueryWrapper<QuAnswer> wrapper = new QueryWrapper<>();
             wrapper.lambda().eq(QuAnswer::getQuId, quId);
             this.remove(wrapper);
         }
     }
-
-
 }

src-源文件/main/java/com/yf/exam/modules/qu/service/impl/QuRepoServiceImpl.java

@@ -1,175 +1,182 @@
-package com.yf.exam.modules.qu.service.impl;
-
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.TypeReference;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.yf.exam.core.api.dto.PagingReqDTO;
-import com.yf.exam.modules.qu.dto.QuRepoDTO;
-import com.yf.exam.modules.qu.dto.request.QuRepoBatchReqDTO;
-import com.yf.exam.modules.qu.entity.Qu;
-import com.yf.exam.modules.qu.entity.QuRepo;
-import com.yf.exam.modules.qu.mapper.QuMapper;
-import com.yf.exam.modules.qu.mapper.QuRepoMapper;
-import com.yf.exam.modules.qu.service.QuRepoService;
-import com.yf.exam.modules.repo.service.RepoService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-import java.util.ArrayList;
-import java.util.List;
+package com.yf.exam.modules.qu.service.impl; // 定义包名，表示这是服务实现类，负责处理与试题题库相关的业务逻辑
+
+import com.alibaba.fastjson.JSON; // 导入 fastjson 库，用于 JSON 序列化和反序列化
+import com.alibaba.fastjson.TypeReference; // 导入 fastjson 库的 TypeReference，用于处理泛型类型
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入 MyBatis-Plus 的 QueryWrapper，用于构造查询条件
+import com.baomidou.mybatisplus.core.metadata.IPage; // 导入 MyBatis-Plus 的 IPage 接口，用于分页查询
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入 MyBatis-Plus 的分页 Page 类
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 导入 MyBatis-Plus 的 ServiceImpl 基类
+import com.yf.exam.core.api.dto.PagingReqDTO; // 导入分页请求数据传输对象类
+import com.yf.exam.modules.qu.dto.QuRepoDTO; // 导入试题题库的 DTO 类
+import com.yf.exam.modules.qu.dto.request.QuRepoBatchReqDTO; // 导入试题题库批量操作请求类
+import com.yf.exam.modules.qu.entity.Qu; // 导入试题实体类
+import com.yf.exam.modules.qu.entity.QuRepo; // 导入试题题库实体类
+import com.yf.exam.modules.qu.mapper.QuMapper; // 导入试题的 Mapper 接口
+import com.yf.exam.modules.qu.mapper.QuRepoMapper; // 导入试题题库的 Mapper 接口
+import com.yf.exam.modules.qu.service.QuRepoService; // 导入试题题库服务接口
+import com.yf.exam.modules.repo.service.RepoService; // 导入题库服务接口
+import org.springframework.beans.factory.annotation.Autowired; // 导入 Spring 的注解，自动注入依赖
+import org.springframework.stereotype.Service; // 导入 Spring 的服务注解，标识这是一个服务类
+import org.springframework.util.CollectionUtils; // 导入 Spring 的集合工具类，用于检查集合是否为空
+
+import java.util.ArrayList; // 导入 ArrayList，用于动态数组
+import java.util.List; // 导入 List 接口，作为列表类型
 
 /**
 * <p>
-* 语言设置 服务实现类
+* 试题题库 服务实现类
 * </p>
 *
 * @author 聪明笨狗
 * @since 2020-05-25 13:23
 */
-@Service
+@Service // 表示这是一个 Spring 服务类，Spring 会自动扫描并管理该类
 public class QuRepoServiceImpl extends ServiceImpl<QuRepoMapper, QuRepo> implements QuRepoService {
 
-
     @Autowired
-    private QuMapper quMapper;
+    private QuMapper quMapper; // 自动注入试题的 Mapper 接口
 
     @Autowired
-    private RepoService repoService;
+    private RepoService repoService; // 自动注入题库服务接口
 
     @Override
     public IPage<QuRepoDTO> paging(PagingReqDTO<QuRepoDTO> reqDTO) {
-
-        //创建分页对象
+        // 创建分页对象，传入当前页和每页大小
         IPage<QuRepo> query = new Page<>(reqDTO.getCurrent(), reqDTO.getSize());
 
-        //查询条件
+        // 创建查询条件包装器
         QueryWrapper<QuRepo> wrapper = new QueryWrapper<>();
 
-        //获得数据
+        // 执行分页查询，获取分页结果
         IPage<QuRepo> page = this.page(query, wrapper);
-        //转换结果
+
+        // 将查询结果转换为 QuRepoDTO 类型的分页结果
         IPage<QuRepoDTO> pageData = JSON.parseObject(JSON.toJSONString(page), new TypeReference<Page<QuRepoDTO>>(){});
         return pageData;
     }
 
     @Override
     public void saveAll(String quId, Integer quType, List<String> ids) {
-        // 先删除
+        // 先删除已有的试题题库记录
         QueryWrapper<QuRepo> wrapper = new QueryWrapper<>();
         wrapper.lambda().eq(QuRepo::getQuId, quId);
         this.remove(wrapper);
 
-        // 保存全部
+        // 如果题库 ID 列表不为空，保存新的记录
         if(!CollectionUtils.isEmpty(ids)){
             List<QuRepo> list = new ArrayList<>();
             for(String id: ids){
                 QuRepo ref = new QuRepo();
-                ref.setQuId(quId);
-                ref.setRepoId(id);
-                ref.setQuType(quType);
+                ref.setQuId(quId); // 设置试题 ID
+                ref.setRepoId(id); // 设置题库 ID
+                ref.setQuType(quType); // 设置题目类型
                 list.add(ref);
             }
+            // 批量保存试题题库记录
             this.saveBatch(list);
 
-
+            // 对每个题库进行排序
             for(String id: ids){
                 this.sortRepo(id);
             }
         }
-
-
     }
 
     @Override
     public List<String> listByQu(String quId) {
-        // 先删除
+        // 根据试题 ID 查找题库记录
         QueryWrapper<QuRepo> wrapper = new QueryWrapper<>();
         wrapper.lambda().eq(QuRepo::getQuId, quId);
         List<QuRepo> list = this.list(wrapper);
         List<String> ids = new ArrayList<>();
         if(!CollectionUtils.isEmpty(list)){
+            // 提取题库 ID 列表
             for(QuRepo item: list){
                 ids.add(item.getRepoId());
             }
         }
-        return ids;
+        return ids; // 返回题库 ID 列表
     }
 
     @Override
     public List<String> listByRepo(String repoId, Integer quType, boolean rand) {
+        // 根据题库 ID 和题目类型查询题库记录
         QueryWrapper<QuRepo> wrapper = new QueryWrapper<>();
-        wrapper.lambda()
-                .eq(QuRepo::getRepoId, repoId);
+        wrapper.lambda().eq(QuRepo::getRepoId, repoId);
 
-        if(quType!=null){
+        // 如果有题目类型，添加过滤条件
+        if(quType != null){
             wrapper.lambda().eq(QuRepo::getQuType, quType);
         }
 
+        // 根据是否需要随机排序决定排序方式
         if(rand){
-            wrapper.orderByAsc(" RAND() ");
+            wrapper.orderByAsc(" RAND() "); // 随机排序
         }else{
-            wrapper.lambda().orderByAsc(QuRepo::getSort);
+            wrapper.lambda().orderByAsc(QuRepo::getSort); // 按照排序字段排序
         }
 
+        // 执行查询，获取题库记录列表
         List<QuRepo> list = this.list(wrapper);
         List<String> ids = new ArrayList<>();
         if(!CollectionUtils.isEmpty(list)){
+            // 提取试题 ID 列表
             for(QuRepo item: list){
                 ids.add(item.getQuId());
             }
         }
-        return ids;
+        return ids; // 返回试题 ID 列表
     }
 
     @Override
     public void batchAction(QuRepoBatchReqDTO reqDTO) {
-
-        // 移除的
-        if(reqDTO.getRemove()!=null &&  reqDTO.getRemove()){
+        // 如果需要移除记录
+        if(reqDTO.getRemove() != null && reqDTO.getRemove()){
+            // 删除满足条件的题库记录
             QueryWrapper<QuRepo> wrapper = new QueryWrapper<>();
             wrapper.lambda()
                     .in(QuRepo::getRepoId, reqDTO.getRepoIds())
                     .in(QuRepo::getQuId, reqDTO.getQuIds());
             this.remove(wrapper);
         }else{
-
-            // 新增的
+            // 如果是新增记录，处理新增逻辑
             for(String quId : reqDTO.getQuIds()){
+                // 根据试题 ID 查询试题类型
                 Qu q = quMapper.selectById(quId);
+                // 保存新的题库记录
                 this.saveAll(quId, q.getQuType(), reqDTO.getRepoIds());
             }
         }
 
+        // 对每个题库进行排序
         for(String id: reqDTO.getRepoIds()){
             this.sortRepo(id);
         }
-
     }
 
-
     /**
      * 单个题库进行排序
-     * @param repoId
+     * @param repoId 题库 ID
      */
     private void sortRepo(String repoId){
-
+        // 查询题库下的所有试题
         QueryWrapper<QuRepo> wrapper = new QueryWrapper<>();
         wrapper.lambda().eq(QuRepo::getRepoId, repoId);
-
         List<QuRepo> list = this.list(wrapper);
+
+        // 如果题库下没有试题，返回
         if(CollectionUtils.isEmpty(list)){
             return;
         }
 
+        // 按照顺序设置每个试题的排序值
         int sort = 1;
         for(QuRepo item: list){
             item.setSort(sort);
             sort++;
         }
+
+        // 批量更新排序值
         this.updateBatchById(list);
     }
 }

src-源文件/main/java/com/yf/exam/modules/qu/service/impl/QuServiceImpl.java

@@ -1,9 +1,12 @@
 package com.yf.exam.modules.qu.service.impl;
 
+// 导入MyBatis Plus相关类
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+
+// 导入其他相关类
 import com.yf.exam.ability.upload.config.UploadConfig;
 import com.yf.exam.core.api.dto.PagingReqDTO;
 import com.yf.exam.core.exception.ServiceException;
@@ -23,6 +26,7 @@ import com.yf.exam.modules.qu.service.QuRepoService;
 import com.yf.exam.modules.qu.service.QuService;
 import com.yf.exam.modules.qu.utils.ImageCheckUtils;
 import com.yf.exam.modules.repo.service.RepoService;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -37,7 +41,7 @@ import java.util.Map;
 
 /**
  * <p>
- * 语言设置 服务实现类
+ * 题目管理服务实现类
  * </p>
  *
  * @author 聪明笨狗
@@ -46,125 +50,136 @@ import java.util.Map;
 @Service
 public class QuServiceImpl extends ServiceImpl<QuMapper, Qu> implements QuService {
 
+    // 注入QuAnswerService服务
     @Autowired
     private QuAnswerService quAnswerService;
 
+    // 注入QuRepoService服务
     @Autowired
     private QuRepoService quRepoService;
 
+    // 注入图片校验工具类
     @Autowired
     private ImageCheckUtils imageCheckUtils;
 
+    // 分页查询题目列表
     @Override
     public IPage<QuDTO> paging(PagingReqDTO<QuQueryReqDTO> reqDTO) {
 
-        //创建分页对象
+        // 创建分页对象
         Page page = new Page<>(reqDTO.getCurrent(), reqDTO.getSize());
 
-        //转换结果
+        // 调用baseMapper的分页查询方法，获取分页数据
         IPage<QuDTO> pageData = baseMapper.paging(page, reqDTO.getParams());
         return pageData;
     }
 
+    // 删除题目、答案和题库绑定
     @Transactional(rollbackFor = Exception.class)
     @Override
     public void delete(List<String> ids) {
-        // 移除题目
+        // 删除题目
         this.removeByIds(ids);
 
-        // 移除选项
+        // 删除与题目相关的选项
         QueryWrapper<QuAnswer> wrapper = new QueryWrapper<>();
         wrapper.lambda().in(QuAnswer::getQuId, ids);
         quAnswerService.remove(wrapper);
 
-        // 移除题库绑定
+        // 删除题库与题目的绑定
         QueryWrapper<QuRepo> wrapper1 = new QueryWrapper<>();
         wrapper1.lambda().in(QuRepo::getQuId, ids);
         quRepoService.remove(wrapper1);
     }
 
+    // 随机获取题目
     @Override
     public List<Qu> listByRandom(String repoId, Integer quType, List<String> excludes, Integer size) {
         return baseMapper.listByRandom(repoId, quType, excludes, size);
     }
 
+    // 获取题目的详细信息
     @Override
     public QuDetailDTO detail(String id) {
 
         QuDetailDTO respDTO = new QuDetailDTO();
+        // 获取题目信息
         Qu qu = this.getById(id);
         BeanMapper.copy(qu, respDTO);
 
+        // 获取题目的选项信息
         List<QuAnswerDTO> answerList = quAnswerService.listByQu(id);
         respDTO.setAnswerList(answerList);
 
+        // 获取题目所属的题库
         List<String> repoIds = quRepoService.listByQu(id);
         respDTO.setRepoIds(repoIds);
 
         return respDTO;
     }
 
-
+    // 保存题目信息
     @Transactional(rollbackFor = Exception.class)
     @Override
     public void save(QuDetailDTO reqDTO) {
 
-
-        // 校验数据
+        // 校验题目信息
         this.checkData(reqDTO, "");
 
         Qu qu = new Qu();
+        // 将题目详情复制到实体类
         BeanMapper.copy(reqDTO, qu);
 
-        // 校验图片地址
+        // 校验图片地址是否正确
         imageCheckUtils.checkImage(qu.getImage(), "题干图片地址错误！");
 
-        // 更新
+        // 保存或更新题目信息
         this.saveOrUpdate(qu);
 
-        // 保存全部问题
+        // 保存题目的选项
         quAnswerService.saveAll(qu.getId(), reqDTO.getAnswerList());
 
-        // 保存到题库
+        // 保存题目与题库的绑定
         quRepoService.saveAll(qu.getId(), qu.getQuType(), reqDTO.getRepoIds());
-
     }
 
+    // 获取题目导出的列表
     @Override
     public List<QuExportDTO> listForExport(QuQueryReqDTO query) {
         return baseMapper.listForExport(query);
     }
 
+    // 导入Excel数据
     @Override
     public int importExcel(List<QuExportDTO> dtoList) {
 
-        //根据题目名称分组
+        // 根据题目名称分组
         Map<Integer, List<QuExportDTO>> anMap = new HashMap<>(16);
 
-        //题目本体信息
+        // 存储题目信息
         Map<Integer, QuExportDTO> quMap = new HashMap<>(16);
 
-        //数据分组
+        // 分组数据
         for (QuExportDTO item : dtoList) {
 
-            // 空白的ID
+            // 如果题目ID为空，跳过
             if (StringUtils.isEmpty(item.getNo())) {
                 continue;
             }
 
             Integer key;
-            //序号
+            // 获取题目序号
             try {
                 key = Integer.parseInt(item.getNo());
             } catch (Exception e) {
                 continue;
             }
 
-            //如果已经有题目了，直接处理选项
+            // 如果题目已存在，直接处理选项
             if (anMap.containsKey(key)) {
                 anMap.get(key).add(item);
             } else {
-                //如果没有，将题目内容和选项一起
+                // 如果没有，将题目内容和选项一起放入
                 List<QuExportDTO> subList = new ArrayList<>();
                 subList.add(item);
                 anMap.put(key, subList);
@@ -174,49 +189,46 @@ public class QuServiceImpl extends ServiceImpl<QuMapper, Qu> implements QuServic
 
         int count = 0;
         try {
-
-            //循环题目插入
+            // 遍历题目插入
             for (Integer key : quMap.keySet()) {
 
                 QuExportDTO im = quMap.get(key);
 
-                //题目基本信息
+                // 处理题目的基本信息
                 QuDetailDTO qu = new QuDetailDTO();
                 qu.setContent(im.getQContent());
                 qu.setAnalysis(im.getQAnalysis());
                 qu.setQuType(Integer.parseInt(im.getQuType()));
                 qu.setCreateTime(new Date());
 
-                //设置回答列表
+                // 设置题目的回答列表
                 List<QuAnswerDTO> answerList = this.processAnswerList(anMap.get(key));
-                //设置题目
                 qu.setAnswerList(answerList);
-                //设置引用题库
+
+                // 设置题目所属的题库
                 qu.setRepoIds(im.getRepoList());
-                // 保存答案
+
+                // 保存题目
                 this.save(qu);
                 count++;
             }
 
         } catch (ServiceException e) {
             e.printStackTrace();
+            // 异常处理，抛出导入失败的异常
             throw new ServiceException(1, "导入出现问题，行：" + count + "，" + e.getMessage());
         }
 
         return count;
     }
 
-    /**
-     * 处理回答列表
-     *
-     * @param importList
-     * @return
-     */
+    // 处理题目的回答列表
     private List<QuAnswerDTO> processAnswerList(List<QuExportDTO> importList) {
 
         List<QuAnswerDTO> list = new ArrayList<>(16);
         for (QuExportDTO item : importList) {
             QuAnswerDTO a = new QuAnswerDTO();
+            // 设置选项是否正确
             a.setIsRight("1".equals(item.getAIsRight()));
             a.setContent(item.getAContent());
             a.setAnalysis(item.getAAnalysis());
@@ -226,58 +238,52 @@ public class QuServiceImpl extends ServiceImpl<QuMapper, Qu> implements QuServic
         return list;
     }
 
-    /**
-     * 校验题目信息
-     *
-     * @param qu
-     * @param no
-     * @throws Exception
-     */
+    // 校验题目信息
     public void checkData(QuDetailDTO qu, String no) {
 
-
+        // 校验题目内容不能为空
         if (StringUtils.isEmpty(qu.getContent())) {
             throw new ServiceException(1, no + "题目内容不能为空！");
         }
 
-
+        // 校验至少选择一个题库
         if (CollectionUtils.isEmpty(qu.getRepoIds())) {
             throw new ServiceException(1, no + "至少要选择一个题库！");
         }
 
+        // 校验回答选项
         List<QuAnswerDTO> answers = qu.getAnswerList();
-
-
         if (CollectionUtils.isEmpty(answers)) {
             throw new ServiceException(1, no + "客观题至少要包含一个备选答案！");
         }
 
-
         int trueCount = 0;
         for (QuAnswerDTO a : answers) {
 
+            // 校验选项是否定义了正确标志
             if (a.getIsRight() == null) {
                 throw new ServiceException(1, no + "必须定义选项是否正确项！");
             }
 
+            // 校验选项内容不能为空
             if (StringUtils.isEmpty(a.getContent())) {
                 throw new ServiceException(1, no + "选项内容不为空！");
             }
 
+            // 统计正确选项的个数
             if (a.getIsRight()) {
                 trueCount += 1;
             }
         }
 
+        // 校验至少包含一个正确选项
         if (trueCount == 0) {
             throw new ServiceException(1, no + "至少要包含一个正确项！");
         }
 
-
-            //单选题
+        // 单选题不能包含多个正确选项
         if (qu.getQuType().equals(QuType.RADIO) && trueCount > 1) {
             throw new ServiceException(1, no + "单选题不能包含多个正确项！");
         }
-
     }
 }

src-源文件/main/java/com/yf/exam/modules/qu/utils/ImageCheckUtils.java

@@ -1,30 +1,41 @@
+// 定义包名，表示该类属于com.yf.exam.modules.qu.utils包下
 package com.yf.exam.modules.qu.utils;
 
+// 导入项目中定义的上传配置类
 import com.yf.exam.ability.upload.config.UploadConfig;
+// 导入项目中定义的服务异常类
 import com.yf.exam.core.exception.ServiceException;
+// 导入Apache Commons Lang库中的StringUtils类，用于字符串操作
 import org.apache.commons.lang3.StringUtils;
+// 导入Spring框架中的注解，用于自动注入依赖
 import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架中的注解，用于声明组件
 import org.springframework.stereotype.Component;
 
+/**
+ * 图片校验工具类，提供图片地址校验的功能
+ */
 @Component
 public class ImageCheckUtils {
 
+    // 自动注入上传配置，用于获取图片上传的相关配置
     @Autowired
     private UploadConfig conf;
 
     /**
-     * 进行图片校验！
-     * @param image
-     * @param throwMsg
+     * 进行图片校验的方法
+     * @param image 图片地址
+     * @param throwMsg 校验失败时抛出的异常信息
      */
     public void checkImage(String image, String throwMsg) {
-
+        // 如果图片地址为空或空白，则直接返回，不进行校验
         if(StringUtils.isBlank(image)){
             return;
         }
 
-        // 校验图片地址
+        // 校验图片地址是否以配置的URL开头，确保图片地址是合法的
         if(!image.startsWith(conf.getUrl())){
+            // 如果图片地址不合法，则抛出服务异常
             throw new ServiceException(throwMsg);
         }
     }