Merge pull request “更新注释文档”(#4) from feature/qzw into develop

.idea/vcs.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
   </component>
 </project>

backend/src/main/java/lsgwr/exam/ExamApplication.java

@@ -1,15 +1,17 @@
+// 指定当前类所在的包路径，这是Java中组织类的一种方式，有助于类的管理和访问控制。
 package lsgwr.exam;
-
+// 导入Spring Boot的启动类和应用配置自动装配的注解类。
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-
-/**
- * 这是Spring Boot应用程序的主要类。它作为应用程序的入口点，启动Spring Boot应用程序上下文。
- */
+// @SpringBootApplication是一个方便的注解，它包括了@Configuration，@EnableAutoConfiguration，和@ComponentScan注解。
+// 它告诉Spring Boot基于当前类所在包及其子包下的组件来启动自动配置和组件扫描。
 @SpringBootApplication
 public class ExamApplication {
-
-    public static void main(String[] args) {
+    // main方法是Java应用程序的入口点。当运行这个类时，JVM会调用这个方法。
+    public static void main(String[] args)
+    {
+        // SpringApplication.run方法启动Spring应用，传入ExamApplication.class（当前启动类）和main方法的参数args。
+        // 这个方法会执行一系列的操作，包括启动Spring容器，加载应用上下文，自动配置等。
         SpringApplication.run(ExamApplication.class, args);
     }
 }

backend/src/main/java/lsgwr/exam/controller/ExamController.java

@@ -138,6 +138,7 @@ ResultVO<QuestionSelectionVo> getSelections() {
         } catch (Exception e) {
             // 如果获取失败，则打印异常信息，并返回ResultVO对象，状态码为-1，提示信息为"获取问题详情失败"，数据为null。
             e.printStackTrace();
+            // 创建一个表示获取失败的ResultVO对象，状态码设置为 -1，表示获取操作失败，消息设置为"获取问题详情失败"，数据部分设置为null
             resultVO = new ResultVO<>(-1, "获取问题详情失败", null);
         }
         // 返回ResultVO对象。
@@ -199,24 +200,22 @@ ResultVO<QuestionSelectionVo> getSelections() {
     @PostMapping("/create")
     @ApiOperation("创建考试")
     ResultVO<Exam> createExam(@RequestBody ExamCreateVo examCreateVo, HttpServletRequest request) {
-        // 从前端传参数过来，在这里完成考试的入库。
+        // 定义一个ResultVO类型的变量，用于存放最终要返回给客户端的结果对象，其泛型参数指定为Exam，表示包含新创建考试相关信息的结果封装
         ResultVO<Exam> resultVO;
-        // 获取当前用户的id。
+        // 从HttpServletRequest对象中获取用户ID信息，通常这个用户ID是在请求处理的前置环节（比如拦截器中）设置到请求属性中的，用于标识创建这个考试的用户是谁
         String userId = (String) request.getAttribute("user_id");
         try {
-            // 调用examService的create方法，将examCreateVo和userId作为参数传入，创建考试。
+            // 调用ExamService的create方法，将创建考试的视图对象（examCreateVo）和获取到的用户ID传递进去，由服务层实现将考试记录数据保存到数据库等具体的创建逻辑操作，返回创建好的Exam对象代表新创建的考试信息
             Exam exam = examService.create(examCreateVo, userId);
-            // 创建一个ResultVO对象，将创建成功的考试信息返回。
+            // 如果创建成功，创建一个表示成功的ResultVO对象，状态码设置为0，表示创建操作成功，消息设置为"创建考试成功"，并将创建好的考试对象放入ResultVO对象中返回给客户端
             resultVO = new ResultVO<>(0, "创建考试成功", exam);
         } catch (Exception e) {
-            // 捕获异常，打印异常信息，并创建一个ResultVO对象，将创建失败的考试信息返回。
             e.printStackTrace();
+            // 如果在创建过程中出现异常，创建一个表示创建失败的ResultVO对象，状态码设置为 -1，表示创建操作失败，消息设置为"创建考试失败"，数据部分设置为null
             resultVO = new ResultVO<>(-1, "创建考试失败", null);
         }
-        // 返回ResultVO对象。
         return resultVO;
     }
-
     /**
      * @Description: 使用examService.updateExam()获取数据,并将其包装在ResultVO对象中,用于更新考试
      * @param examVo 前端传过来的参数
@@ -243,7 +242,6 @@ ResultVO<QuestionSelectionVo> getSelections() {
         }
         return resultVO;
     }
-
     /**
      * @Description: 获取考试列表，适配前端卡片列表
      * @return ResultVO<List<ExamCardVo>> 对象，包含考试列表卡片信息
@@ -256,17 +254,16 @@ ResultVO<QuestionSelectionVo> getSelections() {
         try {
             // 调用examService的getExamCardList方法获取考试列表卡片。
             List<ExamCardVo> examCardVoList = examService.getExamCardList();
-            // 如果获取成功，则返回成功的结果。
+            // 如果获取数据成功，创建一个表示成功的ResultVO对象，状态码设置为0，表示获取考试列表卡片成功，消息设置为"获取考试列表卡片成功"，并将获取到的考试卡片列表数据放入ResultVO对象中，以便返回给客户端进行展示。
             resultVO = new ResultVO<>(0, "获取考试列表卡片成功", examCardVoList);
         } catch (Exception e) {
             // 如果获取失败，则打印异常信息，并返回失败的结果。
             e.printStackTrace();
+            // 创建一个表示获取失败的ResultVO对象，状态码设置为 -1，表示获取考试列表卡片失败，消息可根据业务实际情况设置为相应的提示语，数据部分设置为null，因为没有成功获取到有效的考试卡片列表数据。
             resultVO = new ResultVO<>(-1, "获取考试列表卡片失败", null);
         }
-        // 返回结果
         return resultVO;
     }
-
     /**
      * @Description: 根据考试的id，获取考试详情
      * @param id 考试id
@@ -275,17 +272,19 @@ ResultVO<QuestionSelectionVo> getSelections() {
     @GetMapping("/detail/{id}")
     @ApiOperation("根据考试的id，获取考试详情")
     ResultVO<ExamDetailVo> getExamDetail(@PathVariable String id) {
-        // 根据id获取考试详情。
+        // 根据id获取考试详情，先定义一个用于存放最终要返回给客户端的ResultVO<ExamDetailVo>类型的结果对象，后续根据查询数据的情况进行赋值操作。
         ResultVO<ExamDetailVo> resultVO;
         try {
+            // 调用ExamService的getExamDetail方法，将接收到的考卷唯一标识符（id）传递进去，由服务层实现从数据库或者其他数据源根据该ID查询对应考卷详细信息的逻辑，返回一个ExamDetailVo对象代表该考卷的所有详细信息。
             ExamDetailVo examDetail = examService.getExamDetail(id);
+            // 如果获取详细信息成功，创建一个表示成功的ResultVO对象，状态码设置为0，表示获取考试详情成功，消息设置为"获取考试详情成功"，并将获取到的考卷详细信息对象放入ResultVO对象中，以便返回给客户端进行展示。
             resultVO = new ResultVO<>(0, "获取考试详情成功", examDetail);
         } catch (Exception e) {
+            // 如果在获取考卷详细信息的过程中出现异常，创建一个表示获取失败的ResultVO对象，状态码设置为 -1，表示获取考试详情失败，消息可根据业务实际情况设置为相应的提示语，数据部分设置为null，因为没有成功获取到有效的考卷详细信息。
             resultVO = new ResultVO<>(-1, "获取考试详情失败", null);
         }
         return resultVO;
     }
-
     /**
      * @Description: 使用examService.finishExam获取数据,并将其包装在ResultVO对象中,用于考试判分
      * @param examId 考试id
@@ -295,25 +294,24 @@ ResultVO<QuestionSelectionVo> getSelections() {
      */
     @PostMapping("/finish/{examId}")
     @ApiOperation("根据用户提交的答案对指定id的考试判分")
-    // 完成考试
     ResultVO<ExamRecord> finishExam(@PathVariable String examId, @RequestBody HashMap<String, List<String>> answersMap, HttpServletRequest request) {
-        // 定义返回结果。
+        // 定义一个用于存放结果的ResultVO<ExamRecord>类型的数据结构，后续根据评分操作的成功与否以及获取到的相关数据进行赋值，用于最终返回给客户端展示评分结果。
         ResultVO<ExamRecord> resultVO;
         try {
-            // 拦截器里设置上的用户id。
+            // 拦截器里设置上的用户id，从HttpServletRequest对象中获取用户ID属性值，该用户ID用于标识当前提交答案并进行评分的用户，是后续业务逻辑处理（如记录答题记录归属、判断是否有权限答题等）的重要依据。
             String userId = (String) request.getAttribute("user_id");
-            // 下面根据用户提交的信息进行判分,返回用户的得分情况。
+            // 下面根据用户提交的信息进行判分，返回用户的得分情况，调用ExamService的judge方法，传入获取到的用户ID、考试唯一标识符（examId）以及用户提交的答案集合（answersMap），由服务层实现具体的评分逻辑，比如对比答案、计算得分等操作，并返回一个ExamRecord对象，包含了评分后的成绩记录等详细信息。
             ExamRecord examRecord = examService.judge(userId, examId, answersMap);
-            // 返回结果。
-            resultVO = new ResultVO<>(0, "考卷提交成功", examRecord);
+            // 封装成绩记录到最终结果中，创建一个表示评分成功的ResultVO对象，状态码设置为0，表示考卷提交（评分）成功，消息设置为"考卷提交成功"，并将包含成绩记录的ExamRecord对象放入ResultVO对象中，以便返回给客户端展示评分结果。
+            resultVO = new ResultVO<>(0, "考卷提交成功", examRecord);// 封装成绩记录到最终结果中
         } catch (Exception e) {
+            // 如果在评分过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，查看是答案解析出错还是其他业务逻辑环节出现的错误导致评分失败。
             e.printStackTrace();
-            // 返回错误结果。
+            // 创建一个表示评分失败的ResultVO对象，状态码设置为 -1，表示考卷提交（评分）失败，消息可根据业务实际情况设置为相应的提示语，数据部分设置为null，因为没有成功获取到有效的评分成绩记录。
             resultVO = new ResultVO<>(-1, "考卷提交失败", null);
         }
         return resultVO;
     }
-
     /**
      * @Description: 使用examService.getExamRecordList获取数据,并将其包装在ResultVO对象中,用于获取当前用户的考试记录
      * @param request 获取用户id
@@ -321,22 +319,24 @@ ResultVO<QuestionSelectionVo> getSelections() {
      */
     @GetMapping("/record/list")
     @ApiOperation("获取当前用户的考试记录")
-    // 获取考试记录列表。
     ResultVO<List<ExamRecordVo>> getExamRecordList(HttpServletRequest request) {
+        // 定义一个用于存放结果的ResultVO<List<ExamRecordVo>>类型的数据结构，后续根据查询用户考试记录操作的成功与否以及获取到的相关数据进行赋值，用于最终返回给客户端展示查询结果。
         ResultVO<List<ExamRecordVo>> resultVO;
         try {
-            // 拦截器里设置上的用户id。
+            // 拦截器里设置上的用户id，从HttpServletRequest对象中获取用户ID属性值，该用户ID用于明确要查询其考试记录的目标用户，是服务层准确获取对应数据的关键依据。
             String userId = (String) request.getAttribute("user_id");
-            // 下面根据用户账号拿到他(她所有的考试信息)，注意要用VO封装下。
+            // 下面根据用户账号拿到他（她）所有的考试信息，注意要用VO封装下，调用ExamService的getExamRecordList方法，传入获取到的用户ID，由服务层实现从数据库或者其他数据源获取该用户所有历史考试记录数据的逻辑，并将其整理封装成List<ExamRecordVo>类型的列表返回，每个ExamRecordVo对象包含了如时间、得分等详细信息。
             List<ExamRecordVo> examRecordVoList = examService.getExamRecordList(userId);
-            resultVO = new ResultVO<>(0, "获取考试记录成功", examRecordVoList);
+            // 封装查询得到的信息到最终结果中，创建一个表示获取成功的ResultVO对象，状态码设置为0，表示获取考试记录成功，消息设置为"获取考试记录成功"，并将获取到的用户考试记录列表数据放入ResultVO对象中，以便返回给客户端展示历史考试记录情况。
+            resultVO = new ResultVO<>(0, "获取考试记录成功", examRecordVoList);//封装查询得到的信息到最终结果中；
         } catch (Exception e) {
+            // 如果在获取用户考试记录数据的过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，查看是数据源查询出错还是数据封装等环节出现的错误导致获取失败。
             e.printStackTrace();
+            // 创建一个表示获取失败的ResultVO对象，状态码设置为 -1，表示获取考试记录失败，消息可根据业务实际情况设置为相应的提示语，数据部分设置为null，因为没有成功获取到有效的用户考试记录数据。
             resultVO = new ResultVO<>(-1, "获取考试记录失败", null);
         }
-        return resultVO;
+        return resultVO;//返回封装好的 数据结构
     }
-
     /**
      * @Description: 使用examService.getExamRecordDetail获取数据,并将其包装在ResultVO对象中,用于获取指定id的考试记录详情
      * @param recordId 考试记录id
@@ -345,20 +345,24 @@ ResultVO<QuestionSelectionVo> getSelections() {
     @GetMapping("/record/detail/{recordId}")
     @ApiOperation("根据考试记录id获取考试记录详情")
     ResultVO<RecordDetailVo> getExamRecordDetail(@PathVariable String recordId) {
-        // 定义返回结果。
+        // 定义一个用于存放结果的ResultVO<RecordDetailVo>类型的数据结构，后续根据查询测验详细情况操作的成功与否以及获取到的相关数据进行赋值，用于最终返回给客户端展示查询结果。
         ResultVO<RecordDetailVo> resultVO;
         try {
-            // 调用examService获取考试记录详情。
+            // 调用ExamService的getRecordDetail方法，将接收到的测验记录唯一标识符（recordId）传递进去，由服务层实现从数据库或者其他数据源根据该ID查询对应测验详细信息的逻辑，返回一个RecordDetailVo对象代表该次测验的所有详细信息。
             RecordDetailVo recordDetailVo = examService.getRecordDetail(recordId);
-            // 返回成功结果。
-            resultVO = new ResultVO<>(0, "获取考试记录详情成功", recordDetailVo);
+            // 封装查询得到的信息到最终结果中，创建一个表示获取成功的ResultVO对象，状态码设置为0，表示获取考试记录详情成功，消息设置为"获取考试记录详情成功"，并将获取到的测验详细信息对象放入ResultVO对象中，以便返回给客户端展示该次测验的详细情况。
+            resultVO = new ResultVO<>(0, "获取考试记录详情成功", recordDetailVo);//封装查询得到的信息到最终结果中；
         } catch (Exception e) {
-            // 打印异常信息。
+            // 如果在获取测验详细信息的过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，查看是数据源查询出错还是数据解析等环节出现的错误导致获取失败。
             e.printStackTrace();
-            // 返回失败结果。
+            // 创建一个ResultVO对象，表示操作失败
+            // 状态码设置为-1，表示获取考试记录详情失败
+            // 消息设置为"获取考试记录详情失败"
+            // 由于查询失败，详细信息对象设置为null
             resultVO = new ResultVO<>(-1, "获取考试记录详情失败", null);
         }
-        // 返回结果。
+        // 返回封装好的ResultVO对象给客户端
+        // 客户端可以根据状态码和消息判断操作是否成功，并根据详细信息对象获取测验的详细记录信息
         return resultVO;
     }
 }

backend/src/main/java/lsgwr/exam/entity/Exam.java

@@ -4,51 +4,60 @@
  * @date        : 2019/5/14 07:42
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
-
+// 定义包名，用于组织类文件，避免命名冲突
 package lsgwr.exam.entity;
 
-
+// 导入Jackson库的JsonFormat注解，用于JSON序列化时自定义日期格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入Lombok库的Data注解，用于自动生成getter、setter、equals、hashCode和toString方法
 import lombok.Data;
+// 导入Hibernate的DynamicUpdate注解，用于在实体更新时只更新发生变化的字段
 import org.hibernate.annotations.DynamicUpdate;
-
+// 导入JPA的Entity注解，用于声明该类是一个JPA实体类
 import javax.persistence.Entity;
+// 导入JPA的Id注解，用于声明该类中的某个字段作为主键
 import javax.persistence.Id;
+// 导入Java的Date类，用于表示日期和时间
 import java.util.Date;
 
 @Entity
 @Data
 @DynamicUpdate
 public class Exam {
+    // 使用JPA的@Id注解声明该字段为主键
     @Id
-    private String examId;
-    private String examName;
-    private String examAvatar;
-    private String examDescription;
-    private String examQuestionIds;
-    private String examQuestionIdsRadio;
-    private String examQuestionIdsCheck;
-    private String examQuestionIdsJudge;
-    private Integer examScore;
-    private Integer examScoreRadio;
-    private Integer examScoreCheck;
-    private Integer examScoreJudge;
-    private String examCreatorId;
-    private Integer examTimeLimit;
+    private String examId;// 考试ID，唯一标识一场考试
+    private String examName;// 考试名称
+    private String examAvatar; // 考试头像或图标
+    private String examDescription;// 考试描述或简介
+    private String examQuestionIds;// 存储所有问题ID的字符串，可能是逗号分隔的ID列表
+    private String examQuestionIdsRadio;// 存储所有单选题ID的字符串
+    private String examQuestionIdsCheck;// 存储所有多选题ID的字符串
+    private String examQuestionIdsJudge;// 存储所有判断题ID的字符串
+    private Integer examScore;// 考试总分
+    private Integer examScoreRadio;// 单选题总分
+    private Integer examScoreCheck;// 多选题总分
+    private Integer examScoreJudge;// 判断题总分
+    private String examCreatorId;// 创建者ID，标识谁创建了这场考试
+    private Integer examTimeLimit;// 考试时间限制，单位可能是分钟
+    // 考试开始时间，使用Jackson的@JsonFormat注解自定义日期格式
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date examStartDate;
+    // 考试结束时间
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date examEndDate;
     /**
-     * 创建时间, 设计表时设置了自动插入当前时间，无需在Java代码中设置了
+     * 创建时间，设计数据库表时设置了自动插入当前时间，因此在Java代码中无需手动设置。
+     * 使用Jackson的@JsonFormat注解自定义日期格式以便于前端展示。
      */
 
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date createTime;
 
     /**
-     * 更新时间，设计表时设置了自动插入当前时间，无需在Java代码中设置了。
-     * 同时@DynamicUpdate注解可以时间当数据库数据变化时自动更新，无需人工维护
+     * 更新时间，设计数据库表时也设置了自动插入当前时间（或更新为当前时间），在Java代码中无需手动维护。
+     * 同时，由于使用了Hibernate的@DynamicUpdate注解，当数据库中的实体数据发生变化时，该字段会自动更新为当前时间。
+     * 使用Jackson的@JsonFormat注解自定义日期格式以便于前端展示。
      */
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date updateTime;

backend/src/main/java/lsgwr/exam/entity/ExamRecord.java

@@ -7,42 +7,44 @@
 package lsgwr.exam.entity;
 
 
-import com.fasterxml.jackson.annotation.JsonFormat;
-import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonFormat;// 引入Jackson库用于日期格式化的注解
+import lombok.Data;// 引入Lombok库用于简化Java实体类的编写，如自动生成getter和setter方法
 
-import javax.persistence.Entity;
+import javax.persistence.Entity;// 引入JPA注解，用于标识这是一个实体类，并映射到数据库中的一张表
+// 引入JPA注解，用于标识实体类的主键字段
 import javax.persistence.Id;
 import java.util.Date;
-
+// 使用@Data注解自动生成getter和setter方法，以及toString、equals和hashCode方法
 @Data
+// 使用@Entity注解标识这是一个JPA实体类
 @Entity
 public class ExamRecord {
     /**
-     * 主键
+     * 主键，用于唯一标识一条考试记录
      */
     @Id
     private String examRecordId;
     /**
-     * 参与的考试的id
+     * 关联的考试ID，用于标识考生参加的是哪一场考试
      */
     private String examId;
 
     /**
-     * 考生作答地每个题目的选项(题目和题目之间用_分隔，题目有多个选项地话用-分隔),用于查看考试详情
+     * 考生作答的每个题目的选项，题目之间用下划线_分隔，若题目有多个选项则用短横线-分隔。这个字段用于查看考试详情时展示考生作答情况。
      */
     private String answerOptionIds;
 
     /**
-     * 参与者，即user的id
+     * 参与考试的考生ID，即用户的ID
      */
     private String examJoinerId;
     /**
-     * 参加考试的日期
+     * 参加考试的日期和时间
      */
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date examJoinDate;
     /**
-     * 考试耗时(秒)
+     * 考试耗时，单位为秒
      */
     private Integer examTimeCost;
     /**
@@ -50,7 +52,7 @@ public class ExamRecord {
      */
     private Integer examJoinScore;
     /**
-     * 考试得分水平
+     * 考试得分水平，通常根据得分划分不同的等级，如优秀、良好、及格等（具体等级需另建表定义）
      */
     private Integer examResultLevel;
 }

backend/src/main/java/lsgwr/exam/entity/ExamRecordLevel.java

@@ -7,18 +7,22 @@
 package lsgwr.exam.entity;
 
 
-import lombok.Data;
-
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
+import lombok.Data;// 引入Lombok库中的@Data注解，用于自动生成getter、setter、toString、equals和hashCode方法
 
+import javax.persistence.Entity;// 引入JPA（Java Persistence API）中的@Entity注解，标识这是一个实体类，与数据库中的表相对应
+import javax.persistence.GeneratedValue;// 引入JPA中的@GeneratedValue注解，用于指定主键的生成策略，这里未明确指定策略，将使用默认策略
+import javax.persistence.Id;// 引入JPA中的@Id注解，标识实体类的主键字段
+// 使用@Data注解自动生成getter、setter等方法
 @Data
+// 使用@Entity注解标识这是一个JPA实体类
 @Entity
 public class ExamRecordLevel {
+    // 考试记录等级的ID，是主键，通过@Id注解标识，并通过@GeneratedValue注解指定主键生成策略
     @Id
     @GeneratedValue
     private Integer examRecordLevelId;
+    // 考试记录等级的名称，用于标识等级，如“优秀”、“良好”等
     private String examRecordLevelName;
+    // 考试记录等级的描述，用于对等级进行更详细的说明
     private String examRecordLevelDescription;
 }

backend/src/main/java/lsgwr/exam/exception/ExamException.java

@@ -11,13 +11,16 @@ import lombok.Getter;
 
 @Getter
 public class ExamException extends RuntimeException {
+    // 定义异常码
     private Integer code;
 
+    // 构造函数，传入枚举类型
     public ExamException(ResultEnum resultEnum) {
         super(resultEnum.getMessage());
         this.code = resultEnum.getCode();
     }
 
+    // 构造函数，传入异常码和异常信息
     public ExamException( Integer code, String message) {
         super(message);
         this.code = code;

backend/src/main/java/lsgwr/exam/repository/ExamRecordLevelRepository.java

@@ -9,5 +9,6 @@ package lsgwr.exam.repository;
 import lsgwr.exam.entity.ExamRecordLevel;
 import org.springframework.data.jpa.repository.JpaRepository;
 
+// ExamRecordLevelRepository接口，继承JpaRepository接口，用于操作ExamRecordLevel实体类
 public interface ExamRecordLevelRepository extends JpaRepository<ExamRecordLevel, Integer> {
 }

backend/src/main/java/lsgwr/exam/repository/ExamRecordRepository.java

@@ -1,9 +1,3 @@
-/***********************************************************
- * @Description : 
- * @author      : 梁山广(Laing Shan Guang)
- * @date        : 2019-05-14 08:23
- * @email       : liangshanguang2@gmail.com
- ***********************************************************/
 package lsgwr.exam.repository;
 
 import lsgwr.exam.entity.ExamRecord;

backend/src/main/java/lsgwr/exam/repository/ExamRepository.java

@@ -12,7 +12,9 @@ import org.springframework.data.jpa.repository.Query;
 
 import java.util.List;
 
+// ExamRepository接口，继承JpaRepository接口，用于操作Exam实体类
 public interface ExamRepository extends JpaRepository<Exam, String> {
+    // 使用JPQL查询语句，查询Exam实体类，按照updateTime降序排列
     @Query("select e from Exam e order by e.updateTime desc")
     List<Exam> findAll();
 }

backend/src/main/java/lsgwr/exam/service/ExamService.java

@@ -4,15 +4,15 @@
  * @date        : 2019-05-28 08:05
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
-package lsgwr.exam.service;
+package lsgwr.exam.service;// 定义了接口所属的包名
 
-import lsgwr.exam.entity.Exam;
-import lsgwr.exam.entity.ExamRecord;
-import lsgwr.exam.vo.*;
-
-import java.util.HashMap;
-import java.util.List;
+import lsgwr.exam.entity.Exam;// 导入了实体类Exam，可能包含考试的基本信息
+import lsgwr.exam.entity.ExamRecord;// 导入了实体类ExamRecord，可能包含考试记录的详细信息
+import lsgwr.exam.vo.*;// 导入了VO对象，VO是值对象，用于在不同层之间传递数据
 
+import java.util.HashMap;// 导入了HashMap，用于存储键值对
+import java.util.List;// 导入了List，用于存储一系列对象
+// 定义了一个名为ExamService的接口
 public interface ExamService {
     /**
      * 获取所有的问题列表

backend/src/main/java/lsgwr/exam/vo/ExamCardVo.java

@@ -1,3 +1,9 @@
+/***********************************************************
+ * @Description : 考试卡片列表
+ * @author      : 梁山广(Laing Shan Guang)
+ * @date        : 2019-06-23 19:30
+ * @email       : liangshanguang2@gmail.com
+ ***********************************************************/
 package lsgwr.exam.vo;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
@@ -10,9 +16,6 @@ import lombok.Data;
  */
 @Data
 public class ExamCardVo {
-    /**
-     * 考试ID
-     */
     @JsonProperty("id")
     private String examId;
     /**
@@ -34,10 +37,10 @@ public class ExamCardVo {
      * 考试分数
      */
     @JsonProperty("score")
-    private Integer examScore;
+    private Integer examScore;// 考试的分数
     /**
      * 考试限制的时间，单位为分钟
      */
     @JsonProperty("elapse")
-    private Integer examTimeLimit;
+    private Integer examTimeLimit;// 考试的时间限制，以分钟为单位
 }

backend/src/main/java/lsgwr/exam/vo/ExamCreateVo.java

@@ -5,60 +5,63 @@
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
 package lsgwr.exam.vo;
-
+// 引入Jackson库中的注解，用于JSON序列化和反序列化时自定义属性名
 import com.fasterxml.jackson.annotation.JsonProperty;
+// 引入Lombok库中的@Data注解，它会自动为你的类的字段生成getter和setter方法，以及toString、equals和hashCode方法
 import lombok.Data;
 
 import java.util.List;
-
+// 使用@Data注解来自动生成getter、setter等方法
 @Data
 public class ExamCreateVo {
-
+    // 考试名称，通过@JsonProperty注解指定JSON字段名为"name"
     @JsonProperty("name")
     private String examName;
-
+    // 考试头像或图标，通过@JsonProperty注解指定JSON字段名为"avatar"
     @JsonProperty("avatar")
     private String examAvatar;
-
+    // 考试描述，通过@JsonProperty注解指定JSON字段名为"desc"
     @JsonProperty("desc")
     private String examDescription;
 
     /**
-     * 考试时长，单位分钟
+     * 考试时长，单位分钟。通过@JsonProperty注解指定JSON字段名为"elapse"
+     * 注意：这里的注释说明了字段的用途和单位
      */
     @JsonProperty("elapse")
     private Integer examTimeLimit;
 
 
     /**
-     * 单选题
+     * 单选题列表。这里虽然使用了List<ExamQuestionSelectVo>类型，但注释仅指明了是单选题
+     * 注意：ExamQuestionSelectVo可能是一个表示题目信息的VO类，但在此代码段中未给出
      */
     private List<ExamQuestionSelectVo> radios;
 
     /**
-     * 多选题
+     * 多选题列表。同样使用了List<ExamQuestionSelectVo>类型，但注释指明了是多选题
      */
     private List<ExamQuestionSelectVo> checks;
 
     /**
-     * 判断题
+     * 判断题列表。使用了List<ExamQuestionSelectVo>类型，注释指明了是判断题
      */
     private List<ExamQuestionSelectVo> judges;
 
     /**
-     * 单选题的分数
+     * 单选题每题的分数。通过@JsonProperty注解指定JSON字段名为"radioScore"
      */
     @JsonProperty("radioScore")
     private Integer examScoreRadio;
 
     /**
-     * 多选题的分数
+     * 多选题每题的分数。通过@JsonProperty注解指定JSON字段名为"checkScore"
      */
     @JsonProperty("checkScore")
     private Integer examScoreCheck;
 
     /**
-     * 判断题每题的分数
+     * 判断题每题的分数。通过@JsonProperty注解指定JSON字段名为"judgeScore"
      */
     @JsonProperty("judgeScore")
     private Integer examScoreJudge;

backend/src/main/java/lsgwr/exam/vo/ExamDetailVo.java

@@ -5,29 +5,42 @@
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
 package lsgwr.exam.vo;
-
+// 引入Exam实体类，它可能包含了考试的详细信息，如考试ID、名称、描述等
 import lsgwr.exam.entity.Exam;
+// 引入Lombok库的@Data注解，用于自动生成getter、setter等方法
 import lombok.Data;
-
+// 使用@Data注解来自动生成这个类的getter、setter等方法
 @Data
 public class ExamDetailVo {
     /**
-     * 考试的基本信息对象
+     * 考试的基本信息对象。
+     * 这个字段存储了一个Exam类型的对象，该对象可能包含了考试的详细信息，
+     * 如考试ID、名称、描述、时长、状态等。
+     * 这里，ExamDetailVo通过持有这个Exam对象来提供关于特定考试的详细信息。
      */
     private Exam exam;
 
     /**
-     * 单选题的id数组
+     * 单选题的id数组。
+     * 这个字段是一个字符串数组，用于存储考生所选的单选题的ID。
+     * 每个字符串可能代表一个单选题的唯一标识符。
+     * 在处理考试结果或进行成绩统计时，这些ID可以用于查找和验证考生所选的答案。
      */
     private String[] radioIds;
 
     /**
-     * 多选题的id数组
+     * 多选题的id数组。
+     * 类似于单选题的id数组，这个字段存储了考生所选的多选题的ID。
+     * 由于多选题可能允许选择多个选项，因此这个数组可能包含多个字符串，
+     * 每个字符串代表一个被选中的多选题的唯一标识符。
      */
     private String[] checkIds;
 
     /**
-     * 判断题的id数组
+     * 判断题的id数组。
+     * 这个字段也是一个字符串数组，用于存储考生所选的判断题的ID。
+     * 每个字符串代表一个判断题的唯一标识符，通常与考生所选的答案（正确或错误）相关联。
+     * 在处理考试结果时，这些ID可以用于查找和验证考生对判断题的回答。
      */
     private String[] judgeIds;
 

backend/src/main/java/lsgwr/exam/vo/ExamPageVo.java

@@ -4,37 +4,40 @@
  * @date        : 2019-06-22 17:00
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
-package lsgwr.exam.vo;
-
+package lsgwr.exam.vo;// 定义包名，用于组织类文件，避免命名冲突
+// 导入Jackson库的JsonProperty注解，用于JSON序列化时自定义字段名
 import com.fasterxml.jackson.annotation.JsonProperty;
+// 导入Lombok库的Data注解，用于自动生成getter、setter、equals、hashCode和toString方法
 import lombok.Data;
-
+// 导入Java的List接口，用于存储ExamVo对象的集合
 import java.util.List;
-
+// 使用Lombok的@Data注解，自动为该类生成getter、setter等方法
 @Data
 public class ExamPageVo {
     /**
-     * 分页时每个分页的大小
+     * 分页时每个分页的大小，即每页显示多少条记录
      */
     private Integer pageSize;
 
     /**
-     * 当前是在第几页，注意要比前端传过来地小1
+     * 当前是在第几页，注意这里的页码是从1开始计数的，但后端处理时可能需要减1以符合某些分页算法或框架的页码从0开始的要求
+     * 这里的注释提醒开发者，后端接收到的页码值可能需要减1处理
      */
     private Integer pageNo;
 
     /**
-     * 一共有多少条符合条件的记录
+     * 一共有多少条符合条件的记录，用于计算总页数
      */
     private Long totalCount;
 
     /**
-     * 一共有多少页
+     * 一共有多少页，根据总记录数和每页大小计算得出
      */
     private Integer totalPage;
 
     /**
-     * 当前页的详细数据
+     * 当前页的详细数据，包含了一个ExamVo对象的列表，ExamVo类通常定义了考试信息的数据结构
+     * @JsonProperty("data")注解用于JSON序列化时，将examVoList字段的JSON键名指定为"data"
      */
     @JsonProperty("data")
     private List<ExamVo> examVoList;

backend/src/main/java/lsgwr/exam/vo/ExamQuestionSelectVo.java

@@ -4,22 +4,32 @@
  * @date        : 2019-06-17 23:10
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
-package lsgwr.exam.vo;
-
+package lsgwr.exam.vo;// 定义包名，用于组织类文件，避免命名冲突
+// 导入Jackson库的JsonProperty注解，用于JSON序列化时自定义字段名
 import com.fasterxml.jackson.annotation.JsonProperty;
+// 导入Lombok库的Data注解，用于自动生成getter、setter、equals、hashCode和toString方法
 import lombok.Data;
-
+// 使用Lombok的@Data注解，自动为该类生成getter、setter等方法
 @Data
 public class ExamQuestionSelectVo {
+    /**
+     * 问题的唯一标识符，在JSON序列化时，该字段的名称被指定为"id"
+     * 这通常用于前端向后端发送请求时，标识特定的选择题
+     */
     @JsonProperty("id")
     private String questionId;
-
+    /**
+     * 问题的名称，在JSON序列化时，该字段的名称被指定为"name"
+     * 这通常用于在前端显示问题的名称
+     */
     @JsonProperty("name")
     private String questionName;
 
     /**
-     * 这个问题是否被选为了考试中的题目.默认是false，经过前端修改后可能会变成true，
-     * 传回来用于创建问题
+     * 这个问题是否被选为了考试中的题目。默认值是false，表示未被选中。
+     * 当前端用户进行选择后，该值可能会变为true，并随请求发送回后端，
+     * 用于在创建或更新考试时，确定哪些问题被包含在内。
+     * 在JSON序列化时，该字段的名称被指定为"checked"。
      */
     @JsonProperty("checked")
     private Boolean checked = false;

backend/src/main/java/lsgwr/exam/vo/ExamQuestionTypeVo.java

@@ -4,21 +4,35 @@
  * @date        : 2019-06-23 11:00
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
-package lsgwr.exam.vo;
-
+package lsgwr.exam.vo;// 定义包名，用于组织类文件，避免命名冲突
+// 导入Jackson库的JsonProperty注解，用于JSON序列化时自定义字段名
 import com.fasterxml.jackson.annotation.JsonProperty;
+// 导入Lombok库的Data注解，用于自动生成getter、setter、equals、hashCode和toString方法
 import lombok.Data;
-
+// 导入Java的List接口，用于存储对象的集合
 import java.util.List;
-
+// 使用Lombok的@Data注解，自动为该类生成getter、setter等方法
 @Data
 public class ExamQuestionTypeVo {
+    /**
+     * 单选题列表，包含多个ExamQuestionSelectVo对象，每个对象代表一个单选题。
+     * 在JSON序列化时，该字段的名称被指定为"radios"。
+     * 注意：这里的"radios"命名可能表示单选按钮（radio buttons）的集合。
+     */
     @JsonProperty("radios")
     private List<ExamQuestionSelectVo> examQuestionSelectVoRadioList;
-
+    /**
+     * 多选题列表，包含多个ExamQuestionSelectVo对象，每个对象代表一个多选题。
+     * 在JSON序列化时，该字段的名称被指定为"checks"。
+     * 注意：这里的"checks"命名可能表示复选框（checkboxes）的集合。
+     */
     @JsonProperty("checks")
     private List<ExamQuestionSelectVo> examQuestionSelectVoCheckList;
-
+    /**
+     * 判断题列表，包含多个ExamQuestionSelectVo对象，每个对象代表一个判断题。
+     * 在JSON序列化时，该字段的名称被指定为"judges"。
+     * 注意：这里的"judges"命名可能表示判断题（true/false或yes/no）的集合。
+     */
     @JsonProperty("judges")
     private List<ExamQuestionSelectVo> examQuestionSelectVoJudgeList;
 }

backend/src/main/java/lsgwr/exam/vo/ExamRecordVo.java

@@ -4,27 +4,34 @@
  * @date        : 2019/10/25 7:42
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
-package lsgwr.exam.vo;
-
-import lsgwr.exam.entity.Exam;
-import lsgwr.exam.entity.ExamRecord;
-import lsgwr.exam.entity.User;
+package lsgwr.exam.vo;// 定义包名，用于组织类文件，避免命名冲突
+// 导入相关的实体类
+import lsgwr.exam.entity.Exam;// 考试实体类
+import lsgwr.exam.entity.ExamRecord; // 考试记录实体类
+import lsgwr.exam.entity.User;// 用户实体类
+// 导入Lombok库的Data注解，用于自动生成getter、setter、equals、hashCode和toString方法
 import lombok.Data;
-
+// 使用Lombok的@Data注解自动生成getter、setter等方法
 @Data
 public class ExamRecordVo {
     /**
-     * 当前考试记录对应的考试
+     * 当前考试记录对应的考试。
+     * 这个字段包含了考试的详细信息，如考试名称、描述、时间等。
+     * 它是一个Exam类型的对象，与数据库中的Exam表相对应。
      */
     private Exam exam;
 
     /**
-     * 当前考试对应的内容
+     * 当前考试对应的内容（或记录）。
+     * 这个字段包含了考试记录的具体信息，如用户的答题情况、得分等。
+     * 它是一个ExamRecord类型的对象，与数据库中的ExamRecord表相对应。
      */
     private ExamRecord examRecord;
 
     /**
-     * 参加考试的用户信息
+     * 参加考试的用户信息。
+     * 这个字段包含了用户的详细信息，如用户名、邮箱、头像等。
+     * 它是一个User类型的对象，与数据库中的User表相对应。
      */
     private User user;
 }

backend/src/main/java/lsgwr/exam/vo/ExamVo.java

@@ -4,86 +4,83 @@
  * @date        : 2019/5/14 07:42
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
-
+// 定义包名，用于组织类文件并避免命名冲突
 package lsgwr.exam.vo;
 
+// 导入所需的库和注解
+import com.fasterxml.jackson.annotation.JsonFormat;// 用于日期格式的序列化和反序列化
+import com.fasterxml.jackson.annotation.JsonProperty;// 用于自定义JSON字段名
+import lombok.Data;// 用于自动生成getter、setter等方法
 
-import com.fasterxml.jackson.annotation.JsonFormat;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Data;
-
-import java.util.Date;
-import java.util.List;
-
+import java.util.Date;// Java日期类
+import java.util.List;// Java列表接口
+// 使用Lombok的@Data注解自动生成getter、setter等方法
 @Data
 public class ExamVo {
+    // 使用@JsonProperty注解自定义JSON字段名为"id"
     @JsonProperty("id")
-    private String examId;
+    private String examId;// 考试的唯一标识符
+    // 使用@JsonProperty注解自定义JSON字段名为"name"
     @JsonProperty("name")
-    private String examName;
+    private String examName;// 考试名称
+    // 使用@JsonProperty注解自定义JSON字段名为"avatar"
     @JsonProperty("avatar")
-    private String examAvatar;
+    private String examAvatar;// 考试图标或头像
+    // 使用@JsonProperty注解自定义JSON字段名为"desc"
     @JsonProperty("desc")
-    private String examDescription;
-
+    private String examDescription;// 考试描述
+    // 单选题列表，JSON字段名为"radios"
     @JsonProperty("radios")
-    private List<ExamQuestionSelectVo> examQuestionSelectVoRadioList;
-
+    private List<ExamQuestionSelectVo> examQuestionSelectVoRadioList;// 单选题选项列表
+    // 多选题列表，JSON字段名为"checks"
     @JsonProperty("checks")
-    private List<ExamQuestionSelectVo> examQuestionSelectVoCheckList;
-
+    private List<ExamQuestionSelectVo> examQuestionSelectVoCheckList;// 多选题选项列表
+    // 判断题列表，JSON字段名为"judges"
     @JsonProperty("judges")
-    private List<ExamQuestionSelectVo> examQuestionSelectVoJudgeList;
-
+    private List<ExamQuestionSelectVo> examQuestionSelectVoJudgeList;// 判断题选项列表
+    // 考试总分，JSON字段名为"score"
     @JsonProperty("score")
-    private Integer examScore;
-
+    private Integer examScore;// 考试的总分数
+    // 单选题总分，JSON字段名为"radioScore"
     @JsonProperty("radioScore")
-    private Integer examScoreRadio;
-
+    private Integer examScoreRadio;// 单选题的总分数
+    // 多选题总分，JSON字段名为"checkScore"
     @JsonProperty("checkScore")
-    private Integer examScoreCheck;
-
+    private Integer examScoreCheck;// 多选题的总分数
+    // 判断题总分，JSON字段名为"judgeScore"
     @JsonProperty("judgeScore")
-    private Integer examScoreJudge;
+    private Integer examScoreJudge;// 判断题的总分数
 
-    /**
-     * 考试的创建人，根据id从用户表中查取姓名
-     */
+    // 考试创建人的名称，JSON字段名为"creator"
+    // 注意：这里假设只存储了创建人的名称，实际可能需要根据ID查询数据库获取
     @JsonProperty("creator")
-    private String examCreator;
+    private String examCreator;// 考试的创建者名称
 
-    /**
-     * 考试限制的时间，单位为分钟
-     */
+    // 考试的时间限制（分钟），JSON字段名为"elapse"
     @JsonProperty("elapse")
-    private Integer examTimeLimit;
+    private Integer examTimeLimit;// 考试的时间限制，单位为分钟
 
-    /**
-     * 开始时间
-     */
+    // 考试开始时间，JSON字段名为"startDate"
+    // 使用@JsonFormat注解指定日期格式和时区
     @JsonProperty("startDate")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
-    private Date examStartDate;
+    private Date examStartDate;// 考试的开始时间
 
-    /**
-     * 结束时间
-     */
+    // 考试结束时间，JSON字段名为"endDate"
+    // 使用@JsonFormat注解指定日期格式和时区
     @JsonProperty("endDate")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
-    private Date examEndDate;
+    private Date examEndDate;// 考试的结束时间
 
-    /**
-     * 创建时间
-     */
+    // 创建时间，JSON字段名为"createTime"
+    // 使用@JsonFormat注解指定日期格式和时区
     @JsonProperty("createTime")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
-    private Date createTime;
+    private Date createTime;// 记录的创建时间
 
-    /**
-     * 更新时间
-     */
+    // 更新时间，JSON字段名为"updateTime"
+    // 使用@JsonFormat注解指定日期格式和时区
     @JsonProperty("updateTime")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
-    private Date updateTime;
+    private Date updateTime;// 记录的更新时间
 }