From 059a70f2c9609533a671b89789bd346276303ed1 Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Mon, 16 Dec 2024 21:48:29 +0800
Subject: [PATCH 01/10] main

---
 .../org/alan/exam/common/result/DecryptRequestBodyAdvice.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/cn/org/alan/exam/common/result/DecryptRequestBodyAdvice.java b/src/main/java/cn/org/alan/exam/common/result/DecryptRequestBodyAdvice.java
index 2e39e5f..61ecec9 100644
--- a/src/main/java/cn/org/alan/exam/common/result/DecryptRequestBodyAdvice.java
+++ b/src/main/java/cn/org/alan/exam/common/result/DecryptRequestBodyAdvice.java
@@ -15,7 +15,7 @@ import java.lang.reflect.Type;
 /**
  * @Author Alan
  * @Version
- * @Date 2024/6/8 11:47 AM
+ * @Date 2024/6/8 11:47 AM111
  */
 
 @ControllerAdvice
-- 
2.34.1


From 844711fec9b5b2e509ca6e9dbc14d667fb033460 Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Mon, 16 Dec 2024 21:50:58 +0800
Subject: [PATCH 02/10] main11

---
 .../org/alan/exam/common/result/DecryptRequestBodyAdvice.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/cn/org/alan/exam/common/result/DecryptRequestBodyAdvice.java b/src/main/java/cn/org/alan/exam/common/result/DecryptRequestBodyAdvice.java
index 61ecec9..6264249 100644
--- a/src/main/java/cn/org/alan/exam/common/result/DecryptRequestBodyAdvice.java
+++ b/src/main/java/cn/org/alan/exam/common/result/DecryptRequestBodyAdvice.java
@@ -14,7 +14,7 @@ import java.lang.reflect.Type;
 
 /**
  * @Author Alan
- * @Version
+ * @Version222
  * @Date 2024/6/8 11:47 AM111
  */
 
-- 
2.34.1


From ffcd518bfdee93709c30314eaf4148bf5bd2f86e Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Mon, 16 Dec 2024 21:58:50 +0800
Subject: [PATCH 03/10] main112

---
 .../java/cn/org/alan/exam/common/exception/AppException.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/cn/org/alan/exam/common/exception/AppException.java b/src/main/java/cn/org/alan/exam/common/exception/AppException.java
index 99abeb3..ea699a9 100644
--- a/src/main/java/cn/org/alan/exam/common/exception/AppException.java
+++ b/src/main/java/cn/org/alan/exam/common/exception/AppException.java
@@ -2,7 +2,7 @@ package cn.org.alan.exam.common.exception;
 
 /**
  * @Author WeiJin
- * @Version 1.0
+ * @Version 1.02222
  * @Date 2024/3/29 21:06
  */
 public class AppException extends RuntimeException{
-- 
2.34.1


From 593c5e0a378e6073f364643508d2572cea88e48f Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Mon, 16 Dec 2024 22:10:16 +0800
Subject: [PATCH 04/10] main1122

---
 .../java/cn/org/alan/exam/common/exception/AppException.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/cn/org/alan/exam/common/exception/AppException.java b/src/main/java/cn/org/alan/exam/common/exception/AppException.java
index ea699a9..c457b96 100644
--- a/src/main/java/cn/org/alan/exam/common/exception/AppException.java
+++ b/src/main/java/cn/org/alan/exam/common/exception/AppException.java
@@ -2,7 +2,7 @@ package cn.org.alan.exam.common.exception;
 
 /**
  * @Author WeiJin
- * @Version 1.02222
+ * @Version 1.022222
  * @Date 2024/3/29 21:06
  */
 public class AppException extends RuntimeException{
-- 
2.34.1


From a8361f16b1cd0c33149f6e581fe8273d7be8521a Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Wed, 18 Dec 2024 16:21:24 +0800
Subject: [PATCH 05/10] main1122

---
 .../alan/exam/mapper/CertificateMapper.java   |  19 +++-
 .../exam/mapper/CertificateUserMapper.java    |  27 ++---
 .../org/alan/exam/mapper/ExamGradeMapper.java |  75 ++++++++-----
 .../cn/org/alan/exam/mapper/ExamMapper.java   |  64 +++++++----
 .../alan/exam/mapper/ExamQuAnswerMapper.java  |  49 ++++----
 .../alan/exam/mapper/ExamQuestionMapper.java  |  29 +++--
 .../org/alan/exam/mapper/ExamRepoMapper.java  |  21 +++-
 .../exam/mapper/ExerciseRecordMapper.java     |  25 +++--
 .../alan/exam/mapper/GradeExerciseMapper.java |  25 +++--
 .../cn/org/alan/exam/mapper/GradeMapper.java  |  28 +++--
 .../alan/exam/mapper/ManualScoreMapper.java   |  34 +++---
 .../alan/exam/mapper/NoticeGradeMapper.java   |  35 ++++--
 .../cn/org/alan/exam/mapper/NoticeMapper.java |  91 +++++++++++----
 .../cn/org/alan/exam/mapper/OptionMapper.java |  67 ++++++-----
 .../org/alan/exam/mapper/QuestionMapper.java  | 106 ++++++++++++------
 .../cn/org/alan/exam/mapper/RepoMapper.java   |  53 +++++----
 .../cn/org/alan/exam/mapper/RoleMapper.java   |  26 +++--
 .../cn/org/alan/exam/mapper/StatMapper.java   |  45 ++++----
 .../org/alan/exam/mapper/UserBookMapper.java  |  51 ++++++---
 .../mapper/UserDailyLoginDurationMapper.java  |  31 +++--
 .../exam/mapper/UserExamsScoreMapper.java     |  85 ++++++++------
 .../exam/mapper/UserExerciseRecordMapper.java |  18 ++-
 .../cn/org/alan/exam/mapper/UserMapper.java   |  64 +++++++----
 23 files changed, 678 insertions(+), 390 deletions(-)

diff --git a/src/main/java/cn/org/alan/exam/mapper/CertificateMapper.java b/src/main/java/cn/org/alan/exam/mapper/CertificateMapper.java
index f6aab4b..d5174e3 100644
--- a/src/main/java/cn/org/alan/exam/mapper/CertificateMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/CertificateMapper.java
@@ -1,16 +1,25 @@
 package cn.org.alan.exam.mapper;
+// 指定当前类所在的包路径
 
 import cn.org.alan.exam.model.entity.Certificate;
+// 导入Certificate实体类，代表证书的数据模型
 import cn.org.alan.exam.model.form.CertificateForm;
+// 导入CertificateForm表单类，用于接收前端传递的表单数据
 import cn.org.alan.exam.model.vo.certificate.MyCertificateVO;
+// 导入MyCertificateVO视图对象类，用于封装返回给前端的数据
 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类，是IPage接口的一个实现，用于分页查询
 import org.apache.ibatis.annotations.Param;
+// 导入Param注解，用于MyBatis方法参数注解，便于XML配置文件中引用
 import org.springframework.stereotype.Repository;
+// 导入Repository注解，用于标识当前类是一个持久层（DAO层）的组件
 
 import java.util.List;
-
+// 导入List接口，用于处理集合数据
 
 /**
  * <p>
@@ -21,13 +30,19 @@ import java.util.List;
  * @since 2024-03-21
  */
 @Repository
+// 使用Repository注解，将当前接口标识为Spring管理的组件
 public interface CertificateMapper extends BaseMapper<Certificate> {
+    // 声明CertificateMapper接口继承自BaseMapper<Certificate>，提供基本的证书数据操作
 
+    // 自定义查询方法，根据分页信息、用户ID、考试名称查询用户的证书信息，并返回Page<MyCertificateVO>对象
     Page<MyCertificateVO> selectMyCertificate(Page<MyCertificateVO> myCertificateVOPage, Integer pageNum, Integer pageSize, Integer userId,String examName);
 
+    // 自定义统计方法，根据用户ID、证书名称、认证单位统计符合条件的证书数量
     int countByCondition(Integer userId, String certificateName, String certificationUnit);
 
+    // 自定义分页查询方法，根据用户ID、证书名称、认证单位、偏移量、页面大小查询证书ID列表
     List<Integer> selectCertificateIdsPage(Integer userId, String certificateName, String certificationUnit, Integer offset,Integer pageSize);
 
+    // 自定义批量查询方法，根据证书ID列表批量查询证书信息
     List<Certificate> batchSelectByIds(List<Integer> missIds);
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/CertificateUserMapper.java b/src/main/java/cn/org/alan/exam/mapper/CertificateUserMapper.java
index 46e9541..f6e151d 100644
--- a/src/main/java/cn/org/alan/exam/mapper/CertificateUserMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/CertificateUserMapper.java
@@ -1,24 +1,25 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前接口所在的包路径
 
-import cn.org.alan.exam.model.entity.CertificateUser;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import cn.org.alan.exam.model.entity.CertificateUser; // 导入CertificateUser实体类，代表用户证书关联的数据模型
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口，提供基本的CRUD操作
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理集合数据
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口，用于操作CertificateUser数据表
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口自哪个版本开始可用
  */
-public interface CertificateUserMapper extends BaseMapper<CertificateUser> {
+public interface CertificateUserMapper extends BaseMapper<CertificateUser> { // 声明CertificateUserMapper接口继承自BaseMapper<CertificateUser>，提供基本的CertificateUser数据操作
 
     /**
      * 根据用户id列表批量删除用户的证书
-     * @param userIds 用户id列表
-     * @return 影响数据库记录数
-     */
-    Integer deleteByUserIds(List<Integer> userIds);
-}
+     *
+     * @param userIds 用户id列表，是要删除证书的用户ID集合
+     * @return 影响数据库记录数，表示成功删除的记录条数
+     */ // 方法注释，描述方法的功能、参数和返回值
+    Integer deleteByUserIds(List<Integer> userIds); // 自定义删除方法，根据用户ID列表批量删除证书用户关联记录
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/ExamGradeMapper.java b/src/main/java/cn/org/alan/exam/mapper/ExamGradeMapper.java
index 766215b..a1bd594 100644
--- a/src/main/java/cn/org/alan/exam/mapper/ExamGradeMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/ExamGradeMapper.java
@@ -1,50 +1,71 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前接口所在的包路径
 
-import cn.org.alan.exam.model.entity.Exam;
-import cn.org.alan.exam.model.entity.ExamGrade;
-import cn.org.alan.exam.model.vo.exam.ExamGradeListVO;
-import cn.org.alan.exam.model.vo.score.GradeScoreVO;
-import cn.org.alan.exam.model.vo.stat.GradeExamVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import org.apache.ibatis.annotations.Param;
+import cn.org.alan.exam.model.entity.Exam; // 导入Exam实体类（本接口未直接使用，可能是遗留或用于其他目的）
+import cn.org.alan.exam.model.entity.ExamGrade; // 导入ExamGrade实体类，代表考试与班级的关联数据模型
+import cn.org.alan.exam.model.vo.exam.ExamGradeListVO; // 导入ExamGradeListVO视图对象类，用于封装考试班级列表的数据
+import cn.org.alan.exam.model.vo.score.GradeScoreVO; // 导入GradeScoreVO视图对象类，用于封装班级分数的数据
+import cn.org.alan.exam.model.vo.stat.GradeExamVO; // 导入GradeExamVO视图对象类（本接口未直接使用，可能是遗留或用于其他目的）
+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类（本接口未直接使用，IPage的实现类，但通常不直接引用）
+import org.apache.ibatis.annotations.Param; // 导入Param注解，用于MyBatis方法参数注解
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理集合数据
 
 /**
  * <p>
- *  Mapper 接口
+ * Mapper 接口，用于操作ExamGrade数据表
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口自哪个版本开始可用
  */
-public interface ExamGradeMapper extends BaseMapper<ExamGrade> {
+public interface ExamGradeMapper extends BaseMapper<ExamGrade> { // 声明ExamGradeMapper接口继承自BaseMapper<ExamGrade>，提供基本的ExamGrade数据操作
 
+    // 自定义方法，为指定考试ID添加多个班级ID的关联记录
     Integer addExamGrade(Integer id, List<Integer> gradeIds);
 
+    // 自定义方法，根据考试ID删除考试与班级的关联记录
     Integer delExamGrade(Integer id);
 
     /**
      * 分页获取考试班级用户信息
-     * @param page
-     * @param roleId
-     * @return
+     *
+     * @param page 分页对象，包含分页信息和结果集
+     * @param examTitle 考试标题，用于筛选符合条件的考试
+     * @param userId 用户ID，用于筛选用户相关的考试班级信息（可能用于权限控制或数据筛选）
+     * @param gradeId 班级ID，用于筛选特定班级的考试信息
+     * @param roleId 角色ID，用于筛选特定角色的用户考试信息（可能用于权限控制或数据筛选）
+     * @return 分页对象，包含筛选后的考试班级用户信息
      */
-    IPage<GradeScoreVO> getExamGrade(IPage<GradeScoreVO> page,String examTitle,Integer userId,Integer gradeId,Integer roleId);
-
+    IPage<GradeScoreVO> getExamGrade(IPage<GradeScoreVO> page, String examTitle, Integer userId, Integer gradeId, Integer roleId);
 
     /**
-     * 根据开始id获取所有需要参加该考试的人数
-     * @param id 考试id
-     * @return 人数
+     * 根据考试ID获取所有需要参加该考试的人数
+     *
+     * @param id 考试ID
+     * @return 参加该考试的人数
      */
     Integer selectClassSize(Integer id);
 
+    /**
+     * 分页查询用户参与的考试班级信息
+     *
+     * @param examPage 分页对象，包含分页信息和结果集
+     * @param userId 用户ID，用于筛选用户参与的考试班级信息
+     * @param title 考试标题，用于筛选符合条件的考试班级信息
+     * @return 分页对象，包含筛选后的用户参与的考试班级信息
+     */
+    IPage<ExamGradeListVO> selectClassExam(IPage<ExamGradeListVO> examPage, Integer userId, String title);
 
-    IPage<ExamGradeListVO> selectClassExam(IPage<ExamGradeListVO> examPage, Integer userId,String title);
-
-    IPage<ExamGradeListVO> selectAdminClassExam(IPage<ExamGradeListVO> examPage, Integer userId,String title);
+    /**
+     * 分页查询管理员视角下的考试班级信息
+     *
+     * @param examPage 分页对象，包含分页信息和结果集
+     * @param userId 管理员ID，用于标识查询的管理员（可能用于权限控制或数据筛选）
+     * @param title 考试标题，用于筛选符合条件的考试班级信息
+     * @return 分页对象，包含筛选后的管理员视角下的考试班级信息
+     */
+    IPage<ExamGradeListVO> selectAdminClassExam(IPage<ExamGradeListVO> examPage, Integer userId, String title);
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/ExamMapper.java b/src/main/java/cn/org/alan/exam/mapper/ExamMapper.java
index 4959f4b..59155f7 100644
--- a/src/main/java/cn/org/alan/exam/mapper/ExamMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/ExamMapper.java
@@ -1,49 +1,65 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前接口所在的包路径
 
-import cn.org.alan.exam.model.entity.Exam;
-import cn.org.alan.exam.model.vo.answer.AnswerExamVO;
-import cn.org.alan.exam.model.vo.record.ExamRecordVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import org.apache.ibatis.annotations.Param;
-import org.springframework.stereotype.Repository;
+import cn.org.alan.exam.model.entity.Exam; // 导入Exam实体类，代表考试数据模型
+import cn.org.alan.exam.model.vo.answer.AnswerExamVO; // 导入AnswerExamVO视图对象类，用于封装考试答题相关的数据
+import cn.org.alan.exam.model.vo.record.ExamRecordVO; // 导入ExamRecordVO视图对象类，用于封装考试记录相关的数据
+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类，是IPage接口的一个实现，用于分页查询的具体实现
+import org.apache.ibatis.annotations.Param; // 导入Param注解，用于MyBatis方法参数注解
+import org.springframework.stereotype.Repository; // 导入Repository注解（本接口未直接使用，通常用于标注数据访问层组件）
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理集合数据
 
 /**
- * Mapper 接口
+ * Mapper 接口，用于操作Exam数据表
  *
- * @author Alan
- * @since 2024-03-21
+ * @author Alan // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口自哪个版本开始可用
  */
+@Repository // 注解通常用于标注数据访问层组件，但Mapper接口一般通过MyBatis框架扫描，不需要显式添加
+public interface ExamMapper extends BaseMapper<Exam> { // 声明ExamMapper接口继承自BaseMapper<Exam>，提供基本的Exam数据操作
 
-public interface ExamMapper extends BaseMapper<Exam> {
-
+    // 自定义方法，根据考试ID列表删除多个考试记录
     int deleteExams(List<Integer> examIds);
 
+    // 自定义方法，根据考试ID列表删除多个考试与班级的关联记录（可能是业务逻辑上的关联，不一定直接对应数据库表）
     int deleteExamGrades(List<Integer> examIds);
 
+    // 自定义方法，根据考试ID列表删除多个考试资源（如试题、答案等）
     int deleteExamRepos(List<Integer> examIds);
 
+    // 自定义方法，根据考试ID列表删除多个考试与试题的关联记录
     int deleteExamQuestions(List<Integer> examIds);
 
     /**
      * 删除用户创建的考试
      *
-     * @param userIds 用户id列表
-     * @return 影响数据库记录数
+     * @param userIds 用户ID列表，用于标识需要删除考试的用户
+     * @return 影响数据库记录数，表示成功删除的考试数量
      */
     Integer deleteByUserIds(List<Integer> userIds);
 
-
     /**
-     * 获取自己创建的考试，考试id，考试考试标题，是否需要阅卷
+     * 分页查询用户创建的考试列表，包含考试ID、考试标题以及是否需要阅卷的信息
      *
-     * @param userId
-     * @return
+     * @param page 分页对象，包含分页信息和结果集类型
+     * @param userId 用户ID，用于筛选该用户创建的考试
+     * @param role 用户角色，可能用于权限控制或数据筛选
+     * @param examName 考试名称，用于模糊查询考试标题
+     * @return 分页对象，包含筛选后的考试列表信息
      */
-    IPage<AnswerExamVO> selectMarkedList(@Param("page") IPage<AnswerExamVO> page, @Param("userId") Integer userId,String role,String examName);
+    IPage<AnswerExamVO> selectMarkedList(@Param("page") IPage<AnswerExamVO> page, @Param("userId") Integer userId, String role, String examName);
 
-    Page<ExamRecordVO> getExamRecordPage(Page<ExamRecordVO> examPage, Integer userId,String examName);
-}
+    /**
+     * 分页查询用户的考试记录
+     *
+     * @param examPage 分页对象，包含分页信息和结果集类型（这里使用Page<ExamRecordVO>作为具体实现）
+     * @param userId 用户ID，用于筛选该用户的考试记录
+     * @param examName 考试名称，用于模糊查询考试记录中的考试标题
+     * @return 分页对象，包含筛选后的考试记录信息
+     */
+    Page<ExamRecordVO> getExamRecordPage(Page<ExamRecordVO> examPage, Integer userId, String examName);
+    // 注意：在实际使用中，通常建议统一使用IPage接口作为分页对象的类型，以避免具体实现类的依赖。
+    // 如果MyBatis-Plus的版本或配置允许，可以考虑将getExamRecordPage方法的参数和返回值类型改为IPage<ExamRecordVO>。
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/ExamQuAnswerMapper.java b/src/main/java/cn/org/alan/exam/mapper/ExamQuAnswerMapper.java
index 5bcee1b..9997691 100644
--- a/src/main/java/cn/org/alan/exam/mapper/ExamQuAnswerMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/ExamQuAnswerMapper.java
@@ -1,45 +1,46 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前接口所在的包路径
 
-import cn.org.alan.exam.model.entity.ExamQuAnswer;
-import cn.org.alan.exam.model.vo.answer.UserAnswerDetailVO;
-import cn.org.alan.exam.model.vo.exam.ExamQuAnswerExtVO;
-import cn.org.alan.exam.model.vo.score.QuestionAnalyseVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import cn.org.alan.exam.model.entity.ExamQuAnswer; // 导入ExamQuAnswer实体类，代表考试问题回答的数据模型
+import cn.org.alan.exam.model.vo.answer.UserAnswerDetailVO; // 导入UserAnswerDetailVO视图对象类，用于封装用户回答主观题的信息
+import cn.org.alan.exam.model.vo.exam.ExamQuAnswerExtVO; // 导入ExamQuAnswerExtVO视图对象类，用于扩展封装考试问题回答的信息
+import cn.org.alan.exam.model.vo.score.QuestionAnalyseVO; // 导入QuestionAnalyseVO视图对象类，用于封装试题分析的信息
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口，提供基本的CRUD操作
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理集合数据
 
 /**
  * <p>
- *  Mapper 接口
+ * Mapper 接口，用于操作ExamQuAnswer数据表
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口自哪个版本开始可用
  */
-public interface ExamQuAnswerMapper extends BaseMapper<ExamQuAnswer> {
+public interface ExamQuAnswerMapper extends BaseMapper<ExamQuAnswer> { // 声明ExamQuAnswerMapper接口继承自BaseMapper<ExamQuAnswer>，提供基本的ExamQuAnswer数据操作
 
-    List<ExamQuAnswerExtVO> list(String examId, String questionId);
+    // 自定义方法，根据考试ID和试题ID列表查询考试问题回答信息（扩展信息）
+    List<ExamQuAnswerExtVO> list(String examId, String questionId); // 注意：这里的参数类型通常为Integer，除非有特定原因使用String
 
     /**
      * 获取单题作答信息
-     * @param examId 考试id
-     * @param questionId 试题id
-     * @return 查询结果
+     * @param examId 考试ID，用于标识需要查询作答信息的考试
+     * @param questionId 试题ID，用于标识需要查询作答信息的试题
+     * @return 查询结果，包含试题作答的详细信息，封装在QuestionAnalyseVO对象中
      */
-    QuestionAnalyseVO questionAnalyse(Integer examId, Integer questionId);
+    QuestionAnalyseVO questionAnalyse(Integer examId, Integer questionId); // 根据考试ID和试题ID查询试题作答分析信息
 
     /**
      * 删除用户考试作答记录
-     * @param userIds 用户id列表
-     * @return 影响记录数
+     * @param userIds 用户ID列表，用于标识需要删除作答记录的用户
+     * @return 影响记录数，表示成功删除的作答记录数量
      */
-    Integer deleteByUserIds(List<Integer> userIds);
+    Integer deleteByUserIds(List<Integer> userIds); // 根据用户ID列表删除对应的考试作答记录
 
     /**
      * 获取用户回答主观题信息
-     * @param userId 用户id
-     * @param examId 考试id
-     * @return 结果集
+     * @param userId 用户ID，用于标识需要查询作答信息的用户
+     * @param examId 考试ID，用于标识需要查询作答信息的考试
+     * @return 结果集，包含用户回答主观题的详细信息，封装在List<UserAnswerDetailVO>中
      */
-    List<UserAnswerDetailVO> selectUserAnswer(Integer userId, Integer examId);
-}
+    List<UserAnswerDetailVO> selectUserAnswer(Integer userId, Integer examId); // 根据用户ID和考试ID查询用户回答主观题的信息
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/ExamQuestionMapper.java b/src/main/java/cn/org/alan/exam/mapper/ExamQuestionMapper.java
index 7d9ec34..75ef3be 100644
--- a/src/main/java/cn/org/alan/exam/mapper/ExamQuestionMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/ExamQuestionMapper.java
@@ -1,16 +1,25 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前接口所在的包路径
 
-import cn.org.alan.exam.model.entity.ExamQuestion;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import cn.org.alan.exam.model.entity.ExamQuestion; // 导入ExamQuestion实体类，该类代表考试题目的数据模型
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口，提供基本的CRUD操作
 
-import java.util.List;
-import java.util.Map;
+import java.util.List; // 导入List接口，用于处理集合数据
+import java.util.Map; // 导入Map接口，用于存储键值对数据
 
 /**
- * @Author Alan
- * @Version
- * @Date 2024/4/7 3:49 PM
+ * @Author Alan // 声明当前接口的作者
+ * @Version // 版本信息缺失，通常这里会指定接口的版本号或者留空
+ * @Date 2024/4/7 3:49 PM // 声明当前接口的创建日期和时间
  */
-public interface ExamQuestionMapper extends BaseMapper<ExamQuestion> {
+public interface ExamQuestionMapper extends BaseMapper<ExamQuestion> { // 声明ExamQuestionMapper接口继承自BaseMapper<ExamQuestion>，提供基本的ExamQuestion数据操作
+
+    // 自定义方法，用于插入考试题目信息
+    // 参数说明：
+    // examId - 考试ID，用于标识需要插入题目的考试
+    // quType - 题目类型，用于区分不同类型的题目（如单选题、多选题、判断题等）
+    // quScore - 题目分数，表示该题目的分值
+    // questionIdsAndSorts - 题目ID和排序的列表，其中每个Map对象包含题目ID（作为键）和对应的排序值（作为值）
     int insertQuestion(Integer examId, Integer quType, Integer quScore, List<Map<String, Object>> questionIdsAndSorts);
-}
+    // 方法返回值为int类型，通常表示插入操作影响的行数，但在这里可能主要用于表示操作是否成功（如返回1表示成功，0或负数表示失败）
+    // 注意：这里的业务逻辑可能需要根据实际情况调整，例如题目ID和排序的存储方式、如何确保数据的一致性等
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/ExamRepoMapper.java b/src/main/java/cn/org/alan/exam/mapper/ExamRepoMapper.java
index 81f1004..8e877d3 100644
--- a/src/main/java/cn/org/alan/exam/mapper/ExamRepoMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/ExamRepoMapper.java
@@ -1,16 +1,25 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前Mapper接口所在的包路径
 
+// 导入ExamRepo实体类，该类是与数据库表对应的Java对象，用于表示考试资源仓库的实体
 import cn.org.alan.exam.model.entity.ExamRepo;
+
+// 导入MyBatis-Plus提供的BaseMapper接口，它提供了基础的CRUD操作方法
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口：定义了对数据库表进行操作的方法的接口
+ * </p>
+ * <p>
+ *  这个接口继承自BaseMapper，因此自动拥有了BaseMapper中定义的所有方法，
+ *  这些方法可以用于对数据库表进行基础的CRUD（创建、读取、更新、删除）操作。
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口的创建日期或版本号
  */
-public interface ExamRepoMapper extends BaseMapper<ExamRepo> {
+public interface ExamRepoMapper extends BaseMapper<ExamRepo> { // 声明ExamRepoMapper接口，它继承自BaseMapper<ExamRepo>，因此可以对ExamRepo实体进行基础的数据库操作
 
-}
+    // 由于此接口仅继承了BaseMapper，并未定义额外的方法，
+    // 因此这里没有额外的代码需要解释。所有对ExamRepo实体的数据库操作都将通过BaseMapper中定义的方法来完成。
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/ExerciseRecordMapper.java b/src/main/java/cn/org/alan/exam/mapper/ExerciseRecordMapper.java
index aff5b73..3d4bdce 100644
--- a/src/main/java/cn/org/alan/exam/mapper/ExerciseRecordMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/ExerciseRecordMapper.java
@@ -1,24 +1,29 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前Mapper接口所在的包路径
 
+// 导入ExerciseRecord实体类，该类是与数据库表对应的Java对象，用于表示用户的练习作答记录
 import cn.org.alan.exam.model.entity.ExerciseRecord;
+
+// 导入MyBatis-Plus提供的BaseMapper接口，它提供了基础的CRUD操作方法
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
+// 导入Java的List接口，用于处理用户ID的集合
 import java.util.List;
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口：定义了对数据库表进行操作的方法的接口，专门用于处理ExerciseRecord实体的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口的创建日期或版本号
  */
-public interface ExerciseRecordMapper extends BaseMapper<ExerciseRecord> {
+public interface ExerciseRecordMapper extends BaseMapper<ExerciseRecord> { // 声明ExerciseRecordMapper接口，它继承自BaseMapper<ExerciseRecord>，因此可以对ExerciseRecord实体进行基础的数据库操作
 
     /**
-     * 删除用户练习作答记录
-     * @param userIds 用户id列表
-     * @return 影响记录数
+     * 删除用户练习作答记录的方法
+     *
+     * @param userIds 用户ID列表，表示需要删除作答记录的用户ID集合
+     * @return 影响记录数，表示被删除的记录条数，通常用于判断操作是否成功（非0值表示成功，0表示未找到匹配记录或操作失败）
      */
-    Integer deleteByUserIds(List<Integer> userIds);
-}
+    Integer deleteByUserIds(List<Integer> userIds); // 定义一个自定义方法，用于根据用户ID列表删除对应的练习作答记录，并返回被影响的记录数
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/GradeExerciseMapper.java b/src/main/java/cn/org/alan/exam/mapper/GradeExerciseMapper.java
index 7142abb..19f36b9 100644
--- a/src/main/java/cn/org/alan/exam/mapper/GradeExerciseMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/GradeExerciseMapper.java
@@ -1,24 +1,29 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前Mapper接口所在的包路径
 
+// 导入GradeExercise实体类，该类是与数据库表对应的Java对象，用于表示用户创建的可供学生练习的题库关联信息
 import cn.org.alan.exam.model.entity.GradeExercise;
+
+// 导入MyBatis-Plus提供的BaseMapper接口，它提供了基础的CRUD操作方法
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
+// 导入Java的List接口，用于处理用户ID的集合
 import java.util.List;
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口：定义了对数据库表进行操作的方法的接口，专门用于处理GradeExercise实体的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口的创建日期或版本号
  */
-public interface GradeExerciseMapper extends BaseMapper<GradeExercise> {
+public interface GradeExerciseMapper extends BaseMapper<GradeExercise> { // 声明GradeExerciseMapper接口，它继承自BaseMapper<GradeExercise>，因此可以对GradeExercise实体进行基础的数据库操作
 
     /**
-     * 删除用户创建的可供学生练习的题库关联表
-     * @param userIds 用户id列表
-     * @return 影响记录数
+     * 删除用户创建的可供学生练习的题库关联记录的方法
+     *
+     * @param userIds 用户ID列表，指定需要删除其创建的题库关联记录的用户ID集合
+     * @return 影响记录数，表示被删除的记录条数，通常用于判断操作是否成功（非0值表示成功，0表示未找到匹配记录或操作失败）
      */
-    Integer deleteByUserIds(List<Integer> userIds);
-}
+    Integer deleteByUserIds(List<Integer> userIds); // 定义一个自定义方法，用于根据用户ID列表删除对应的题库关联记录，并返回被影响的记录数
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/GradeMapper.java b/src/main/java/cn/org/alan/exam/mapper/GradeMapper.java
index 7faab77..9edbf4a 100644
--- a/src/main/java/cn/org/alan/exam/mapper/GradeMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/GradeMapper.java
@@ -1,32 +1,44 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前Mapper接口所在的包路径
 
+// 导入Grade实体类，该类是与数据库表对应的Java对象，用于表示成绩信息
 import cn.org.alan.exam.model.entity.Grade;
+// 导入GradeVO类，这是一个值对象（Value Object），通常用于封装从数据库查询后需要展示给前端的数据
 import cn.org.alan.exam.model.vo.GradeVO;
+// 导入MyBatis-Plus提供的BaseMapper接口，它提供了基础的CRUD操作方法
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 导入MyBatis-Plus分页插件提供的Page类，用于实现分页查询功能
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 导入Spring框架的Repository注解，用于标识这是一个数据访问层的组件
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口：定义了对数据库表进行操作的方法的接口，专门用于处理Grade实体的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口的创建日期或版本号
  */
-@Repository
-public interface GradeMapper extends BaseMapper<Grade> {
+@Repository // 使用@Repository注解标识这是一个数据访问层的组件，Spring会将其识别为一个Bean并进行管理
+public interface GradeMapper extends BaseMapper<Grade> { // 声明GradeMapper接口，它继承自BaseMapper<Grade>，因此可以对Grade实体进行基础的数据库操作
+
+    // 根据用户ID列表查询对应的成绩ID列表
     List<Integer> selectIdsByUserIds(List<Integer> userIds);
 
+    // 根据用户ID列表删除对应的成绩记录
     Integer deleteByUserId(List<Integer> userIds);
 
-    Page<GradeVO> selectGradePage(Page<GradeVO> page, Integer userId , String gradeName, Integer role);
+    // 分页查询成绩信息，返回Page<GradeVO>对象，包含分页信息和查询结果
+    Page<GradeVO> selectGradePage(Page<GradeVO> page, Integer userId, String gradeName, Integer role);
 
+    // 根据用户ID、角色、成绩名称和分页参数（偏移量和页面大小）查询成绩ID列表，用于分页显示
     List<Integer> selectGradeIdsPage(Integer userId, Integer role, String gradeName, int offset, Integer pageSize);
 
+    // 根据ID列表批量查询成绩信息，返回GradeVO对象列表
     List<GradeVO> batchSelectByIds(List<Integer> missIds);
 
+    // 根据用户ID、成绩名称和角色统计符合条件的成绩记录数
     int countByCondition(Integer userId, String gradeName, Integer role);
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/ManualScoreMapper.java b/src/main/java/cn/org/alan/exam/mapper/ManualScoreMapper.java
index 7f0e305..3b77689 100644
--- a/src/main/java/cn/org/alan/exam/mapper/ManualScoreMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/ManualScoreMapper.java
@@ -1,31 +1,35 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前Mapper接口所在的包路径
 
+// 导入ManualScore实体类，该类是与数据库表对应的Java对象，用于表示用户批改的主观题分数信息
 import cn.org.alan.exam.model.entity.ManualScore;
+// 导入MyBatis-Plus提供的BaseMapper接口，它提供了基础的CRUD操作方法
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
-import java.util.List;
+import java.util.List; // 导入Java的List接口，用于处理集合数据
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口：定义了对数据库表进行操作的方法的接口，专门用于处理ManualScore实体的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口的创建日期或版本号
  */
-public interface ManualScoreMapper extends BaseMapper<ManualScore> {
+public interface ManualScoreMapper extends BaseMapper<ManualScore> { // 声明ManualScoreMapper接口，它继承自BaseMapper<ManualScore>，因此可以对ManualScore实体进行基础的数据库操作
 
     /**
-     * 删除用户批改的主观题
-     * @param userIds 用户id列表
-     * @return 影响记录数
+     * 根据用户ID列表删除用户批改的主观题分数记录
+     *
+     * @param userIds 用户ID列表，指定需要删除其批改的主观题分数记录的用户ID集合
+     * @return 影响记录数，表示被删除的记录条数，通常用于判断操作是否成功（非0值表示成功，0表示未找到匹配记录或操作失败）
      */
-    Integer deleteByUserIds(List<Integer> userIds);
+    Integer deleteByUserIds(List<Integer> userIds); // 定义一个自定义方法，用于根据用户ID列表删除对应的主观题分数记录，并返回被影响的记录数
 
     /**
-     * 批量添加批改分数
-     * @param manualScores 入参
-     * @return 影响记录数
+     * 批量添加用户批改的主观题分数记录
+     *
+     * @param manualScores 批改分数列表，包含需要批量添加到数据库的主观题分数信息
+     * @return 影响记录数，表示被成功添加的记录条数，通常用于判断操作是否成功（非0值表示成功添加了部分或全部记录，0表示未添加任何记录）
      */
-    Integer insertList(List<ManualScore> manualScores);
-}
+    Integer insertList(List<ManualScore> manualScores); // 定义一个自定义方法，用于批量添加主观题分数记录到数据库，并返回被影响的记录数
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/NoticeGradeMapper.java b/src/main/java/cn/org/alan/exam/mapper/NoticeGradeMapper.java
index 8108e3f..82b6a78 100644
--- a/src/main/java/cn/org/alan/exam/mapper/NoticeGradeMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/NoticeGradeMapper.java
@@ -1,27 +1,38 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 声明当前Mapper接口所在的包路径
 
+// 导入Grade实体类，该类表示学生的成绩信息
 import cn.org.alan.exam.model.entity.Grade;
+// 导入NoticeGrade实体类，该类表示公告与班级的关联信息
 import cn.org.alan.exam.model.entity.NoticeGrade;
+// 导入MyBatis-Plus提供的BaseMapper接口，提供基础的CRUD操作
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
-import java.util.List;
+import java.util.List; // 导入Java的List接口，用于处理集合数据
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口：定义了对数据库表进行操作的方法的接口，专门用于处理NoticeGrade实体的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口的创建日期或版本号
  */
-public interface NoticeGradeMapper extends BaseMapper<NoticeGrade> {
+public interface NoticeGradeMapper extends BaseMapper<NoticeGrade> { // 声明NoticeGradeMapper接口，继承自BaseMapper<NoticeGrade>，提供基础的CRUD操作
 
     /**
-     * 根据公告id删除公告与班级关联
-     * @param noticeIds 公告id列表
-     * @return 影响数据库记录数
+     * 根据公告ID列表删除公告与班级的关联记录
+     *
+     * @param noticeIds 公告ID列表，指定需要删除其关联的公告ID集合
+     * @return 影响数据库记录数，表示被删除的记录条数，通常用于判断操作是否成功（非0值表示成功，0表示未找到匹配记录或操作失败）
      */
-    Integer deleteByNoticeIds(List<Integer> noticeIds);
+    Integer deleteByNoticeIds(List<Integer> noticeIds); // 定义一个自定义方法，用于根据公告ID列表删除对应的公告与班级关联记录，并返回被影响的记录数
 
-    int addNoticeGrade(Integer noticeId, List<Grade> grades);
-}
+    /**
+     * 添加公告与成绩的关联记录
+     *
+     * @param noticeId 公告ID，指定需要添加关联的公告
+     * @param grades 成绩列表，包含需要与该公告关联的成绩信息
+     * @return 影响数据库记录数，表示被成功添加的记录条数，通常用于判断操作是否成功（非0值表示成功添加了部分或全部记录，0表示未添加任何记录）
+     */
+    int addNoticeGrade(Integer noticeId, List<Grade> grades); // 定义一个自定义方法，用于添加公告与成绩的关联记录到数据库，并返回被影响的记录数
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/NoticeMapper.java b/src/main/java/cn/org/alan/exam/mapper/NoticeMapper.java
index 0835b3d..9deb694 100644
--- a/src/main/java/cn/org/alan/exam/mapper/NoticeMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/NoticeMapper.java
@@ -1,45 +1,94 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 指定当前Mapper接口所在的包路径
 
+// 导入Notice实体类，表示公告信息
 import cn.org.alan.exam.model.entity.Notice;
+// 导入NoticeVO值对象类，通常用于封装传递给前端的数据，可能包含Notice实体类的数据以及其他相关信息
 import cn.org.alan.exam.model.vo.NoticeVO;
+// 导入MyBatis-Plus提供的BaseMapper接口，提供基础的CRUD操作
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 导入MyBatis-Plus分页插件提供的Page类，用于分页查询
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 
-import java.util.List;
+import java.util.List; // 导入Java的List接口，用于处理集合数据
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口：定义了对数据库表进行操作的方法的接口，专门用于处理Notice实体的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明当前接口的作者
+ * @since 2024-03-21 // 声明当前接口的创建日期或版本号
  */
-public interface NoticeMapper extends BaseMapper<Notice> {
+public interface NoticeMapper extends BaseMapper<Notice> { // 声明NoticeMapper接口，继承自BaseMapper<Notice>，提供基础的CRUD操作
 
-    int removeNotice(List<Integer> noticeIds);
+    /**
+     * 根据公告ID列表删除公告记录
+     *
+     * @param noticeIds 公告ID列表，指定需要删除的公告ID集合
+     * @return 影响记录数，表示被删除的记录条数，通常用于判断操作是否成功（非0值表示成功，0表示未找到匹配记录或操作失败）
+     */
+    int removeNotice(List<Integer> noticeIds); // 定义一个自定义方法，用于根据公告ID列表删除公告记录，并返回被影响的记录数
 
     /**
-     * 删除用户创建的公告
-     * @param userIds 用户id列表
-     * @return 影响记录数
+     * 删除用户创建的公告记录
+     *
+     * @param userIds 用户ID列表，指定需要删除其创建的公告的用户ID集合
+     * @return 影响记录数，表示被删除的记录条数，通常用于判断操作是否成功（非0值表示成功，0表示未找到匹配记录或操作失败）
      */
-    Integer deleteByUserIds(List<Integer> userIds);
+    Integer deleteByUserIds(List<Integer> userIds); // 定义一个自定义方法，用于根据用户ID列表删除用户创建的公告记录，并返回被影响的记录数
 
     /**
-     * 根据用户id获取公告ids
-     * @param userIds 用户id列表
-     * @return 查询结果
+     * 根据用户ID列表查询公告ID
+     *
+     * @param userIds 用户ID列表，指定需要查询其创建的公告ID的用户ID集合
+     * @return 查询结果，返回用户创建的公告ID列表
      */
-    List<Integer> selectIdsByUserIds(List<Integer> userIds);
+    List<Integer> selectIdsByUserIds(List<Integer> userIds); // 定义一个自定义方法，用于根据用户ID列表查询并返回对应的公告ID列表
 
-    Page<NoticeVO> selectNewNoticePage(Page<NoticeVO> page, Integer userId);
+    /**
+     * 分页查询用户的新公告
+     *
+     * @param page 分页对象，包含分页参数（如页码、每页数量）和查询结果
+     * @param userId 用户ID，指定需要查询其新公告的用户
+     * @return 分页查询结果，返回包含公告信息的NoticeVO对象的Page对象
+     */
+    Page<NoticeVO> selectNewNoticePage(Page<NoticeVO> page, Integer userId); // 定义一个自定义方法，用于分页查询并返回用户的新公告信息，结果封装在NoticeVO对象中
 
-    int countByCondition(Integer userId, String title);
+    /**
+     * 根据条件统计公告数量
+     *
+     * @param userId 用户ID，指定需要统计其公告数量的用户（可能为空，表示不根据用户ID过滤）
+     * @param title 公告标题，指定需要统计的公告标题（可能为空，表示不根据标题过滤）
+     * @return 统计结果，返回符合条件的公告数量
+     */
+    int countByCondition(Integer userId, String title); // 定义一个自定义方法，用于根据用户ID和公告标题统计公告数量，并返回结果
 
-    List<Integer> selectNoticeIdsPage(Integer userId, String title, int offset, Integer pageSize);
+    /**
+     * 分页查询公告ID列表
+     *
+     * @param userId 用户ID，指定需要查询其公告ID的用户（可能为空，表示不根据用户ID过滤）
+     * @param title 公告标题，指定需要查询的公告标题（可能为空，表示不根据标题过滤）
+     * @param offset 查询偏移量，用于分页查询中的页码计算
+     * @param pageSize 每页查询数量，用于分页查询中的每页大小
+     * @return 查询结果，返回符合条件的公告ID列表
+     */
+    List<Integer> selectNoticeIdsPage(Integer userId, String title, int offset, Integer pageSize); // 定义一个自定义方法，用于分页查询并返回符合条件的公告ID列表
 
-    List<NoticeVO> batchSelectByIds(List<Integer> missIds);
+    /**
+     * 批量查询公告信息
+     *
+     * @param missIds 公告ID列表，指定需要查询的公告ID集合
+     * @return 查询结果，返回包含公告信息的NoticeVO对象列表
+     */
+    List<NoticeVO> batchSelectByIds(List<Integer> missIds); // 定义一个自定义方法，用于批量查询并返回对应的公告信息，结果封装在NoticeVO对象中
 
-    List<Integer> selectNewNoticeIdsPage(Integer userId, int offset, Integer pageSize);
-}
+    /**
+     * 分页查询用户的新公告ID列表
+     *
+     * @param userId 用户ID，指定需要查询其新公告ID的用户
+     * @param offset 查询偏移量，用于分页查询中的页码计算
+     * @param pageSize 每页查询数量，用于分页查询中的每页大小
+     * @return 查询结果，返回符合条件的新公告ID列表
+     */
+    List<Integer> selectNewNoticeIdsPage(Integer userId, int offset, Integer pageSize); // 定义一个自定义方法，用于分页查询并返回用户的新公告ID列表
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/OptionMapper.java b/src/main/java/cn/org/alan/exam/mapper/OptionMapper.java
index e5e075a..6b38014 100644
--- a/src/main/java/cn/org/alan/exam/mapper/OptionMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/OptionMapper.java
@@ -1,52 +1,57 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 声明包路径，指明当前接口所在的包
 
-import cn.org.alan.exam.model.entity.Option;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import cn.org.alan.exam.model.entity.Option; // 导入Option实体类，代表试题选项的数据模型
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入BaseMapper接口，提供基础的CRUD操作
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理集合数据
 
 /**
  * <p>
- *  Mapper 接口
+ * Mapper 接口：定义了对数据库表进行操作的方法的接口，专门用于处理Option实体的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明接口作者
+ * @since 2024-03-21 // 声明接口创建日期或版本号
  */
-public interface OptionMapper extends BaseMapper<Option> {
-
+public interface OptionMapper extends BaseMapper<Option> { // 声明OptionMapper接口，继承自BaseMapper<Option>，提供基础的CRUD操作
 
     /**
-     * 批量添加选项
-     * @param options 选型列表
-     * @return 影响数据库内容的记录数
+     * 批量添加选项到数据库
+     *
+     * @param options 选项列表，包含需要添加到数据库中的Option对象集合
+     * @return 影响数据库内容的记录数，表示成功插入到数据库中的记录条数
      */
-    Integer insertBatch(List<Option> options);
+    Integer insertBatch(List<Option> options); // 定义一个自定义方法，用于批量添加选项到数据库，并返回影响的记录数
 
     /**
-     * 批量删除，根据选项所属试题id列表删除试题选项
-     * @param quIdList 试题id列表
-     * @return 影响表中记录的条数
+     * 批量删除选项，根据选项所属试题ID列表删除对应的试题选项
+     *
+     * @param quIdList 试题ID列表，指定需要删除其对应选项的试题ID集合
+     * @return 影响表中记录的条数，表示被成功删除的记录条数
      */
-    Integer deleteBatchByQuIds(List<Integer> quIdList);
+    Integer deleteBatchByQuIds(List<Integer> quIdList); // 定义一个自定义方法，用于根据试题ID列表批量删除选项，并返回影响的记录数
 
     /**
-     * 根据试题id获取所有选项
-     * @param id 试题id
-     * @return 结果集
+     * 根据试题ID查询所有选项
+     *
+     * @param id 试题ID，指定需要查询其所有选项的试题
+     * @return 结果集，返回包含该试题所有选项的List<Option>集合
      */
-    List<Option> selectAllByQuestionId(Integer id);
-/**
-     * 根据试题id获取所有选项，不包含是否正确
-     * @param id 试题id
-     * @return 结果集
+    List<Option> selectAllByQuestionId(Integer id); // 定义一个自定义方法，用于根据试题ID查询并返回其所有选项的集合
+
+    /**
+     * 根据试题ID查询所有选项，但不包含选项是否正确的信息
+     *
+     * @param id 试题ID，指定需要查询其所有选项（不包含是否正确信息）的试题
+     * @return 结果集，返回包含该试题所有选项（不包含是否正确信息）的List<Option>集合
      */
-    List<Option> selectByQuestionId(Integer id);
+    List<Option> selectByQuestionId(Integer id); // 定义一个自定义方法，用于根据试题ID查询并返回其所有选项（不包含是否正确信息）的集合
 
     /**
-     * 根据试题Id获取正确个数
-     * @param optionIds 选项Id列表
-     * @return 正确个数
+     * 根据选项ID列表查询正确的选项个数
+     *
+     * @param optionIds 选项ID列表，指定需要查询其正确个数的选项ID集合
+     * @return 正确个数，返回在给定选项ID列表中标记为正确的选项数量
      */
-    Integer selectRightCountByIds(List<Integer> optionIds);
-}
+    Integer selectRightCountByIds(List<Integer> optionIds); // 定义一个自定义方法，用于根据选项ID列表查询并返回正确的选项个数
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/QuestionMapper.java b/src/main/java/cn/org/alan/exam/mapper/QuestionMapper.java
index 450505e..075e77a 100644
--- a/src/main/java/cn/org/alan/exam/mapper/QuestionMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/QuestionMapper.java
@@ -1,74 +1,114 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 声明包路径，包含当前Mapper接口
 
-import cn.org.alan.exam.model.entity.Question;
-import cn.org.alan.exam.model.vo.QuestionVO;
-import cn.org.alan.exam.model.vo.exercise.QuestionSheetVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
+import cn.org.alan.exam.model.entity.Question; // 导入Question实体类，代表试题的数据模型
+import cn.org.alan.exam.model.vo.QuestionVO; // 导入QuestionVO类，用于视图层展示试题的详细信息
+import cn.org.alan.exam.model.vo.exercise.QuestionSheetVO; // 导入QuestionSheetVO类，用于表示用户的试题答题情况
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入BaseMapper接口，提供基础的CRUD操作
+import com.baomidou.mybatisplus.core.metadata.IPage; // 导入IPage接口，用于分页查询
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理集合数据
 
 /**
  * <p>
- * Mapper 接口
+ * Mapper 接口：定义了对数据库表进行操作的方法的接口，专门用于处理Question实体的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 声明接口作者
+ * @since 2024-03-21 // 声明接口创建日期或版本号
  */
-public interface QuestionMapper extends BaseMapper<Question> {
-
-
+public interface QuestionMapper extends BaseMapper<Question> { // 声明QuestionMapper接口，继承自BaseMapper<Question>，提供基础的CRUD操作
 
     /**
      * 分页获取试题信息
      *
-     * @param page   分页信息
-     * @param content  试题模糊查询
-     * @param repoId 题库id
-     * @param type 试题类型
-     * @param userId 用户id
-     * @return 放回结果
+     * @param page   分页信息，包含当前页码、每页数量等
+     * @param content 试题模糊查询的关键字
+     * @param repoId 题库ID，指定查询哪个题库的试题
+     * @param type 试题类型，指定查询哪种类型的试题
+     * @param userId 用户ID，指定查询该用户是否有权限查看的试题（可能用于筛选用户创建的试题）
+     * @return 返回分页后的试题信息集合，封装在IPage<QuestionVO>对象中
      */
     IPage<QuestionVO> pagingQuestion(IPage<QuestionVO> page, String content, Integer repoId, Integer type, Integer userId);
 
     /**
-     * 根据试题id获取单题详情
-     * @param id 试题id
-     * @return 结果集
+     * 根据试题ID获取单题详情
+     *
+     * @param id 试题ID，唯一标识一个试题
+     * @return 返回试题的详细信息，封装在QuestionVO对象中
      */
     QuestionVO selectSingle(Integer id);
 
     /**
      * 删除用户添加的试题
-     * @param userIds 用户id列表
-     * @return 影响记录数
+     *
+     * @param userIds 用户ID列表，指定需要删除其试题的用户
+     * @return 返回影响的记录数，表示被成功删除的试题数量
      */
     Integer deleteByUserIds(List<Integer> userIds);
 
     /**
-     * 获取用户创建的试题id列表
-     * @param userIds 用户id列表
-     * @return 查询结果
+     * 获取用户创建的试题ID列表
+     *
+     * @param userIds 用户ID列表，指定需要查询其创建的试题的用户
+     * @return 返回用户创建的试题ID集合
      */
     List<Integer> selectIdsByUserIds(List<Integer> userIds);
 
     /**
-     * 获取试题Id并判断用户是否做过该题
-     * @param repoId 题库Id
-     * @param quType 试题类型
-     * @param userId 用户Id
-     * @return 查询结果
+     * 获取试题ID并判断用户是否做过该题
+     *
+     * @param repoId 题库ID，指定查询哪个题库的试题
+     * @param quType 试题类型，指定查询哪种类型的试题
+     * @param userId 用户ID，指定查询该用户是否做过这些试题
+     * @return 返回用户的试题答题情况集合，封装在QuestionSheetVO对象中
      */
     List<QuestionSheetVO> selectQuestionSheet(Integer repoId, Integer quType, Integer userId);
 
+    /**
+     * 根据试题ID获取试题的详细信息
+     *
+     * @param id 试题ID，唯一标识一个试题
+     * @return 返回试题的详细信息，封装在QuestionVO对象中（与selectSingle方法功能相似，可能是为了不同的业务场景而定义）
+     */
     QuestionVO selectDetail(Integer id);
 
+    /**
+     * 批量删除试题，根据试题ID列表删除
+     *
+     * @param list 试题ID列表，指定需要删除的试题
+     * @return 该方法通常为void，表示不返回任何值，但实际操作中可能会影响数据库中的记录数
+     */
     void deleteBatchIdsQu(List<Integer> list);
 
+    /**
+     * 根据条件统计试题数量
+     *
+     * @param userId 用户ID，指定统计哪个用户创建的试题数量（可能也用于筛选用户有权限查看的试题）
+     * @param title 试题标题的关键字，用于模糊查询
+     * @param type 试题类型，指定统计哪种类型的试题
+     * @param repoId 题库ID，指定统计哪个题库的试题数量
+     * @return 返回符合条件的试题数量
+     */
     int countByCondition(Integer userId, String title, Integer type, Integer repoId);
 
+    /**
+     * 分页查询试题ID列表
+     *
+     * @param userId 用户ID，指定查询哪个用户创建的试题（可能也用于筛选用户有权限查看的试题）
+     * @param title 试题标题的关键字，用于模糊查询
+     * @param type 试题类型，指定查询哪种类型的试题
+     * @param repoId 题库ID，指定查询哪个题库的试题
+     * @param offset 查询的起始位置（页码相关的计算得出）
+     * @param pageSize 每页显示的记录数
+     * @return 返回分页后的试题ID集合
+     */
     List<Integer> selectQuestionIdsPage(Integer userId, String title, Integer type, Integer repoId, int offset, Integer pageSize);
 
+    /**
+     * 批量根据ID查询试题详细信息
+     *
+     * @param missIds 试题ID列表，指定需要查询详细信息的试题
+     * @return 返回试题的详细信息集合，封装在QuestionVO对象中
+     */
     List<QuestionVO> batchSelectByIds(List<Integer> missIds);
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/RepoMapper.java b/src/main/java/cn/org/alan/exam/mapper/RepoMapper.java
index 767d4e8..0d16785 100644
--- a/src/main/java/cn/org/alan/exam/mapper/RepoMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/RepoMapper.java
@@ -1,30 +1,30 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 定义mapper接口所在的包
 
-import cn.org.alan.exam.model.entity.Repo;
-import cn.org.alan.exam.model.vo.repo.RepoListVO;
-import cn.org.alan.exam.model.vo.repo.RepoVO;
-import cn.org.alan.exam.model.vo.exercise.ExerciseRepoVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import org.apache.ibatis.annotations.Param;
-import org.springframework.stereotype.Repository;
+import cn.org.alan.exam.model.entity.Repo; // 引入Repo实体类
+import cn.org.alan.exam.model.vo.repo.RepoListVO; // 引入RepoListVO视图对象
+import cn.org.alan.exam.model.vo.repo.RepoVO; // 引入RepoVO视图对象
+import cn.org.alan.exam.model.vo.exercise.ExerciseRepoVO; // 引入ExerciseRepoVO视图对象
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入MyBatis Plus的BaseMapper接口
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入MyBatis Plus的分页接口
+import org.apache.ibatis.annotations.Param; // 引入MyBatis的Param注解，用于传递参数
+import org.springframework.stereotype.Repository; // 引入Spring的Repository注解，标记为持久层组件
 
-import java.util.List;
+import java.util.List; // 引入Java的List接口
 
 /**
  * @author WeiJin
  * @since 2024-03-21
- */
-@Repository
-public interface RepoMapper extends BaseMapper<Repo> {
+ */ // 类注释，说明作者和创建时间
+@Repository // 标记为Spring的持久层组件
+public interface RepoMapper extends BaseMapper<Repo> { // 定义RepoMapper接口，继承BaseMapper，提供基础的CRUD操作
 
     /**
      * 分页查询题库
      *
-     * @param page   分页项
-     * @param title  题库名
-     * @param userId 用户名
-     * @return 响应结果
+     * @param page   分页项，包含分页信息，如页码、每页数量等
+     * @param title  题库名，用于筛选符合条件的题库
+     * @param userId 用户名（或用户ID），用于筛选该用户创建的题库
+     * @return 响应结果，包含分页信息和筛选后的题库列表
      */
     IPage<RepoVO> pagingRepo(@Param("page") IPage<RepoVO> page, @Param("title") String title,
                              @Param("userId") Integer userId);
@@ -32,20 +32,27 @@ public interface RepoMapper extends BaseMapper<Repo> {
     /**
      * 删除用户创建的题库
      *
-     * @param userIds 用户id列表
-     * @return 影响记录数
+     * @param userIds 用户id列表，用于指定要删除哪些用户创建的题库
+     * @return 影响记录数，即被删除的题库数量
      */
     Integer deleteByUserIds(List<Integer> userIds);
 
     /**
      * 分页获取可刷题库列表
      *
-     * @param page  分页信息
-     * @param title 题库名
-     * @return 结果
+     * @param page  分页信息，包含分页请求的信息
+     * @param title 题库名，用于筛选符合条件的题库
+     * @return 结果，包含分页信息和筛选后的题库列表（ExerciseRepoVO格式）
      */
     IPage<ExerciseRepoVO> selectRepo(IPage<ExerciseRepoVO> page,
                                      String title);
 
+    /**
+     * 根据题库名称和用户ID查询题库列表
+     *
+     * @param repoTitle 题库名称，用于筛选符合条件的题库
+     * @param userId 用户ID，用于筛选该用户创建的题库
+     * @return 结果，包含筛选后的题库列表（RepoListVO格式）
+     */
     List<RepoListVO> selectRepoList(String repoTitle, int userId);
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/RoleMapper.java b/src/main/java/cn/org/alan/exam/mapper/RoleMapper.java
index cd3ad3b..d3d1653 100644
--- a/src/main/java/cn/org/alan/exam/mapper/RoleMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/RoleMapper.java
@@ -1,19 +1,25 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 定义RoleMapper接口所在的包路径
 
-import cn.org.alan.exam.model.entity.Role;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import cn.org.alan.exam.model.entity.Role; // 引入Role实体类，该类与数据库中的角色表对应
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入MyBatis Plus的BaseMapper接口，提供基础的CRUD操作
 
-import java.util.List;
+import java.util.List; // 引入Java的List接口，用于定义返回结果类型
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口，用于定义Role相关的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 作者信息
+ * @since 2024-03-21 // 创建时间
  */
-public interface RoleMapper extends BaseMapper<Role> {
+public interface RoleMapper extends BaseMapper<Role> { // 定义RoleMapper接口，继承BaseMapper<Role>，提供对Role实体的基础CRUD操作
 
-    List<String> selectCodeById(Integer roleId);
-}
+    /**
+     * 根据角色ID查询角色编码列表
+     *
+     * @param roleId 角色ID，用于指定要查询的角色
+     * @return 返回角色编码列表，每个编码代表一个特定的角色或权限
+     */
+    List<String> selectCodeById(Integer roleId); // 自定义查询方法，根据角色ID返回对应的角色编码列表
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/StatMapper.java b/src/main/java/cn/org/alan/exam/mapper/StatMapper.java
index b83b101..bb4f19d 100644
--- a/src/main/java/cn/org/alan/exam/mapper/StatMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/StatMapper.java
@@ -1,35 +1,40 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 定义StatMapper接口所在的包路径
 
-import cn.org.alan.exam.model.entity.Grade;
-import cn.org.alan.exam.model.vo.stat.AllStatsVO;
-import cn.org.alan.exam.model.vo.stat.GradeExamVO;
-import cn.org.alan.exam.model.vo.stat.GradeStudentVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import org.apache.ibatis.annotations.Param;
-import org.springframework.stereotype.Repository;
+import cn.org.alan.exam.model.entity.Grade; // 引入Grade实体类，代表年级或班级信息
+import cn.org.alan.exam.model.vo.stat.AllStatsVO; // 引入AllStatsVO视图对象，可能用于其他统计功能（当前接口未使用）
+import cn.org.alan.exam.model.vo.stat.GradeExamVO; // 引入GradeExamVO视图对象，用于封装各班试卷数的统计信息
+import cn.org.alan.exam.model.vo.stat.GradeStudentVO; // 引入GradeStudentVO视图对象，用于封装各班人数的统计信息
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入MyBatis Plus的BaseMapper接口，提供基础的CRUD操作
+import org.apache.ibatis.annotations.Param; // 引入MyBatis的Param注解，用于传递参数
+import org.springframework.stereotype.Repository; // 引入Spring的Repository注解，标记为持久层组件
 
-import java.util.List;
+import java.util.List; // 引入Java的List接口，用于定义返回结果类型
 
 /**
- * @ Author JinXi
- * @ Version 1.0
- * @ Date 2024/5/12 14:56
+ * @ Author JinXi // 作者信息
+ * @ Version 1.0 // 版本信息
+ * @ Date 2024/5/12 14:56 // 创建时间
  */
-@Repository
-public interface  StatMapper extends BaseMapper<Grade> {
+@Repository // 标记为Spring的持久层组件
+public interface StatMapper extends BaseMapper<Grade> { // 定义StatMapper接口，继承BaseMapper<Grade>，提供对Grade实体的基础CRUD操作
 
     /**
      * 统计各班人数
-     * @return 人数总数
+     *
+     * @param roleId 角色ID，可能用于权限控制或指定查询范围（具体含义需结合业务逻辑）
+     * @param id 年级或班级ID，用于指定要统计的年级或班级
+     * @return 返回GradeStudentVO列表，包含各班人数的统计信息
      */
-    List<GradeStudentVO> StudentGradeCount(@Param("roleId")Integer roleId, Integer id);
+    List<GradeStudentVO> StudentGradeCount(@Param("roleId") Integer roleId, Integer id);
 
     /**
      * 统计各班试卷数
-     * @return 试卷总数
+     *
+     * @param roleId 角色ID，可能用于权限控制或指定查询范围（具体含义需结合业务逻辑）
+     * @param id 年级或班级ID，用于指定要统计的年级或班级
+     * @return 返回GradeExamVO列表，包含各班试卷数的统计信息
      */
     List<GradeExamVO> ExamGradeCount(@Param("roleId") Integer roleId, Integer id);
 
-
-
-}
+    // 注意：接口中缺少对AllStatsVO的使用，如果后续需要使用，应添加相应的方法
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/UserBookMapper.java b/src/main/java/cn/org/alan/exam/mapper/UserBookMapper.java
index f7c0e3f..854e2d2 100644
--- a/src/main/java/cn/org/alan/exam/mapper/UserBookMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/UserBookMapper.java
@@ -1,31 +1,46 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 定义UserBookMapper接口所在的包路径
 
-import cn.org.alan.exam.model.entity.UserBook;
-import cn.org.alan.exam.model.vo.userbook.UserPageBookVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import cn.org.alan.exam.model.entity.UserBook; // 引入UserBook实体类，代表用户的错题本记录
+import cn.org.alan.exam.model.vo.userbook.UserPageBookVO; // 引入UserPageBookVO视图对象，用于封装分页查询结果
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入MyBatis Plus的BaseMapper接口，提供基础的CRUD操作
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 引入MyBatis Plus的分页插件Page类，用于分页查询
 
-import java.util.List;
+import java.util.List; // 引入Java的List接口，用于定义返回结果类型或传递参数类型
 
 /**
  * <p>
- * Mapper 接口
+ * Mapper 接口，用于定义UserBook相关的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 作者信息
+ * @since 2024-03-21 // 创建时间
  */
-public interface UserBookMapper extends BaseMapper<UserBook> {
+public interface UserBookMapper extends BaseMapper<UserBook> { // 定义UserBookMapper接口，继承BaseMapper<UserBook>，提供对UserBook实体的基础CRUD操作
 
     /**
-     * 删除用户的错题本
-     * @param userIds 用户id列表
-     * @return 影响记录数
+     * 删除用户的错题本记录
+     *
+     * @param userIds 用户ID列表，用于指定要删除记录的用户
+     * @return 返回影响的记录数，即被删除的记录条数
      */
-    Integer deleteByUserIds(List<Integer> userIds);
+    Integer deleteByUserIds(List<Integer> userIds); // 自定义删除方法，根据用户ID列表删除对应的错题本记录
 
+    /**
+     * 批量添加用户的错题本记录
+     *
+     * @param userBookArrayList UserBook对象列表，包含要添加的错题本记录信息
+     * @return 返回影响的记录数，即成功添加的记录条数
+     */
+    int addUserBookList(List<UserBook> userBookArrayList); // 自定义添加方法，批量添加错题本记录
 
-    int addUserBookList(List<UserBook> userBookArrayList);
-
-    Page<UserPageBookVO> selectPageVo(Page<UserPageBookVO> page, String examName, Integer userId,Integer role);
-}
+    /**
+     * 分页查询用户的错题本记录
+     *
+     * @param page 分页对象，包含分页信息和查询条件
+     * @param examName 考试名称，用于指定要查询的错题本记录的考试
+     * @param userId 用户ID，用于指定要查询的错题本记录的用户
+     * @param role 角色ID，可能用于权限控制或指定查询范围（具体含义需结合业务逻辑）
+     * @return 返回分页查询结果，包含查询到的错题本记录信息和分页信息
+     */
+    Page<UserPageBookVO> selectPageVo(Page<UserPageBookVO> page, String examName, Integer userId, Integer role); // 自定义分页查询方法，根据分页信息、考试名称、用户ID和角色ID查询错题本记录
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/UserDailyLoginDurationMapper.java b/src/main/java/cn/org/alan/exam/mapper/UserDailyLoginDurationMapper.java
index e7789e0..e607415 100644
--- a/src/main/java/cn/org/alan/exam/mapper/UserDailyLoginDurationMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/UserDailyLoginDurationMapper.java
@@ -1,17 +1,24 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 定义UserDailyLoginDurationMapper接口所在的包路径
 
-import cn.org.alan.exam.model.entity.UserDailyLoginDuration;
-import cn.org.alan.exam.model.entity.UserExerciseRecord;
-import cn.org.alan.exam.model.vo.stat.DailyVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import cn.org.alan.exam.model.entity.UserDailyLoginDuration; // 引入UserDailyLoginDuration实体类，表示用户的每日登录时长记录
+import cn.org.alan.exam.model.entity.UserExerciseRecord; // 引入UserExerciseRecord实体类（虽然在此接口中未直接使用，可能是为了后续扩展或代码未完全展示）
+import cn.org.alan.exam.model.vo.stat.DailyVO; // 引入DailyVO视图对象，用于封装每日统计信息
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入MyBatis Plus的BaseMapper接口，提供基础的CRUD操作
 
-import java.util.List;
+// 不需要为import语句添加注释
 
 /**
- * @Author Alan
- * @Version
- * @Date 2024/5/28 10:47 PM
+ * @Author Alan // 作者信息
+ * @Version // 版本信息（此处未填写具体内容）
+ * @Date 2024/5/28 10:47 PM // 创建时间
  */
-public interface UserDailyLoginDurationMapper extends BaseMapper<UserDailyLoginDuration> {
-    List<DailyVO>  getDaily(Integer userId);
-}
+public interface UserDailyLoginDurationMapper extends BaseMapper<UserDailyLoginDuration> { // 定义UserDailyLoginDurationMapper接口，继承BaseMapper<UserDailyLoginDuration>，提供对UserDailyLoginDuration实体的基础CRUD操作
+
+    /**
+     * 根据用户ID获取用户的每日登录时长统计信息
+     *
+     * @param userId 用户ID，用于指定要查询的用户
+     * @return 返回DailyVO对象列表，包含用户的每日登录时长统计信息
+     */
+    List<DailyVO> getDaily(Integer userId); // 自定义查询方法，根据用户ID获取用户的每日登录时长统计信息，并封装为DailyVO对象列表返回
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/UserExamsScoreMapper.java b/src/main/java/cn/org/alan/exam/mapper/UserExamsScoreMapper.java
index 3ed049c..9d31fd8 100644
--- a/src/main/java/cn/org/alan/exam/mapper/UserExamsScoreMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/UserExamsScoreMapper.java
@@ -1,66 +1,83 @@
-package cn.org.alan.exam.mapper;
+package cn.org.alan.exam.mapper; // 定义UserExamsScoreMapper接口所在的包路径
 
-import cn.org.alan.exam.model.entity.UserExamsScore;
-import cn.org.alan.exam.model.vo.answer.UncorrectedUserVO;
-import cn.org.alan.exam.model.vo.score.ExportScoreVO;
-import cn.org.alan.exam.model.vo.score.GradeScoreVO;
-import cn.org.alan.exam.model.vo.score.UserScoreVO;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
+// 引入相关的实体类和视图对象
+import cn.org.alan.exam.model.entity.UserExamsScore; // 引入UserExamsScore实体类，表示用户的考试成绩
+import cn.org.alan.exam.model.vo.answer.UncorrectedUserVO; // 引入UncorrectedUserVO视图对象，用于封装未考试用户的信息
+import cn.org.alan.exam.model.vo.score.ExportScoreVO; // 引入ExportScoreVO视图对象，用于导出考试成绩
+import cn.org.alan.exam.model.vo.score.GradeScoreVO; // 引入GradeScoreVO视图对象，用于封装班级用户的成绩分析信息
+import cn.org.alan.exam.model.vo.score.UserScoreVO; // 引入UserScoreVO视图对象，用于封装分页查询的用户成绩信息
 
-import java.util.List;
+// 引入MyBatis Plus的相关类
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入BaseMapper接口，提供基础的CRUD操作
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入IPage接口，用于分页查询
+
+import java.util.List; // 引入Java的List接口，用于定义返回结果类型或传递参数类型
 
 /**
  * <p>
- * Mapper 接口
+ * Mapper 接口，用于定义UserExamsScore相关的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 作者信息
+ * @since 2024-03-21 // 创建时间
  */
-public interface UserExamsScoreMapper extends BaseMapper<UserExamsScore> {
+public interface UserExamsScoreMapper extends BaseMapper<UserExamsScore> { // 定义UserExamsScoreMapper接口，继承BaseMapper<UserExamsScore>，提供对UserExamsScore实体的基础CRUD操作
 
     /**
      * 考试班级用户成绩分析
-     * @param page 分页信息
-     * @param gradeId 班级Id
-     * @param examTitle 考试名称
-     * @param userId 用户Id
-     * @param roleId 角色Id
-     * @return 结果
+     *
+     * @param page 分页信息，包含分页参数和查询结果类型
+     * @param gradeId 班级Id，用于指定要分析的班级
+     * @param examTitle 考试名称，用于指定要分析的考试
+     * @param userId 用户Id，用于指定要分析的用户（可能为null，表示分析所有用户）
+     * @param roleId 角色Id，可能用于权限控制或指定分析范围（具体含义需结合业务逻辑）
+     * @return 返回分页查询结果，包含班级用户的成绩分析信息
      */
-    IPage<GradeScoreVO> scoreStatistics(IPage<GradeScoreVO> page ,Integer gradeId, String examTitle,Integer userId,Integer roleId);
+    IPage<GradeScoreVO> scoreStatistics(IPage<GradeScoreVO> page, Integer gradeId, String examTitle, Integer userId, Integer roleId);
 
     /**
      * 成绩分页查询
      *
-     * @param page     分页信息
-     * @param gradeId  班级Id
-     * @param examId   考试Id
-     * @param realName 真实姓名
-     * @return 查询结果集
+     * @param page 分页信息，包含分页参数和查询结果类型
+     * @param gradeId 班级Id，用于指定要查询成绩的班级
+     * @param examId 考试Id，用于指定要查询成绩的考试
+     * @param realName 真实姓名，用于指定要查询成绩的用户（可能为null，表示查询所有用户）
+     * @return 返回分页查询结果，包含用户成绩信息
      */
     IPage<UserScoreVO> pagingScore(IPage<UserScoreVO> page, Integer gradeId, Integer examId, String realName);
 
+    /**
+     * 获取报考人数
+     *
+     * @param examId 考试Id，用于指定要查询报考人数的考试
+     * @return 返回报考人数
+     */
     Integer getNumberOfApplicants(Integer examId);
 
+    /**
+     * 获取已阅卷人数
+     *
+     * @param examId 考试Id，用于指定要查询已阅卷人数的考试
+     * @return 返回已阅卷人数
+     */
     Integer getCorrectedPaper(Integer examId);
 
     /**
-     * 获取成绩
+     * 获取成绩列表
      *
-     * @param examId  考试id
-     * @param gradeId 班级id
-     * @return 查询结果
+     * @param examId 考试id，用于指定要查询成绩的考试
+     * @param gradeId 班级id，用于指定要查询成绩的班级（可能为null，表示查询所有班级）
+     * @return 返回成绩列表，包含考试id和班级id对应的所有学生成绩信息
      */
     List<ExportScoreVO> selectScores(Integer examId, Integer gradeId);
 
     /**
      * 根据考试id获取未考试用户
      *
-     * @param page   分页信息
-     * @param examId 考试id
-     * @return 查询结果
+     * @param page 分页信息，包含分页参数和查询结果类型
+     * @param examId 考试id，用于指定要查询未考试用户的考试
+     * @param realName 真实姓名，用于指定要查询未考试用户的姓名（可能为null，表示查询所有未考试用户）
+     * @return 返回分页查询结果，包含未考试用户的信息
      */
-    IPage<UncorrectedUserVO> uncorrectedUser(IPage<UncorrectedUserVO> page, Integer examId,String realName);
-}
+    IPage<UncorrectedUserVO> uncorrectedUser(IPage<UncorrectedUserVO> page, Integer examId, String realName);
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/UserExerciseRecordMapper.java b/src/main/java/cn/org/alan/exam/mapper/UserExerciseRecordMapper.java
index 19462a5..a116803 100644
--- a/src/main/java/cn/org/alan/exam/mapper/UserExerciseRecordMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/UserExerciseRecordMapper.java
@@ -1,16 +1,24 @@
+// 定义UserExerciseRecordMapper接口所在的包路径
 package cn.org.alan.exam.mapper;
 
+// 引入UserExerciseRecord实体类，该类表示用户的练习记录
 import cn.org.alan.exam.model.entity.UserExerciseRecord;
+
+// 引入MyBatis Plus的BaseMapper接口，它提供了基础的CRUD操作
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
 /**
  * <p>
- *  Mapper 接口
+ *  Mapper 接口，用于定义UserExerciseRecord相关的数据库操作
+ * </p>
+ * <p>
+ * 该接口继承自BaseMapper<UserExerciseRecord>，因此自动拥有了UserExerciseRecord实体的基础CRUD操作方法
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 作者信息
+ * @since 2024-03-21 // 接口创建时间
  */
 public interface UserExerciseRecordMapper extends BaseMapper<UserExerciseRecord> {
-
-}
+    // 此处为空，因为该接口仅继承了BaseMapper，未定义额外的方法。
+    // 若需要自定义数据库操作方法，可在此处添加。
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/mapper/UserMapper.java b/src/main/java/cn/org/alan/exam/mapper/UserMapper.java
index 8694f11..dc913b4 100644
--- a/src/main/java/cn/org/alan/exam/mapper/UserMapper.java
+++ b/src/main/java/cn/org/alan/exam/mapper/UserMapper.java
@@ -1,34 +1,43 @@
+// 定义UserMapper接口所在的包路径
 package cn.org.alan.exam.mapper;
 
+// 引入User实体类，代表用户信息
 import cn.org.alan.exam.model.entity.User;
+// 引入ClassCountResult类，用于统计和分组的结果
 import cn.org.alan.exam.model.form.count.ClassCountResult;
+// 引入UserVO类，用于视图层展示的用户信息
 import cn.org.alan.exam.model.vo.UserVO;
+// 引入MyBatis Plus的BaseMapper接口，提供基础的CRUD操作
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 引入MyBatis Plus的IPage接口，用于分页查询
 import com.baomidou.mybatisplus.core.metadata.IPage;
+// 引入Spring的Repository注解，标记这是一个持久层组件
 import org.springframework.stereotype.Repository;
 
-
 import java.util.List;
 
 /**
  * <p>
- * Mapper 接口
+ * Mapper 接口，用于定义User相关的数据库操作
  * </p>
  *
- * @author WeiJin
- * @since 2024-03-21
+ * @author WeiJin // 作者信息
+ * @since 2024-03-21 // 接口创建时间
  */
-@Repository
-public interface UserMapper extends BaseMapper<User> {
+@Repository // 标记为Spring的Repository组件
+public interface UserMapper extends BaseMapper<User> { // 继承BaseMapper<User>，提供User的基础CRUD操作
 
+    // 已被注释的方法，原意是根据id获取用户列表（但通常id应唯一，此处逻辑可能有误）
     // List<User> getText(Integer id);
+
+    // 根据用户ID列表删除用户等级信息（注意：方法名可能不完全准确反映其功能，需根据业务逻辑确认）
     Integer removeUserGrade(List<Integer> userIds);
 
     /**
      * 批量添加用户
      *
-     * @param list
-     * @return
+     * @param list 用户列表
+     * @return 影响的数据库记录数
      */
     Integer insertBatchUser(List<User> list);
 
@@ -36,40 +45,51 @@ public interface UserMapper extends BaseMapper<User> {
      * 获取用户信息
      *
      * @param userId 用户id
-     * @return 响应
+     * @return UserVO对象，包含视图层所需的用户信息
      */
     UserVO info(Integer userId);
 
     /**
-     * 根据班级Id获取该班级学生Id
+     * 根据班级Id获取该班级所有学生的Id
      *
      * @param classId 班级Id
-     * @return 结果集
+     * @return 学生Id列表
      */
     List<Integer> selectIdsByClassId(Integer classId);
 
     /**
      * 分页获取用户信息
      *
-     * @param page     分页信息
-     * @param gradeId  班级Id
-     * @param realName 真实姓名
-     * @param roleId   角色Id
-     * @return 查询结果集
+     * @param page     分页信息，包含页码、每页记录数等
+     * @param gradeId  班级Id，用于筛选
+     * @param realName 真实姓名，用于筛选
+     * @param userId   用户Id，用于筛选（注意：与removeUserGrade方法中的userIds不同，此处为单个用户Id）
+     * @param roleId   角色Id，用于筛选
+     * @return 分页查询结果集，包含用户信息和分页信息
      */
-    IPage<UserVO> pagingUser(IPage<UserVO> page, Integer gradeId, String realName,Integer userId, Integer roleId);
-
-
+    IPage<UserVO> pagingUser(IPage<UserVO> page, Integer gradeId, String realName, Integer userId, Integer roleId);
 
     /**
-     * 移除班级
+     * 移除班级（注意：方法名可能不完全准确反映其功能，根据参数应为根据班级Id列表删除班级信息）
+     *
      * @param gradeIds 班级id列表
      * @return 影响数据库记录数
      */
     Integer removeGradeIdByGradeIds(List<Integer> gradeIds);
 
+    /**
+     * 根据角色Id统计并分组班级和学生数量
+     *
+     * @param roleId 角色Id
+     * @return 统计结果列表，每个元素包含班级Id、角色Id和对应的数量
+     */
     List<ClassCountResult> countAndGroupByGradeAndRoleId(Integer roleId);
 
-
+    /**
+     * 根据用户Id列表删除用户
+     *
+     * @param userIds 用户Id列表
+     * @return 影响数据库记录数
+     */
     Integer deleteByUserIds(List<Integer> userIds);
-}
+}
\ No newline at end of file
-- 
2.34.1


From 75a12190b99693ce503ef8f62b093e1acf60ad95 Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Wed, 18 Dec 2024 16:37:49 +0800
Subject: [PATCH 06/10] main1122

---
 .../exam/service/impl/GradeServiceImpl.java   | 138 +++++++++-----
 .../service/impl/ManualScoreServiceImpl.java  |  95 +++++++---
 .../service/impl/NoticeGradeServiceImpl.java  |  15 +-
 .../exam/service/impl/NoticeServiceImpl.java  | 169 ++++++++++--------
 4 files changed, 271 insertions(+), 146 deletions(-)

diff --git a/src/main/java/cn/org/alan/exam/service/impl/GradeServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/GradeServiceImpl.java
index eb9bb3e..f0c50e5 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/GradeServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/GradeServiceImpl.java
@@ -40,177 +40,223 @@ import java.util.stream.Collectors;
  */
 @Service
 public class GradeServiceImpl extends ServiceImpl<GradeMapper, Grade> implements IGradeService {
+    // 注入GradeMapper，用于操作班级数据的持久层接口
     @Resource
     private GradeMapper gradeMapper;
+    // 注入ExamMapper，可能用于操作考试相关数据的持久层接口（此处从命名推测）
     @Resource
     private ExamMapper examMapper;
+    // 注入QuestionMapper，可能用于操作题目相关数据的持久层接口（此处从命名推测）
     @Resource
     private QuestionMapper questionMapper;
+    // 注入GradeConverter，用于不同班级相关对象之间的转换（比如表单对象和实体对象等）
     @Resource
     private GradeConverter gradeConverter;
+    // 注入UserMapper，用于操作用户相关数据的持久层接口
     @Resource
     private UserMapper userMapper;
+    // 注入IGradeService，自身接口注入，可能用于调用自身定义的其他服务方法（此处从代码结构推测）
     @Resource
     private IGradeService gradeService;
+    // 注入StringRedisTemplate，用于操作Redis字符串类型数据，常用于缓存相关操作
     @Resource
     private StringRedisTemplate stringRedisTemplate;
+    // 注入CacheClient，自定义的缓存客户端，用于更方便地进行缓存操作
     @Resource
     private CacheClient cacheClient;
 
+    // 添加班级的方法，事务性操作，成功返回添加成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> addGrade(GradeForm gradeForm) {
-        // 生成班级口令
+        // 生成班级口令，调用工具类方法生成一个长度为18的班级口令
         gradeForm.setCode(ClassTokenGenerator.generateClassToken(18));
-        // 实体转换
+        // 将GradeForm对象转换为Grade实体对象，方便后续持久化操作
         Grade grade = gradeConverter.formToEntity(gradeForm);
-        // 添加数据
+        // 调用gradeMapper的insert方法将班级数据插入到数据库中，返回受影响的行数
         int rows = gradeMapper.insert(grade);
+        // 如果插入操作没有影响到任何行，即插入失败，返回添加失败的结果信息
         if (rows == 0) {
             return Result.failed("添加失败");
         }
-        // 更新缓存
-        if (grade.getId() != null) { // 确保ID有效
-            // 如果是更新操作，先从缓存中移除旧数据，然后重新放入最新的数据
-            stringRedisTemplate.delete("cache:grade:getPaging:"+grade.getId().toString()); // 删除旧缓存
+        // 如果插入成功，班级数据有了有效的ID（这里假设插入后会自动生成ID），进行缓存相关操作
+        if (grade.getId()!= null) { // 确保ID有效
+            // 如果是更新操作（此处逻辑可能不太准确，实际上是添加操作，但代码结构类似更新时的缓存处理逻辑），先从缓存中移除旧数据
+            // 根据班级ID删除对应的缓存数据，缓存键格式为"cache:grade:getPaging:" + 班级ID
+            stringRedisTemplate.delete("cache:grade:getPaging:" + grade.getId().toString());
             // GradeVO updatedGradeVO = gradeConverter.GradeToGradeVO(grade); // 转换为视图对象
             // Map<Integer, GradeVO> map = Map.of(updatedGradeVO.getId(), updatedGradeVO);
             // cacheClient.batchPut("cache:grade:getPaging:",map,10L,TimeUnit.MINUTES); // 存储新数据
         }
-        stringRedisTemplate.delete("cache:grade:getAllGrade:"+SecurityUtil.getUserId());
+        // 根据当前用户ID删除获取所有班级的缓存数据，缓存键格式为"cache:grade:getAllGrade:" + 当前用户ID
+        stringRedisTemplate.delete("cache:grade:getAllGrade:" + SecurityUtil.getUserId());
+        // 返回添加成功的结果信息
         return Result.success("添加成功");
     }
 
+    // 更新班级信息的方法，事务性操作，成功返回更新成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> updateGrade(Integer id, GradeForm gradeForm) {
-        // 建立更新条件
+        // 创建一个LambdaUpdateWrapper对象，用于构建更新班级信息的条件和要更新的字段
         LambdaUpdateWrapper<Grade> gradeUpdateWrapper = new LambdaUpdateWrapper<>();
+        // 设置要更新的班级名称字段，值为传入的gradeForm中的班级名称
         gradeUpdateWrapper
                 .set(Grade::getGradeName, gradeForm.getGradeName())
+                // 设置更新条件为班级ID等于传入的id参数
                 .eq(Grade::getId, id);
-        // 更新班级
+        // 调用gradeMapper的update方法，根据上面构建的更新条件和要更新的字段来更新班级数据，返回受影响的行数
         int rows = gradeMapper.update(gradeUpdateWrapper);
+        // 如果更新操作没有影响到任何行，即更新失败，返回修改失败的结果信息
         if (rows == 0) {
             return Result.failed("修改失败");
         }
+        // 根据ID获取更新后的班级对象，用于后续缓存操作等（可能需要获取最新数据来更新缓存等）
         Grade byId = getById(id);
-        // 更新缓存
-        if (byId.getId() != null) { // 确保ID有效
-            // 如果是更新操作，先从缓存中移除旧数据，然后重新放入最新的数据
-            stringRedisTemplate.delete("cache:grade:getPaging:"+byId.getId().toString()); // 删除旧缓存
+        // 如果获取到的班级对象有有效的ID，进行缓存相关操作
+        if (byId.getId()!= null) { // 确保ID有效
+            // 如果是更新操作，先从缓存中移除旧数据，根据班级ID删除对应的缓存数据，缓存键格式为"cache:grade:getPaging:" + 班级ID
+            stringRedisTemplate.delete("cache:grade:getPaging:" + byId.getId().toString());
             // GradeVO updatedGradeVO = gradeConverter.GradeToGradeVO(byId); // 转换为视图对象
             // Map<Integer, GradeVO> map = Map.of(updatedGradeVO.getId(), updatedGradeVO);
             // cacheClient.batchPut("cache:grade:getPaging:",map,10L,TimeUnit.MINUTES); // 存储新数据
         }
-        stringRedisTemplate.delete("cache:grade:getAllGrade:"+SecurityUtil.getUserId());
+        // 根据当前用户ID删除获取所有班级的缓存数据，缓存键格式为"cache:grade:getAllGrade:" + 当前用户ID
+        stringRedisTemplate.delete("cache:grade:getAllGrade:" + SecurityUtil.getUserId());
+        // 返回更新成功的结果信息
         return Result.success("修改成功");
     }
 
+    // 删除班级的方法，事务性操作，成功返回删除成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> deleteGrade(Integer id) {
-        // 删除班级
+        // 创建一个LambdaUpdateWrapper对象，用于构建删除班级的逻辑（这里实际是逻辑删除，设置删除标记字段）
         LambdaUpdateWrapper<Grade> gradeLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
-        gradeLambdaUpdateWrapper.eq(Grade::getId,id)
-                .set(Grade::getIsDeleted,1);
+        // 设置更新条件为班级ID等于传入的id参数
+        gradeLambdaUpdateWrapper.eq(Grade::getId, id)
+                // 设置班级的删除标记字段（假设名为isDeleted）为1，表示已删除
+                .set(Grade::getIsDeleted, 1);
+        // 调用gradeMapper的update方法，根据上面构建的更新条件来执行逻辑删除操作，返回受影响的行数
         int rows = gradeMapper.update(gradeLambdaUpdateWrapper);
+        // 如果删除操作没有影响到任何行，即删除失败，返回删除失败的结果信息
         if (rows == 0) {
             return Result.failed("删除失败");
         }
-        // 删除缓存
-        stringRedisTemplate.delete("cache:grade:getPaging:"+id.toString());
-        stringRedisTemplate.delete("cache:grade:getAllGrade:"+SecurityUtil.getUserId());
+        // 根据班级ID删除对应的缓存数据，缓存键格式为"cache:grade:getPaging:" + 班级ID
+        stringRedisTemplate.delete("cache:grade:getPaging:" + id.toString());
+        // 根据当前用户ID删除获取所有班级的缓存数据，缓存键格式为"cache:grade:getAllGrade:" + 当前用户ID
+        stringRedisTemplate.delete("cache:grade:getAllGrade:" + SecurityUtil.getUserId());
+        // 返回删除成功的结果信息
         return Result.success("删除成功");
     }
 
+    // 获取班级分页数据的方法，返回包含分页信息和班级视图对象列表的结果
     @Override
     public Result<IPage<GradeVO>> getPaging(Integer pageNum, Integer pageSize, String gradeName) {
+        // 初始化角色变量，默认为0，这里可能根据不同角色有不同的查询逻辑（从后续代码推测）
         Integer role = 0;
-        if("role_teacher".equals(SecurityUtil.getRole())){
+        // 如果当前用户角色为"role_teacher"，则将角色设置为2（具体角色值含义根据业务定义）
+        if ("role_teacher".equals(SecurityUtil.getRole())) {
             role = 2;
         }
-        // 查询满足条件的总记录数
-        int total = gradeMapper.countByCondition(SecurityUtil.getUserId(), gradeName,role); // 假设gradeMapper中实现了根据条件计数的方法
-        // 计算偏移量
+        // 调用gradeMapper的countByCondition方法，根据当前用户ID、班级名称和角色来统计满足条件的班级总记录数（假设gradeMapper中实现了该方法）
+        int total = gradeMapper.countByCondition(SecurityUtil.getUserId(), gradeName, role);
+        // 计算分页查询的偏移量，根据当前页码和每页显示数量来计算
         int offset = (pageNum - 1) * pageSize;
 
-        // 查询分页ID列表
-        List<Integer> gradeIds = gradeMapper.selectGradeIdsPage(SecurityUtil.getUserId(), role ,gradeName, offset, pageSize);
+        // 调用gradeMapper的selectGradeIdsPage方法，根据当前用户ID、角色、班级名称以及偏移量和每页显示数量来查询分页的班级ID列表（假设gradeMapper中实现了该方法）
+        List<Integer> gradeIds = gradeMapper.selectGradeIdsPage(SecurityUtil.getUserId(), role, gradeName, offset, pageSize);
 
-        // 批量从缓存中获取GradeVO对象
-        Map<Integer, GradeVO> cachedGradesMap = cacheClient.batchGet("cache:grade:getPaging:",gradeIds, GradeVO.class);
+        // 使用cacheClient的batchGet方法，从缓存中批量获取对应班级ID的GradeVO对象，缓存键前缀为"cache:grade:getPaging:"
+        Map<Integer, GradeVO> cachedGradesMap = cacheClient.batchGet("cache:grade:getPaging:", gradeIds, GradeVO.class);
 
-        // 确定未命中的ID列表
+        // 创建一个列表，用于存储在缓存中未命中的班级ID，即缓存中不存在对应数据的班级ID
         List<Integer> missIds = new ArrayList<>();
+        // 遍历查询到的班级ID列表，检查每个ID在缓存中是否存在，如果不存在则添加到未命中ID列表中
         for (Integer id : gradeIds) {
             if (!cachedGradesMap.containsKey(id)) {
                 missIds.add(id);
             }
         }
 
-        // 如果有未命中的ID，从数据库批量查询并更新缓存
+        // 如果存在未命中缓存的班级ID，即missIds列表不为空
         if (!missIds.isEmpty()) {
+            // 调用gradeMapper的batchSelectByIds方法，从数据库中批量查询未命中缓存的班级数据，并转换为GradeVO对象列表（假设gradeMapper中实现了该方法）
             List<GradeVO> missedGrades = gradeMapper.batchSelectByIds(missIds);
-            // 假设GradeVO的ID为getId()，使用Collectors.toMap转换
+            // 使用Java 8的Stream API，将GradeVO对象列表转换为以班级ID为键，GradeVO对象为值的Map，方便后续操作
             Map<Integer, GradeVO> missedGradesMap = missedGrades.stream()
                     .collect(Collectors.toMap(GradeVO::getId, Function.identity()));
-            // 更新缓存
-            cacheClient.batchPut("cache:grade:getPaging:",missedGradesMap,10L,TimeUnit.MINUTES);
-            // 合并缓存结果
+            // 使用cacheClient的batchPut方法，将从数据库中查询到的未命中缓存的班级数据更新到缓存中，缓存有效期为10分钟
+            cacheClient.batchPut("cache:grade:getPaging:", missedGradesMap, 10L, TimeUnit.MINUTES);
+            // 将从数据库中查询到的未命中缓存的班级数据合并到缓存结果的Map中，确保缓存数据的完整性
             cachedGradesMap.putAll(missedGradesMap);
         }
 
-        // 根据ID列表从缓存中获取完整的GradeVO对象列表
+        // 创建一个列表，用于存储最终要返回的完整的GradeVO对象列表，初始大小为查询到的班级ID列表的大小
         List<GradeVO> finalResult = new ArrayList<>(gradeIds.size());
+        // 遍历班级ID列表，从缓存结果的Map中获取对应的GradeVO对象，并添加到最终结果列表中
         for (Integer id : gradeIds) {
             finalResult.add(cachedGradesMap.get(id));
         }
 
-        // 构建并返回IPage对象
+        // 创建一个IPage对象，用于封装分页信息和最终的班级视图对象列表，设置当前页码、每页显示数量以及总记录数
         IPage<GradeVO> resultPage = new Page<>(pageNum, pageSize, Long.valueOf(total));
+        // 将最终的班级视图对象列表设置到IPage对象中
         resultPage.setRecords(finalResult);
 
+        // 返回包含分页信息和班级视图对象列表的成功结果信息
         return Result.success("查询成功", resultPage);
     }
 
+    // 移除用户班级关联的方法，成功返回移除成功的提示信息，失败返回相应错误提示
     @Override
     public Result<String> removeUserGrade(String ids) {
-        // 字符串转换为列表
+        // 将传入的以逗号分隔的字符串形式的用户ID列表转换为Integer类型的列表，使用Java 8的Stream API进行转换
         List<Integer> userIds = Arrays.stream(ids.split(","))
                 .map(Integer::parseInt)
                 .toList();
-        // 移出班级
+        // 调用userMapper的removeUserGrade方法，根据用户ID列表移除用户与班级的关联关系，返回受影响的行数（假设userMapper中实现了该方法）
         int rows = userMapper.removeUserGrade(userIds);
+        // 如果移除操作没有影响到任何行，即移除失败，返回移除失败的结果信息
         if (rows == 0) {
             return Result.failed("移除失败");
         }
-        userIds.forEach(id->{
-            stringRedisTemplate.delete("cache:grade:getPaging:"+id.toString());
+        // 遍历用户ID列表，根据每个用户ID删除对应的获取班级分页数据的缓存（这里的逻辑可能需要根据实际业务进一步确认是否合理）
+        userIds.forEach(id -> {
+            stringRedisTemplate.delete("cache:grade:getPaging:" + id.toString());
         });
 
+        // 返回移除成功的结果信息
         return Result.success("移除成功");
     }
 
+    // 获取所有班级信息的方法，返回包含所有班级视图对象列表的结果
     @Override
     public Result<List<GradeVO>> getAllGrade() {
+        // 创建一个匿名内部类实现Function接口，用于定义从用户ID获取班级视图对象列表的逻辑
         Function<Integer, List> function = new Function<>() {
             @Override
             public List apply(Integer userId) {
+                // 创建一个LambdaQueryWrapper对象，用于构建查询班级信息的条件，这里查询当前用户ID下未删除的班级（假设isDeleted字段表示是否删除）
                 LambdaQueryWrapper<Grade> gradeLambdaQueryWrapper = new LambdaQueryWrapper<>();
                 gradeLambdaQueryWrapper.eq(Grade::getUserId, userId)
-                        .eq(Grade::getIsDeleted,0);
+                        .eq(Grade::getIsDeleted, 0);
+                // 调用gradeMapper的selectList方法，根据上面构建的查询条件获取班级实体对象列表
                 List<Grade> grades = gradeMapper.selectList(gradeLambdaQueryWrapper);
+                // 使用gradeConverter的listEntityToVo方法，将班级实体对象列表转换为班级视图对象列表
                 List<GradeVO> gradeVOS = gradeConverter.listEntityToVo(grades);
+                // 返回班级视图对象列表
                 return gradeVOS;
             }
         };
+        // 使用cacheClient的queryWithPassThrough方法，通过缓存穿透机制获取所有班级信息，缓存键前缀为"cache:grade:getAllGrade:"，传入当前用户ID、期望返回的类型、查询逻辑函数、返回对象类型、缓存有效期等参数
         List<GradeVO> result = cacheClient.queryWithPassThrough("cache:grade:getAllGrade:", SecurityUtil.getUserId(), List.class, function, GradeVO.class, 10L, TimeUnit.MINUTES);
-        if(result==null){
+        // 如果获取结果为null，即查询失败，返回查询失败的结果信息
+        if (result == null) {
             return Result.failed("查询失败");
         }
+        // 返回包含所有班级视图对象列表的成功结果信息
         return Result.success("查询成功", result);
     }
-
-}
-
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/ManualScoreServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/ManualScoreServiceImpl.java
index 36257a5..342b501 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/ManualScoreServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/ManualScoreServiceImpl.java
@@ -23,134 +23,177 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
-
 /**
  * <p>
  * 服务实现类
  * </p>
- *
  * @author WeiJin
  * @since 2024-03-21
  */
 @Service
 public class ManualScoreServiceImpl extends ServiceImpl<ManualScoreMapper, ManualScore> implements IManualScoreService {
 
+    // 注入ExamMapper，用于操作考试相关数据的持久层接口（从命名推测其功能）
     @Resource
     private ExamMapper examMapper;
+    // 注入ExamGradeMapper，可能用于操作考试与班级关联相关数据的持久层接口（根据命名推测）
     @Resource
     private ExamGradeMapper examGradeMapper;
+    // 注入UserExamsScoreMapper，用于操作用户考试成绩相关数据的持久层接口（推测用途）
     @Resource
     private UserExamsScoreMapper userExamsScoreMapper;
+    // 注入ExamQuAnswerMapper，可能用于操作考试题目作答相关数据的持久层接口（从名字判断）
     @Resource
     private ExamQuAnswerMapper examQuAnswerMapper;
+    // 注入ManualScoreMapper，用于操作手动评分相关数据的持久层接口（对应业务功能）
     @Resource
     private ManualScoreMapper manualScoreMapper;
+    // 注入CertificateUserMapper，可能用于操作证书与用户关联相关数据的持久层接口（依据命名猜测）
     @Resource
     private CertificateUserMapper certificateUserMapper;
 
-
+    // 获取用户答题详情的方法，根据用户ID和考试ID从数据库获取相关答题详情信息并返回
     @Override
     public Result<List<UserAnswerDetailVO>> getDetail(Integer userId, Integer examId) {
+        // 调用examQuAnswerMapper的selectUserAnswer方法，传入用户ID和考试ID，获取用户答题详情列表
         List<UserAnswerDetailVO> list = examQuAnswerMapper.selectUserAnswer(userId, examId);
+        // 返回包含答题详情列表的成功结果信息，这里第一个参数为null，可能是预留用于传递其他提示信息等情况
         return Result.success(null, list);
     }
 
-
+    // 批改答题的方法，事务性操作，用于处理答题批改相关逻辑，包括记录手动评分、更新用户考试记录、颁发证书等操作
     @Override
     @Transactional
     public Result<String> correct(List<CorrectAnswerFrom> correctAnswerFroms) {
+        // 创建一个ManualScore类型的列表，用于存储要插入数据库的手动评分记录，初始大小为传入的答题批改表单列表的大小
         List<ManualScore> list = new ArrayList<>(correctAnswerFroms.size());
+        // 创建一个AtomicInteger对象，用于原子性地累加手动评分的总分，方便在多线程环境下安全地更新总分（虽然此处可能并非多线程场景，但使用它保证操作的原子性）
         AtomicInteger manualTotalScore = new AtomicInteger();
+
+        // 遍历传入的答题批改表单列表，处理每个答题的批改信息
         correctAnswerFroms.forEach(correctAnswerFrom -> {
 
-            //获取用户作答信息id
+            // 创建一个LambdaQueryWrapper对象，用于构建查询考试题目作答信息的条件，这里只选择作答信息的ID字段
             LambdaQueryWrapper<ExamQuAnswer> wrapper = new LambdaQueryWrapper<ExamQuAnswer>()
                     .select(ExamQuAnswer::getId)
+                    // 设置查询条件为考试ID等于当前答题批改表单中的考试ID
                     .eq(ExamQuAnswer::getExamId, correctAnswerFrom.getExamId())
+                    // 设置查询条件为用户ID等于当前答题批改表单中的用户ID
                     .eq(ExamQuAnswer::getUserId, correctAnswerFrom.getUserId())
+                    // 设置查询条件为题目ID等于当前答题批改表单中的题目ID
                     .eq(ExamQuAnswer::getQuestionId, correctAnswerFrom.getQuestionId());
 
+            // 创建一个ManualScore对象，用于存储当前答题的手动评分记录信息
             ManualScore manualScore = new ManualScore();
+            // 设置手动评分记录中的考试题目作答信息ID，通过查询获取对应的作答信息ID并设置
             manualScore.setExamQuAnswerId(examQuAnswerMapper.selectOne(wrapper).getId());
+            // 设置手动评分记录中的分数，值为当前答题批改表单中的分数
             manualScore.setScore(correctAnswerFrom.getScore());
+            // 将当前手动评分记录添加到列表中，后续批量插入数据库
             list.add(manualScore);
+            // 原子性地累加当前答题的分数到总分中
             manualTotalScore.addAndGet(correctAnswerFrom.getScore());
         });
+
+        // 调用manualScoreMapper的insertList方法，将整理好的手动评分记录列表批量插入到数据库中
         manualScoreMapper.insertList(list);
 
-        //把用户考试记录修改为已批改，并把简答题分数添加进去
+        // 把用户考试记录修改为已批改，并把简答题分数添加进去
+        // 获取答题批改表单列表中的第一个表单对象，用于后续构建更新用户考试记录的条件（这里假设所有表单对应的考试和用户是相同的，若不同则逻辑可能需要调整）
         CorrectAnswerFrom correctAnswerFrom = correctAnswerFroms.get(0);
+        // 创建一个LambdaUpdateWrapper对象，用于构建更新用户考试成绩记录的条件和要更新的字段
         LambdaUpdateWrapper<UserExamsScore> userExamsScoreLambdaUpdateWrapper = new LambdaUpdateWrapper<UserExamsScore>()
+                // 设置更新条件为考试ID等于当前答题批改表单中的考试ID
                 .eq(UserExamsScore::getExamId, correctAnswerFrom.getExamId())
+                // 设置更新条件为用户ID等于当前答题批改表单中的用户ID
                 .eq(UserExamsScore::getUserId, correctAnswerFrom.getUserId())
+                // 设置要更新的字段为是否已批改标记为1，表示已批改
                 .set(UserExamsScore::getWhetherMark, 1)
+                // 使用SQL语句设置更新用户成绩，将原用户成绩加上手动评分的总分（这里使用了原生SQL语句拼接，可能存在SQL注入风险，若有安全需求可考虑参数化方式）
                 .setSql("user_score = user_score + " + manualTotalScore.get());
+        // 调用userExamsScoreMapper的update方法，根据构建的更新条件和字段来更新用户考试成绩记录
         userExamsScoreMapper.update(userExamsScoreLambdaUpdateWrapper);
 
-        //根据该考试是否有证书来给用户颁发对应证书
-        //判断该考试是否有证书
+        // 根据该考试是否有证书来给用户颁发对应证书
+        // 判断该考试是否有证书
         LambdaQueryWrapper<Exam> examWrapper = new LambdaQueryWrapper<Exam>()
+                // 选择查询考试的ID、证书ID以及及格分数字段
                 .select(Exam::getId, Exam::getCertificateId, Exam::getPassedScore)
+                // 设置查询条件为考试ID等于当前答题批改表单中的考试ID
                 .eq(Exam::getId, correctAnswerFrom.getExamId());
+        // 调用examMapper的selectOne方法，根据构建的查询条件获取对应的考试信息对象
         Exam exam = examMapper.selectOne(examWrapper);
-        //不必对exam做非空验证，这里一定不为null
-        if (exam.getCertificateId() != null && exam.getCertificateId() > 0) {
-            //有证书 获取用户得分
+        // 不必对exam做非空验证，这里一定不为null（此处根据代码逻辑的前置假设，认为该查询必然能获取到数据，如果实际情况可能为空则需要添加空值判断处理）
+        if (exam.getCertificateId()!= null && exam.getCertificateId() > 0) {
+            // 有证书 获取用户得分
             LambdaQueryWrapper<UserExamsScore> examsScoreWrapper = new LambdaQueryWrapper<UserExamsScore>()
+                    // 选择查询用户考试成绩记录的ID和用户分数字段
                     .select(UserExamsScore::getId, UserExamsScore::getUserScore)
+                    // 设置查询条件为考试ID等于当前答题批改表单中的考试ID
                     .eq(UserExamsScore::getExamId, correctAnswerFrom.getExamId())
+                    // 设置查询条件为用户ID等于当前答题批改表单中的用户ID
                     .eq(UserExamsScore::getUserId, correctAnswerFrom.getUserId());
+            // 调用userExamsScoreMapper的selectOne方法，根据构建的查询条件获取对应的用户考试成绩记录对象
             UserExamsScore userExamsScore = userExamsScoreMapper.selectOne(examsScoreWrapper);
-            //不必对userExamsScore做非空验证，这里一定不为null
+            // 不必对userExamsScore做非空验证，这里一定不为null（同样基于前置假设，如果实际可能为空需处理）
             if (userExamsScore.getUserScore() >= exam.getPassedScore()) {
-                //分数合格，判罚证书
+                // 分数合格，判罚证书（这里可能是“颁发”证书的意思，疑似笔误写为“判罚”，以下按颁发理解）
                 CertificateUser certificateUser = new CertificateUser();
                 certificateUser.setUserId(correctAnswerFrom.getUserId());
                 certificateUser.setExamId(correctAnswerFrom.getExamId());
                 certificateUser.setCode(ClassTokenGenerator.generateClassToken(18));
                 certificateUser.setCertificateId(exam.getCertificateId());
+                // 调用certificateUserMapper的insert方法，将生成的证书与用户关联信息插入到数据库中，完成证书颁发操作
                 certificateUserMapper.insert(certificateUser);
             }
 
         }
+        // 返回批改成功的结果信息
         return Result.success("批改成功");
     }
 
+    // 获取考试分页信息的方法，根据页码、每页数量以及考试名称等条件，返回包含相关考试信息的分页结果
     @Override
-    public Result<IPage<AnswerExamVO>> examPage(Integer pageNum, Integer pageSize,String examName) {
+    public Result<IPage<AnswerExamVO>> examPage(Integer pageNum, Integer pageSize, String examName) {
 
+        // 创建一个Page对象，用于封装分页相关信息，设置当前页码和每页显示数量
         Page<AnswerExamVO> page = new Page<>(pageNum, pageSize);
-        //获取自己创建的考试
-        List<AnswerExamVO> list = examMapper.selectMarkedList(page, SecurityUtil.getUserId(), SecurityUtil.getRole(),examName).getRecords();
+        // 调用examMapper的selectMarkedList方法，传入分页对象、当前用户ID、当前用户角色以及考试名称，获取自己创建的考试信息列表，并获取其记录列表（这里假设selectMarkedList方法返回的是包含分页信息和记录的对象）
+        List<AnswerExamVO> list = examMapper.selectMarkedList(page, SecurityUtil.getUserId(), SecurityUtil.getRole(), examName).getRecords();
 
-        //获取相关信息
+        // 遍历获取到的考试信息列表，为每个考试信息对象补充相关统计信息
         list.forEach(answerExamVO -> {
-            //需要参加考试人数
+            // 设置需要参加考试的人数，调用examGradeMapper的selectClassSize方法，传入考试ID获取班级规模即需要参加考试的人数
             answerExamVO.setClassSize(examGradeMapper.selectClassSize(answerExamVO.getExamId()));
-            //实际参加考试人数
+            // 设置实际参加考试的人数，创建一个LambdaQueryWrapper对象用于构建查询条件，查询对应考试的用户考试成绩记录数量，即实际参加考试的人数
             LambdaQueryWrapper<UserExamsScore> numberWrapper = new LambdaQueryWrapper<UserExamsScore>()
                     .eq(UserExamsScore::getExamId, answerExamVO.getExamId());
             answerExamVO.setNumberOfApplicants(userExamsScoreMapper.selectCount(numberWrapper).intValue());
-            //已阅人数
+            // 设置已阅试卷的数量，创建一个LambdaQueryWrapper对象用于构建查询条件，查询对应考试中已批改（是否已批改标记为1）的用户考试成绩记录数量，即已阅试卷的数量
             LambdaQueryWrapper<UserExamsScore> correctedWrapper = new LambdaQueryWrapper<UserExamsScore>()
                     .eq(UserExamsScore::getWhetherMark, 1)
-                    .eq(UserExamsScore::getExamId,answerExamVO.getExamId());
+                    .eq(UserExamsScore::getExamId, answerExamVO.getExamId());
             answerExamVO.setCorrectedPaper(userExamsScoreMapper.selectCount(correctedWrapper).intValue());
         });
-        //移除不需要批改的试卷
+
+        // 移除不需要批改的试卷，通过流操作过滤出需要批改（neededMark为1）的考试信息列表，重新设置到分页对象的记录列表中
         page.setRecords(list.stream()
                 .filter(answerExamVO -> answerExamVO.getNeededMark() == 1)
                 .toList());
 
+        // 返回包含处理后考试信息分页结果的成功结果信息，这里第一个参数为null，可能是预留用于传递其他提示信息等情况
         return Result.success(null, page);
 
     }
 
+    // 获取学生考试分页信息的方法，根据页码、每页数量、考试ID以及学生真实姓名等条件，返回包含未批改学生考试信息的分页结果
     @Override
-
-    public Result<IPage<UncorrectedUserVO>> stuExamPage(Integer pageNum, Integer pageSize, Integer examId,String realName) {
+    public Result<IPage<UncorrectedUserVO>> stuExamPage(Integer pageNum, Integer pageSize, Integer examId, String realName) {
+        // 创建一个IPage对象，用于封装分页相关信息，设置当前页码和每页显示数量
         IPage<UncorrectedUserVO> page = new Page<>(pageNum, pageSize);
-        page = userExamsScoreMapper.uncorrectedUser(page, examId,realName);
+        // 调用userExamsScoreMapper的uncorrectedUser方法，传入分页对象、考试ID以及学生真实姓名，获取未批改学生考试信息的分页结果并赋值给page对象
+        page = userExamsScoreMapper.uncorrectedUser(page, examId, realName);
+        // 返回包含未批改学生考试信息分页结果的成功结果信息，这里第一个参数为null，可能是预留用于传递其他提示信息等情况
         return Result.success(null, page);
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/NoticeGradeServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/NoticeGradeServiceImpl.java
index 9b2323d..0dd5dbd 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/NoticeGradeServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/NoticeGradeServiceImpl.java
@@ -1,20 +1,29 @@
 package cn.org.alan.exam.service.impl;
 
+// 导入NoticeGradeMapper接口，用于操作与通知班级关联相关的数据持久化操作（从命名推测功能）
 import cn.org.alan.exam.mapper.NoticeGradeMapper;
+// 导入NoticeGrade实体类，代表通知班级相关的实体对象
 import cn.org.alan.exam.model.entity.NoticeGrade;
+// 导入INoticeGradeService接口，定义了通知班级相关的业务服务方法
 import cn.org.alan.exam.service.INoticeGradeService;
+// 导入ServiceImpl类，这是MyBatis Plus提供的基础服务实现类，方便进行常见的数据库操作服务实现
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入Spring的Service注解，用于标记该类是一个服务层组件，由Spring容器进行管理
 import org.springframework.stereotype.Service;
 
 /**
  * <p>
- *  服务实现类
+ *  服务实现类，这里应该是针对通知班级相关业务逻辑的服务实现类（可根据具体业务完善文档注释）
  * </p>
  *
  * @author WeiJin
  * @since 2024-03-21
  */
+// 使用@Service注解将该类标记为Spring容器管理的服务层组件，方便在其他地方通过依赖注入使用
 @Service
+// 定义NoticeGradeServiceImpl类，继承自ServiceImpl<NoticeGradeMapper, NoticeGrade>，实现了INoticeGradeService接口
+// 这样可以复用ServiceImpl中的通用数据库操作方法，并按照INoticeGradeService接口定义实现具体业务逻辑
 public class NoticeGradeServiceImpl extends ServiceImpl<NoticeGradeMapper, NoticeGrade> implements INoticeGradeService {
-
-}
+    // 此处类体为空，意味着目前它继承了ServiceImpl中的通用方法，还没有额外实现INoticeGradeService接口中特定的业务方法
+    // 如果后续需要添加如添加通知班级、删除通知班级、查询通知班级等业务逻辑相关的方法，会在这里进行具体实现
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/NoticeServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/NoticeServiceImpl.java
index 280fcd9..899e429 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/NoticeServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/NoticeServiceImpl.java
@@ -35,205 +35,232 @@ import java.util.function.Function;
 import java.util.stream.Collectors;
 
 /**
- * 公告实现类
+ * 公告实现类，用于实现公告相关业务逻辑的服务层类
  *
  * @author Alan
  * @since 2024-03-21
  */
 @Service
+// NoticeServiceImpl类继承自ServiceImpl<NoticeMapper, Notice>，实现了INoticeService接口
+// 这样可以复用ServiceImpl中的通用数据库操作方法，并按照INoticeService接口定义实现具体业务逻辑
 public class NoticeServiceImpl extends ServiceImpl<NoticeMapper, Notice> implements INoticeService {
+    // 注入NoticeMapper，用于操作公告数据的持久层接口，比如插入、删除、查询公告等操作
     @Resource
     private NoticeMapper noticeMapper;
+    // 注入NoticeConverter，用于不同公告相关对象之间的转换（比如表单对象和实体对象等）
     @Resource
     private NoticeConverter noticeConverter;
+    // 注入NoticeGradeMapper，可能用于操作公告与班级关联相关数据的持久层接口（从命名推测其功能）
     @Resource
     private NoticeGradeMapper noticeGradeMapper;
+    // 注入GradeMapper，用于操作班级相关数据的持久层接口（可能在公告关联班级等业务中会用到）
     @Resource
     private GradeMapper gradeMapper;
+    // 注入CacheClient，自定义的缓存客户端，用于更方便地进行缓存操作，如批量获取、批量存入缓存等
     @Resource
     private CacheClient cacheClient;
+    // 注入StringRedisTemplate，用于操作Redis字符串类型数据，常用于缓存相关操作，比如删除缓存等
     @Resource
     private StringRedisTemplate stringRedisTemplate;
 
+    // 添加公告的方法，事务性操作，成功返回添加成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> addNotice(NoticeForm noticeForm) {
-        // 设置创建人
+        // 设置公告的创建人ID为当前登录用户的ID，通过SecurityUtil工具类获取当前用户ID
         noticeForm.setUserId(SecurityUtil.getUserId());
-        // 添加公告
+        // 将NoticeForm对象转换为Notice实体对象，方便后续持久化操作，使用NoticeConverter进行转换
         Notice notice = noticeConverter.formToEntity(noticeForm);
+        // 调用noticeMapper的insert方法将公告数据插入到数据库中，返回受影响的行数，即插入操作影响的记录数
         int rowsAffected = noticeMapper.insert(notice);
 
+        // 如果插入操作没有影响到任何行，即插入失败，返回添加失败的结果信息
         if (rowsAffected == 0) {
             return Result.failed("添加失败");
         }
+
+        // 创建一个LambdaQueryWrapper对象，用于构建查询班级信息的条件，这里查询当前用户创建的班级（通过用户ID关联）
         LambdaQueryWrapper<Grade> gradeLambdaQueryWrapper = new LambdaQueryWrapper<>();
-        gradeLambdaQueryWrapper.eq(Grade::getUserId,SecurityUtil.getUserId());
+        gradeLambdaQueryWrapper.eq(Grade::getUserId, SecurityUtil.getUserId());
+        // 调用gradeMapper的selectList方法，根据上面构建的查询条件获取班级实体对象列表，即获取当前用户创建的所有班级
         List<Grade> grades = gradeMapper.selectList(gradeLambdaQueryWrapper);
+        // 获取刚插入公告的ID，用于后续关联班级等操作（假设插入后会自动生成ID）
         Integer noticeId = notice.getId();
-        if(grades.isEmpty()){
-            return  Result.failed("您还没有创建班级，请先创建班级后再添加公告尝试");
+        // 如果当前用户没有创建任何班级，返回相应提示信息，提示先创建班级再添加公告
+        if (grades.isEmpty()) {
+            return Result.failed("您还没有创建班级，请先创建班级后再添加公告尝试");
         }
 
-        int addNoticeGradeRow = noticeGradeMapper.addNoticeGrade(noticeId,grades);
+        // 调用noticeGradeMapper的addNoticeGrade方法，将公告与班级进行关联，传入公告ID和班级列表，返回受影响的行数（假设该方法实现了关联操作并返回影响行数）
+        int addNoticeGradeRow = noticeGradeMapper.addNoticeGrade(noticeId, grades);
+        // 如果关联操作没有影响到任何行，即关联失败，返回添加失败的结果信息
         if (addNoticeGradeRow == 0) {
             return Result.failed("添加失败");
         }
-        // 更新缓存
-        if (notice.getId() != null) { // 确保ID有效
-            // 如果是更新操作，先从缓存中移除旧数据，然后重新放入最新的数据
-            stringRedisTemplate.delete("cache:notice:getNotice:"+notice.getId().toString()); // 删除旧缓存
-            stringRedisTemplate.delete("cache:notice:getNewNotice:"+notice.getId().toString());
+
+        // 如果公告插入成功且关联班级等操作也成功，公告数据有了有效的ID，进行缓存相关操作
+        if (notice.getId()!= null) { // 确保ID有效
+            // 如果是更新操作（此处逻辑可能不太准确，实际上是添加操作，但代码结构类似更新时的缓存处理逻辑），先从缓存中移除旧数据
+            // 根据公告ID删除对应的缓存数据，缓存键格式为"cache:notice:getNotice:" + 公告ID
+            stringRedisTemplate.delete("cache:notice:getNotice:" + notice.getId().toString());
+            // 根据公告ID删除对应的另一个缓存数据（可能是用于获取新公告相关的缓存，从命名推测），缓存键格式为"cache:notice:getNewNotice:" + 公告ID
+            stringRedisTemplate.delete("cache:notice:getNewNotice:" + notice.getId().toString());
             // NoticeVO updatedNoticeVO = noticeConverter.NoticeToNoticeVO(notice); // 转换为视图对象
             // Map<Integer, NoticeVO> map = Map.of(updatedNoticeVO.getId(), updatedNoticeVO);
             // cacheClient.batchPut("cache:notice:getNotice:",map,10L,TimeUnit.MINUTES); // 存储新数据
             // cacheClient.batchPut("cache:notice:getNewNotice:",map,10L,TimeUnit.MINUTES); // 存储新数据
 
         }
+
+        // 返回添加成功的结果信息
         return Result.success("添加成功");
     }
 
+    // 删除公告的方法，事务性操作，成功返回删除成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> deleteNotice(String ids) {
-        // 转换为集合
+        // 将传入的以逗号分隔的字符串形式的公告ID列表转换为Integer类型的列表，使用Java 8的Stream API进行转换
         List<Integer> noticeIds = Arrays.stream(ids.split(","))
                 .map(Integer::parseInt)
                 .toList();
-        // 删除公告
+        // 调用noticeMapper的removeNotice方法，根据公告ID列表删除对应的公告数据，返回受影响的行数，即删除操作影响的记录数
         int rowsAffected = noticeMapper.removeNotice(noticeIds);
+        // 如果删除操作没有影响到任何行，即删除失败，返回删除失败的结果信息
         if (rowsAffected == 0) {
             return Result.failed("删除失败");
         }
-        noticeIds.forEach(id->{
-            stringRedisTemplate.delete("cache:notice:getNewNotice:"+id);
-            stringRedisTemplate.delete("cache:notice:getNotice:"+id);
+
+        // 遍历公告ID列表，根据每个公告ID删除对应的两个缓存数据（分别用于获取公告和获取新公告相关的缓存，从缓存键命名推测）
+        noticeIds.forEach(id -> {
+            stringRedisTemplate.delete("cache:notice:getNewNotice:" + id);
+            stringRedisTemplate.delete("cache:notice:getNotice:" + id);
         });
 
+        // 返回删除成功的结果信息
         return Result.success("删除成功");
     }
 
+    // 更新公告的方法，事务性操作，成功返回更新成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> updateNotice(String id, NoticeForm noticeForm) {
-        // 创建更新条件
+        // 创建一个LambdaUpdateWrapper对象，用于构建更新公告信息的条件和要更新的字段
         LambdaUpdateWrapper<Notice> noticeWrapper = new LambdaUpdateWrapper<>();
+        // 设置更新条件为公告ID等于传入的id参数
         noticeWrapper.eq(Notice::getId, id)
-                .eq(Notice::getIsDeleted,0)
+                // 设置更新条件为公告未被删除（假设isDeleted字段表示是否删除，0表示未删除）
+                .eq(Notice::getIsDeleted, 0)
+                // 设置要更新的公告内容字段，值为传入的noticeForm中的公告内容
                 .set(Notice::getContent, noticeForm.getContent());
-        // 更新公告
+        // 调用noticeMapper的update方法，根据上面构建的更新条件和要更新的字段来更新公告数据，返回受影响的行数，即更新操作影响的记录数
         int rowsAffected = noticeMapper.update(noticeWrapper);
+        // 如果更新操作没有影响到任何行，即更新失败，返回修改失败的结果信息
         if (rowsAffected == 0) {
             return Result.failed("修改失败");
         }
+
+        // 根据ID获取更新后的公告对象，用于后续缓存操作等（可能需要获取最新数据来更新缓存等）
         Notice byId = getById(id);
-        if (byId.getId() != null) { // 确保ID有效
-            // 如果是更新操作，先从缓存中移除旧数据，然后重新放入最新的数据
-            stringRedisTemplate.delete("cache:notice:getNotice:"+byId.getId().toString()); // 删除旧缓存
-            stringRedisTemplate.delete("cache:notice:getNewNotice:"+byId.getId().toString()); // 删除旧缓存
+        // 如果获取到的公告对象有有效的ID，进行缓存相关操作
+        if (byId.getId()!= null) { // 确保ID有效
+            // 如果是更新操作，先从缓存中移除旧数据，根据公告ID删除对应的缓存数据，缓存键格式为"cache:notice:getNotice:" + 公告ID
+            stringRedisTemplate.delete("cache:notice:getNotice:" + byId.getId().toString());
+            // 根据公告ID删除对应的另一个缓存数据（可能是用于获取新公告相关的缓存，从命名推测），缓存键格式为"cache:notice:getNewNotice:" + 公告ID
+            stringRedisTemplate.delete("cache:notice:getNewNotice:" + byId.getId().toString());
             // NoticeVO updatedNoticeVO = noticeConverter.NoticeToNoticeVO(byId); // 转换为视图对象
             // Map<Integer, NoticeVO> map = Map.of(updatedNoticeVO.getId(), updatedNoticeVO);
             // cacheClient.batchPut("cache:notice:getNotice:",map,10L,TimeUnit.MINUTES); // 存储新数据
             // cacheClient.batchPut("cache:notice:getNewNotice:",map,10L,TimeUnit.MINUTES); // 存储新数据
         }
+
+        // 返回更新成功的结果信息
         return Result.success("修改成功");
     }
 
+    // 获取公告分页数据的方法，返回包含分页信息和公告视图对象列表的结果
     @Override
     public Result<IPage<NoticeVO>> getNotice(Integer pageNum, Integer pageSize, String title) {
-        // 查询满足条件的总记录数
-        int total = noticeMapper.countByCondition(SecurityUtil.getUserId(), title); // 假设gradeMapper中实现了根据条件计数的方法
-        // 计算偏移量
+        // 调用noticeMapper的countByCondition方法，根据当前用户ID和公告标题来统计满足条件的公告总记录数（假设noticeMapper中实现了该方法）
+        int total = noticeMapper.countByCondition(SecurityUtil.getUserId(), title);
+        // 计算分页查询的偏移量，根据当前页码和每页显示数量来计算
         int offset = (pageNum - 1) * pageSize;
 
-        // 查询分页ID列表
+        // 调用noticeMapper的selectNoticeIdsPage方法，根据当前用户ID、公告标题以及偏移量和每页显示数量来查询分页的公告ID列表（假设noticeMapper中实现了该方法）
         List<Integer> noticeIds = noticeMapper.selectNoticeIdsPage(SecurityUtil.getUserId(), title, offset, pageSize);
 
-        // 批量从缓存中获取GradeVO对象
-        Map<Integer, NoticeVO> cachedGradesMap = cacheClient.batchGet("cache:notice:getNotice:",noticeIds, NoticeVO.class);
+        // 使用cacheClient的batchGet方法，从缓存中批量获取对应公告ID的NoticeVO对象，缓存键前缀为"cache:notice:getNotice:"
+        Map<Integer, NoticeVO> cachedGradesMap = cacheClient.batchGet("cache:notice:getNotice:", noticeIds, NoticeVO.class);
 
-        // 确定未命中的ID列表
+        // 创建一个列表，用于存储在缓存中未命中的公告ID，即缓存中不存在对应数据的公告ID
         List<Integer> missIds = new ArrayList<>();
+        // 遍历查询到的公告ID列表，检查每个ID在缓存中是否存在，如果不存在则添加到未命中ID列表中
         for (Integer id : noticeIds) {
             if (!cachedGradesMap.containsKey(id)) {
                 missIds.add(id);
             }
         }
 
-        // 如果有未命中的ID，从数据库批量查询并更新缓存
+        // 如果存在未命中缓存的公告ID，即missIds列表不为空
         if (!missIds.isEmpty()) {
+            // 调用noticeMapper的batchSelectByIds方法，从数据库中批量查询未命中缓存的公告数据，并转换为NoticeVO对象列表（假设noticeMapper中实现了该方法）
             List<NoticeVO> missedGrades = noticeMapper.batchSelectByIds(missIds);
-            // 假设GradeVO的ID为getId()，使用Collectors.toMap转换
+            // 使用Java 8的Stream API，将NoticeVO对象列表转换为以公告ID为键，NoticeVO对象为值的Map，方便后续操作
             Map<Integer, NoticeVO> missedGradesMap = missedGrades.stream()
                     .collect(Collectors.toMap(NoticeVO::getId, Function.identity()));
-            // 更新缓存
-            cacheClient.batchPut("cache:notice:getNotice:",missedGradesMap,10L, TimeUnit.MINUTES);
-            // 合并缓存结果
+            // 使用cacheClient的batchPut方法，将从数据库中查询到的未命中缓存的公告数据更新到缓存中，缓存有效期为10分钟
+            cacheClient.batchPut("cache:notice:getNotice:", missedGradesMap, 10L, TimeUnit.MINUTES);
+            // 将从数据库中查询到的未命中缓存的公告数据合并到缓存结果的Map中，确保缓存数据的完整性
             cachedGradesMap.putAll(missedGradesMap);
         }
 
-        // 根据ID列表从缓存中获取完整的GradeVO对象列表
+        // 创建一个列表，用于存储最终要返回的完整的NoticeVO对象列表，初始大小为查询到的公告ID列表的大小
         List<NoticeVO> finalResult = new ArrayList<>(noticeIds.size());
+        // 遍历公告ID列表，从缓存结果的Map中获取对应的NoticeVO对象，并添加到最终结果列表中
         for (Integer id : noticeIds) {
             finalResult.add(cachedGradesMap.get(id));
         }
 
-        // 构建并返回IPage对象
+        // 创建一个IPage对象，用于封装分页信息和最终的公告视图对象列表，设置当前页码、每页显示数量以及总记录数
         IPage<NoticeVO> resultPage = new Page<>(pageNum, pageSize, Long.valueOf(total));
+        // 将最终的公告视图对象列表设置到IPage对象中
         resultPage.setRecords(finalResult);
 
+        // 返回包含分页信息和公告视图对象列表的成功结果信息
         return Result.success("查询成功", resultPage);
 
     }
 
+    // 获取新公告分页数据的方法，返回包含分页信息和公告视图对象列表的结果（与getNotice方法逻辑有部分重复，可能可进行适当优化抽取公共逻辑）
     @Override
     public Result<IPage<NoticeVO>> getNewNotice(Integer pageNum, Integer pageSize) {
-        // 创建分页对象
+        // 创建一个Page对象，用于封装分页相关信息，设置当前页码和每页显示数量
         Page<NoticeVO> page = new Page<>(pageNum, pageSize);
-        // 学生分页查询公告
-         page = noticeMapper.selectNewNoticePage(page,SecurityUtil.getUserId());
+        // 调用noticeMapper的selectNewNoticePage方法，传入分页对象和当前用户ID，进行学生分页查询公告操作（具体查询逻辑在该方法内部实现，从命名推测是获取新公告相关的分页数据）
+        page = noticeMapper.selectNewNoticePage(page, SecurityUtil.getUserId());
         // return Result.success("查询成功", page);
-        // 查询满足条件的总记录数
-        int total = noticeMapper.countByCondition(SecurityUtil.getUserId(), null); // 假设gradeMapper中实现了根据条件计数的方法
-        // 计算偏移量
+        // 调用noticeMapper的countByCondition方法，根据当前用户ID（标题为null，可能表示不按标题筛选）来统计满足条件的公告总记录数（假设noticeMapper中实现了该方法）
+        int total = noticeMapper.countByCondition(SecurityUtil.getUserId(), null);
+        // 计算分页查询的偏移量，根据当前页码和每页显示数量来计算
         int offset = (pageNum - 1) * pageSize;
 
-        // 查询分页ID列表
+        // 调用noticeMapper的selectNewNoticeIdsPage方法，根据当前用户ID、偏移量和每页显示数量来查询分页的公告ID列表（假设noticeMapper中实现了该方法）
         List<Integer> noticeIds = noticeMapper.selectNewNoticeIdsPage(SecurityUtil.getUserId(), offset, pageSize);
 
-        // 批量从缓存中获取GradeVO对象
-        Map<Integer, NoticeVO> cachedGradesMap = cacheClient.batchGet("cache:notice:getNewNotice:",noticeIds, NoticeVO.class);
+        // 使用cacheClient的batchGet方法，从缓存中批量获取对应公告ID的NoticeVO对象，缓存键前缀为"cache:notice:getNewNotice:"
+        Map<Integer, NoticeVO> cachedGradesMap = cacheClient.batchGet("cache:notice:getNewNotice:", noticeIds, NoticeVO.class);
 
-        // 确定未命中的ID列表
+        // 创建一个列表，用于存储在缓存中未命中的公告ID，即缓存中不存在对应数据的公告ID
         List<Integer> missIds = new ArrayList<>();
+        // 遍历查询到的公告ID列表，检查每个ID在缓存中是否存在，如果不存在则添加到未命中ID列表中
         for (Integer id : noticeIds) {
             if (!cachedGradesMap.containsKey(id)) {
                 missIds.add(id);
             }
         }
 
-        // 如果有未命中的ID，从数据库批量查询并更新缓存
+        // 如果存在未命中缓存的公告ID，即missIds列表不为空
         if (!missIds.isEmpty()) {
+            // 调用noticeMapper的batchSelectByIds方法，从数据库中批量查询未命中缓存的公告数据，并转换为NoticeVO对象列表（假设noticeMapper中实现了该方法）
             List<NoticeVO> missedGrades = noticeMapper.batchSelectByIds(missIds);
-            // 假设GradeVO的ID为getId()，使用Collectors.toMap转换
-            Map<Integer, NoticeVO> missedGradesMap = missedGrades.stream()
-                    .collect(Collectors.toMap(NoticeVO::getId, Function.identity()));
-            // 更新缓存
-            cacheClient.batchPut("cache:notice:getNotice:",missedGradesMap,10L, TimeUnit.MINUTES);
-            // 合并缓存结果
-            cachedGradesMap.putAll(missedGradesMap);
-        }
-
-        // 根据ID列表从缓存中获取完整的GradeVO对象列表
-        List<NoticeVO> finalResult = new ArrayList<>(noticeIds.size());
-        for (Integer id : noticeIds) {
-            finalResult.add(cachedGradesMap.get(id));
-        }
-
-        // 构建并返回IPage对象
-        IPage<NoticeVO> resultPage = new Page<>(pageNum, pageSize, Long.valueOf(total));
-        resultPage.setRecords(finalResult);
-
-        return Result.success("查询成功", resultPage);
-    }
-}
+            // 使用Java 8的Stream API，将NoticeVO对象列表转换为以公告ID为键，NoticeVO对象为
\ No newline at end of file
-- 
2.34.1


From 092da9cd0abaf8f63b9ff509e85e1209afc4c9fd Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Wed, 18 Dec 2024 16:48:18 +0800
Subject: [PATCH 07/10] main1122

---
 .../exam/service/impl/OptionServiceImpl.java  |  13 +-
 .../service/impl/QuestionServiceImpl.java     | 174 ++++++++++--------
 .../exam/service/impl/RepoServiceImpl.java    |  59 ++++--
 .../exam/service/impl/RoleServiceImpl.java    |  13 +-
 .../exam/service/impl/StatServiceImpl.java    |  71 +++++--
 5 files changed, 220 insertions(+), 110 deletions(-)

diff --git a/src/main/java/cn/org/alan/exam/service/impl/OptionServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/OptionServiceImpl.java
index 3aacd46..4ae6b4b 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/OptionServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/OptionServiceImpl.java
@@ -1,20 +1,29 @@
 package cn.org.alan.exam.service.impl;
 
+// 导入OptionMapper接口，它是用于操作题目选项相关数据的持久层接口，例如对选项数据进行增删改查等操作（从命名推测其功能）
 import cn.org.alan.exam.mapper.OptionMapper;
+// 导入Option实体类，代表题目选项相关的实体对象，包含了选项的各种属性信息，如选项内容、是否正确等
 import cn.org.alan.exam.model.entity.Option;
+// 导入IOptionService接口，该接口定义了题目选项相关的业务服务方法，规定了具体有哪些业务操作需要实现
 import cn.org.alan.exam.service.IOptionService;
+// 导入ServiceImpl类，这是MyBatis Plus提供的基础服务实现类，它提供了很多通用的数据库操作方法，方便在此基础上扩展具体业务逻辑的实现
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入Spring的Service注解，用于标记该类是一个服务层组件，Spring容器会对其进行管理，使其能够参与依赖注入等相关机制
 import org.springframework.stereotype.Service;
 
 /**
  * <p>
- *  服务实现类
+ *  服务实现类，这里应该是针对题目选项相关业务逻辑的服务实现类（可根据具体业务完善文档注释内容进一步明确其功能）
  * </p>
  *
  * @author WeiJin
  * @since 2024-03-21
  */
+// 使用@Service注解将该类标记为Spring容器管理的服务层组件，意味着在Spring应用中可以通过依赖注入的方式在其他地方使用这个服务类
 @Service
+// 定义OptionServiceImpl类，它继承自ServiceImpl<OptionMapper, Option>，同时实现了IOptionService接口
+// 通过继承ServiceImpl可以复用其中已有的通用数据库操作方法，再按照IOptionService接口中定义的业务方法来实现具体针对题目选项的业务逻辑
+// 目前类体为空，表示暂时没有添加额外的业务方法实现，如果后续有添加选项、删除选项、查询选项等业务逻辑相关的方法，就需要在这里进行具体的编写
 public class OptionServiceImpl extends ServiceImpl<OptionMapper, Option> implements IOptionService {
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/QuestionServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/QuestionServiceImpl.java
index 82f8819..5a064cd 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/QuestionServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/QuestionServiceImpl.java
@@ -38,7 +38,7 @@ import java.util.function.Function;
 import java.util.stream.Collectors;
 
 /**
- * 服务实现类
+ * 服务实现类，这里应该是针对题目相关业务逻辑的服务实现类（可根据具体业务完善更详细的文档注释）
  *
  * @author WeiJin
  * @since 2024-03-21
@@ -46,215 +46,239 @@ import java.util.stream.Collectors;
 @Service
 public class QuestionServiceImpl extends ServiceImpl<QuestionMapper, Question> implements IQuestionService {
 
+    // 注入QuestionConverter，用于不同题目相关对象之间的转换（比如表单对象和实体对象等）
     @Resource
     private QuestionConverter questionConverter;
+    // 注入QuestionMapper，用于操作题目数据的持久层接口，例如插入、查询、更新、删除题目等操作
     @Resource
     private QuestionMapper questionMapper;
+    // 注入OptionMapper，用于操作题目选项数据的持久层接口，像插入、更新、删除题目选项等操作（与题目相关联）
     @Resource
     private OptionMapper optionMapper;
+    // 注入AliOSSUtil，可能是用于与阿里云对象存储服务（OSS）交互的工具类，比如上传图片等操作（从命名推测）
     @Resource
     private AliOSSUtil aliOSSUtil;
+    // 注入ExerciseRecordMapper，可能用于操作练习记录相关数据的持久层接口（推测与用户做题目练习的记录有关）
     @Resource
     private ExerciseRecordMapper exerciseRecordMapper;
+    // 注入CacheClient，自定义的缓存客户端，用于更方便地进行缓存操作，如批量获取、批量存入缓存等
     @Resource
     private CacheClient cacheClient;
+    // 注入StringRedisTemplate，用于操作Redis字符串类型数据，常用于缓存相关操作，比如删除缓存等
     @Resource
     private StringRedisTemplate stringRedisTemplate;
 
+    // 添加单个题目（可能是单选题、多选题、判断题、简答题等不同类型）的方法，事务性操作，成功返回添加成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> addSingleQuestion(QuestionFrom questionFrom) {
-        // 入参校验
+        // 入参校验，获取题目表单中的选项列表
         List<Option> options = questionFrom.getOptions();
-        if (questionFrom.getQuType() != 4 && (Objects.isNull(options) || options.size() < 2)) {
+        // 判断题目类型不是简答题（假设题目类型4代表简答题）且选项为空或者选项数量小于2时，不符合要求，返回错误提示
+        if (questionFrom.getQuType()!= 4 && (Objects.isNull(options) || options.size() < 2)) {
             return Result.failed("非简答题的试题选项不能少于两个");
         }
 
+        // 将QuestionFrom对象转换为Question实体对象，方便后续持久化操作，使用QuestionConverter进行转换
         Question question = questionConverter.fromToEntity(questionFrom);
 
+        // 调用questionMapper的insert方法将题目数据插入到数据库中
         questionMapper.insert(question);
-        if (question.getQuType() == 4) {
-            // 简答题添加选项
 
+        // 如果题目类型是简答题
+        if (question.getQuType() == 4) {
+            // 简答题添加选项，获取题目表单中第一个选项（简答题通常可能只有一个用于填写答案的选项，这里从代码逻辑推测）
             Option option = questionFrom.getOptions().get(0);
+            // 设置该选项所属题目的ID为刚插入题目的ID，建立关联
             option.setQuId(question.getId());
+            // 调用optionMapper的insert方法将选项数据插入到数据库中
             optionMapper.insert(option);
         } else {
             // 非简答题添加选项
-            // 把新建试题获取的id，填入选项中
+            // 遍历题目表单中的所有选项，将每个选项所属题目的ID设置为刚插入题目的ID，建立关联
             options.forEach(option -> {
                 option.setQuId(question.getId());
             });
+            // 调用optionMapper的insertBatch方法，批量将选项数据插入到数据库中
             optionMapper.insertBatch(options);
         }
-        if (question.getId() != null) { // 确保ID有效
-            // 如果是更新操作，先从缓存中移除旧数据，然后重新放入最新的数据
-            stringRedisTemplate.delete("cache:question:pagingQuestion:"+question.getId().toString()); // 删除旧缓存
-            //
+
+        // 如果题目插入成功，题目数据有了有效的ID（这里假设插入后会自动生成ID），进行缓存相关操作
+        if (question.getId()!= null) { // 确保ID有效
+            // 如果是更新操作（此处逻辑可能不太准确，实际上是添加操作，但代码结构类似更新时的缓存处理逻辑），先从缓存中移除旧数据
+            // 根据题目ID删除对应的缓存数据，缓存键格式为"cache:question:pagingQuestion:" + 题目ID
+            stringRedisTemplate.delete("cache:question:pagingQuestion:" + question.getId().toString());
             // QuestionVO questionVO = questionConverter.QuestionToQuestionVO(question); // 转换为视图对象
             // Map<Integer, QuestionVO> map = Map.of(questionVO.getId(), questionVO);
             // cacheClient.batchPut("cache:question:pagingQuestion:",map,10L,TimeUnit.MINUTES); // 存储新数据
         }
+
+        // 返回添加成功的结果信息
         return Result.success("添加成功");
 
     }
 
+    // 批量删除题目（根据题目ID列表）的方法，事务性操作，成功返回删除成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> deleteBatchByIds(String ids) {
+        // 将传入的以逗号分隔的字符串形式的题目ID列表转换为Integer类型的列表，使用Java 8的Stream API进行转换
         List<Integer> list = Arrays.stream(ids.split(",")).map(Integer::parseInt).toList();
 
-        //删除用户刷题记录表
+        // 删除用户刷题记录表中与要删除题目相关的记录，创建一个LambdaUpdateWrapper对象用于构建删除条件
         LambdaUpdateWrapper<ExerciseRecord> updateWrapper =
                 new LambdaUpdateWrapper<ExerciseRecord>().in(ExerciseRecord::getQuestionId, list);
+        // 调用exerciseRecordMapper的delete方法，根据构建的条件删除相关记录，返回受影响的行数
         int delete = exerciseRecordMapper.delete(updateWrapper);
-        // 先删除选项
+
+        // 先删除题目对应的选项，调用optionMapper的deleteBatchByQuIds方法，传入题目ID列表批量删除选项（假设该方法实现了批量删除逻辑）
         optionMapper.deleteBatchByQuIds(list);
-        // 再删除试题
+
+        // 再删除题目，调用questionMapper的deleteBatchIdsQu方法，传入题目ID列表删除对应的题目（假设该方法实现了批量删除逻辑）
         questionMapper.deleteBatchIdsQu(list);
-        list.forEach(id->{
-            stringRedisTemplate.delete("cache:question:pagingQuestion:"+id);
+
+        // 遍历题目ID列表，根据每个题目ID删除对应的缓存数据，缓存键格式为"cache:question:pagingQuestion:" + 题目ID
+        list.forEach(id -> {
+            stringRedisTemplate.delete("cache:question:pagingQuestion:" + id);
         });
 
+        // 返回删除成功的结果信息
         return Result.success("删除成功");
     }
 
+    // 获取题目分页数据的方法，根据页码、每页数量、题目标题、题目类型以及题库ID等条件，返回包含分页信息和题目视图对象列表的结果
     @Override
     public Result<IPage<QuestionVO>> pagingQuestion(Integer pageNum, Integer pageSize, String title, Integer type, Integer repoId) {
+        // 初始化用户ID变量，默认为null，后续根据用户角色进行赋值
         Integer userId = null;
+        // 如果当前用户角色为"role_teacher"（可能代表教师角色，具体根据业务定义），则将用户ID设置为当前登录用户的ID
         if ("role_teacher".equals(SecurityUtil.getRole())) {
             userId = SecurityUtil.getUserId();
         } else {
+            // 否则设置为0（这里0可能代表其他情况，比如游客或者无特定用户身份等，具体看业务逻辑）
             userId = 0;
         }
-        // 查询满足条件的总记录数
-        int total = questionMapper.countByCondition(userId, title,type,repoId); // 假设gradeMapper中实现了根据条件计数的方法
-        // 计算偏移量
+
+        // 调用questionMapper的countByCondition方法，根据用户ID、题目标题、题目类型以及题库ID来统计满足条件的题目总记录数（假设questionMapper中实现了该方法）
+        int total = questionMapper.countByCondition(userId, title, type, repoId);
+        // 计算分页查询的偏移量，根据当前页码和每页显示数量来计算
         int offset = (pageNum - 1) * pageSize;
 
-        // 查询分页ID列表
-        List<Integer> quIds = questionMapper.selectQuestionIdsPage(userId, title,type,repoId, offset, pageSize);
+        // 调用questionMapper的selectQuestionIdsPage方法，根据用户ID、题目标题、题目类型、题库ID以及偏移量和每页显示数量来查询分页的题目ID列表（假设questionMapper中实现了该方法）
+        List<Integer> quIds = questionMapper.selectQuestionIdsPage(userId, title, type, repoId, offset, pageSize);
 
-        // 批量从缓存中获取GradeVO对象
-        Map<Integer, QuestionVO> cachedQuestionsMap = cacheClient.batchGet("cache:question:pagingQuestion:",quIds, QuestionVO.class);
+        // 使用cacheClient的batchGet方法，从缓存中批量获取对应题目ID的QuestionVO对象，缓存键前缀为"cache:question:pagingQuestion:"
+        Map<Integer, QuestionVO> cachedQuestionsMap = cacheClient.batchGet("cache:question:pagingQuestion:", quIds, QuestionVO.class);
 
-        // 确定未命中的ID列表
+        // 创建一个列表，用于存储在缓存中未命中的题目ID，即缓存中不存在对应数据的题目ID
         List<Integer> missIds = new ArrayList<>();
+        // 遍历查询到的题目ID列表，检查每个ID在缓存中是否存在，如果不存在则添加到未命中ID列表中
         for (Integer id : quIds) {
             if (!cachedQuestionsMap.containsKey(id)) {
                 missIds.add(id);
             }
         }
 
-        // 如果有未命中的ID，从数据库批量查询并更新缓存
+        // 如果存在未命中缓存的题目ID，即missIds列表不为空
         if (!missIds.isEmpty()) {
+            // 调用questionMapper的batchSelectByIds方法，从数据库中批量查询未命中缓存的题目数据，并转换为QuestionVO对象列表（假设questionMapper中实现了该方法）
             List<QuestionVO> missedGrades = questionMapper.batchSelectByIds(missIds);
-            // 假设GradeVO的ID为getId()，使用Collectors.toMap转换
+            // 使用Java 8的Stream API，将QuestionVO对象列表转换为以题目ID为键，QuestionVO对象为值的Map，方便后续操作
             Map<Integer, QuestionVO> missedGradesMap = missedGrades.stream()
                     .collect(Collectors.toMap(QuestionVO::getId, Function.identity()));
-            // 更新缓存
-            cacheClient.batchPut("cache:question:pagingQuestion:",missedGradesMap,10L, TimeUnit.MINUTES);
-            // 合并缓存结果
+            // 使用cacheClient的batchPut方法，将从数据库中查询到的未命中缓存的题目数据更新到缓存中，缓存有效期为10分钟
+            cacheClient.batchPut("cache:question:pagingQuestion:", missedGradesMap, 10L, TimeUnit.MINUTES);
+            // 将从数据库中查询到的未命中缓存的题目数据合并到缓存结果的Map中，确保缓存数据的完整性
             cachedQuestionsMap.putAll(missedGradesMap);
         }
 
-        // 根据ID列表从缓存中获取完整的GradeVO对象列表
+        // 创建一个列表，用于存储最终要返回的完整的QuestionVO对象列表，初始大小为查询到的题目ID列表的大小
         List<QuestionVO> finalResult = new ArrayList<>(quIds.size());
+        // 遍历题目ID列表，从缓存结果的Map中获取对应的QuestionVO对象，并添加到最终结果列表中
         for (Integer id : quIds) {
             finalResult.add(cachedQuestionsMap.get(id));
         }
 
-        // 构建并返回IPage对象
+        // 创建一个IPage对象，用于封装分页信息和最终的题目视图对象列表，设置当前页码、每页显示数量以及总记录数
         IPage<QuestionVO> resultPage = new Page<>(pageNum, pageSize, Long.valueOf(total));
+        // 将最终的题目视图对象列表设置到IPage对象中
         resultPage.setRecords(finalResult);
 
+        // 返回包含分页信息和题目视图对象列表的成功结果信息，这里第一个参数为null，可能是预留用于传递其他提示信息等情况
         return Result.success(null, resultPage);
     }
 
+    // 查询单个题目的方法，根据题目ID查询并返回对应的题目视图对象，返回包含题目视图对象的结果信息
     @Override
     public Result<QuestionVO> querySingle(Integer id) {
+        // 调用questionMapper的selectSingle方法，传入题目ID查询对应的题目数据，并将其包装在成功结果信息中返回
         return Result.success(null, questionMapper.selectSingle(id));
     }
 
+    // 更新题目的方法，事务性操作，成功返回更新成功的提示信息，失败返回相应错误提示
     @Override
     @Transactional
     public Result<String> updateQuestion(QuestionFrom questionFrom) {
-        // 修改试题
-
+        // 修改试题，将QuestionFrom对象转换为Question实体对象，方便后续更新操作，使用QuestionConverter进行转换
         Question question = questionConverter.fromToEntity(questionFrom);
+        // 调用questionMapper的updateById方法，根据题目实体对象的ID更新对应的题目数据（假设ID是唯一标识且不为空）
         questionMapper.updateById(question);
-        // 修改选项
+
+        // 修改选项，获取题目表单中的选项列表
         List<Option> options = questionFrom.getOptions();
+        // 遍历题目表单中的每个选项，调用optionMapper的updateById方法，根据选项实体对象的ID更新对应的选项数据（假设ID是唯一标识且不为空）
         for (Option option : options) {
             optionMapper.updateById(option);
         }
-        if (question.getId() != null) { // 确保ID有效
-            // 如果是更新操作，先从缓存中移除旧数据，然后重新放入最新的数据
-            stringRedisTemplate.delete("cache:question:pagingQuestion:"+question.getId().toString()); // 删除旧缓存
+
+        // 如果题目更新成功，题目数据有了有效的ID（这里假设更新前后ID不变且不为空），进行缓存相关操作
+        if (question.getId()!= null) { // 确保ID有效
+            // 如果是更新操作，先从缓存中移除旧数据，根据题目ID删除对应的缓存数据，缓存键格式为"cache:question:pagingQuestion:" + 题目ID
+            stringRedisTemplate.delete("cache:question:pagingQuestion:" + question.getId().toString());
             // QuestionVO questionVO = questionConverter.QuestionToQuestionVO(question); // 转换为视图对象
             // Map<Integer, QuestionVO> map = Map.of(questionVO.getId(), questionVO);
             // cacheClient.batchPut("cache:question:pagingQuestion:",map,10L,TimeUnit.MINUTES); // 存储新数据
         }
+
+        // 返回更新成功的结果信息
         return Result.success("修改成功");
     }
 
+    // 导入题目（从Excel文件导入）的方法，事务性操作，成功返回导入成功的提示信息，失败返回相应错误提示，使用了异常处理注解来简化异常抛出处理
     @SneakyThrows(Exception.class)
     @Override
     @Transactional
     public Result<String> importQuestion(Integer id, MultipartFile file) {
+        // 检查传入的文件是否是合法的Excel文件，调用ExcelUtils工具类的isExcel方法进行判断
         if (!ExcelUtils.isExcel(Objects.requireNonNull(file.getOriginalFilename()))) {
             return Result.failed("该文件不是一个合法的Excel文件");
         }
+
+        // 调用ExcelUtils的readMultipartFile方法，读取传入的MultipartFile类型的Excel文件，并转换为QuestionExcelFrom对象列表（假设该方法实现了读取并转换逻辑）
         List<QuestionExcelFrom> questionExcelFroms = ExcelUtils.readMultipartFile(file, QuestionExcelFrom.class);
-        // 类型转换
+        // 进行类型转换，将QuestionExcelFrom对象列表转换为QuestionFrom对象列表，调用QuestionExcelFrom类中的静态方法进行转换（假设该方法实现了转换逻辑）
         List<QuestionFrom> list = QuestionExcelFrom.converterQuestionFrom(questionExcelFroms);
 
+        // 遍历转换后的QuestionFrom对象列表，处理每个题目表单对象对应的题目及选项数据插入逻辑
         for (QuestionFrom questionFrom : list) {
+            // 将QuestionFrom对象转换为Question实体对象，方便后续持久化操作，使用QuestionConverter进行转换
             Question question = questionConverter.fromToEntity(questionFrom);
+            // 设置题目所属的题库ID为传入的id参数
             question.setRepoId(id);
-            // 添加单题获取Id
+            // 插入单个题目数据到数据库中，调用questionMapper的insert方法
             questionMapper.insert(question);
-            // 批量添加选项
+
+            // 批量添加选项，获取题目表单中的选项列表
             List<Option> options = questionFrom.getOptions();
+            // 创建一个长度为1的数组，用于记录选项的排序序号，初始值为0（这里通过数组实现类似引用传递的效果，方便在Lambda表达式中修改值）
             final int[] count = {0};
+            // 遍历题目表单中的每个选项，设置选项的相关属性并建立与题目的关联
             options.forEach(option -> {
-                //简答题答案默认给正确
+                // 简答题答案默认给正确（假设题目类型4代表简答题，这里根据题目类型设置选项的是否正确属性）
                 if (question.getQuType() == 4) {
                     option.setIsRight(1);
                 }
+                // 设置选项的排序序号，每次自增1
                 option.setSort(++count[0]);
-                option.setQuId(question.getId());
-            });
-
-            // 避免简答题没有答案
-            if (!options.isEmpty()) {
-                optionMapper.insertBatch(options);
-            }
-            if (question.getId() != null) { // 确保ID有效
-                // 如果是更新操作，先从缓存中移除旧数据，然后重新放入最新的数据
-                stringRedisTemplate.delete("cache:question:pagingQuestion:"+question.getId().toString()); // 删除旧缓存
-                // QuestionVO questionVO = questionConverter.QuestionToQuestionVO(question); // 转换为视图对象
-                // Map<Integer, QuestionVO> map = Map.of(questionVO.getId(), questionVO);
-                // cacheClient.batchPut("cache:question:pagingQuestion:",map,10L,TimeUnit.MINUTES); // 存储新数据
-            }
-
-        }
-        return Result.success("导入成功");
-    }
-
-    @SneakyThrows(IOException.class)
-    @Override
-    public Result<String> uploadImage(MultipartFile file) {
-        if (!aliOSSUtil.isImage(Objects.requireNonNull(file.getOriginalFilename()))) {
-            return Result.failed("该文件不是常用图片格式(png、jpg、jpeg、bmp)");
-        }
-        if (aliOSSUtil.isOverSize(file)) {
-            return Result.failed("图片大小不能超过50KB");
-        }
-        String url = aliOSSUtil.upload(file);
-        if (StringUtils.isBlank(url)) {
-            return Result.failed("图片上传失败");
-        }
-        return Result.success("图片上传成功", url);
-    }
-}
+                // 设置选项所属题目的ID为刚插入题目的ID，建立关联
+                option.setQuId(question
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/RepoServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/RepoServiceImpl.java
index 3009015..4a9616c 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/RepoServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/RepoServiceImpl.java
@@ -30,95 +30,128 @@ import java.util.List;
 /**
  * @author WeiJin
  * @since 2024-03-21
+ * 这是一个实现了IRepoService接口的服务类，用于处理与题库（Repo）相关的业务逻辑，例如添加、更新、删除题库以及获取题库相关信息等操作。
  */
 @Service
 public class RepoServiceImpl extends ServiceImpl<RepoMapper, Repo> implements IRepoService {
 
-
+    // 注入RepoMapper，用于操作题库数据的持久层接口，比如插入、更新、查询、删除题库记录等操作。
     @Resource
     private RepoMapper repoMapper;
+    // 注入QuestionMapper，用于操作题目数据的持久层接口，可能在涉及题库与题目关联的业务逻辑中使用，比如更新题目所属题库等操作。
     @Resource
     private QuestionMapper questionMapper;
-
+    // 注入ExerciseRecordMapper，用于操作练习记录数据的持久层接口，或许在获取题库相关统计信息（如刷题次数等）时会用到。
     @Resource
     private ExerciseRecordMapper exerciseRecordMapper;
 
-
+    // 添加题库的方法，将传入的Repo对象插入到数据库中，成功返回保存成功的提示信息。
     @Override
     public Result<String> addRepo(Repo repo) {
+        // 调用repoMapper的insert方法，将传入的Repo对象插入到数据库中，执行插入操作。
         repoMapper.insert(repo);
+        // 返回表示保存成功的结果信息，通常可以在前端等地方展示给用户相应提示。
         return Result.success("保存成功");
     }
 
+    // 更新题库信息的方法，根据传入的Repo对象和要更新的题库ID，更新对应题库的标题信息，成功返回修改成功的提示信息。
     @Override
     public Result<String> updateRepo(Repo repo, Integer id) {
-        //修改题库
+        // 创建一个LambdaUpdateWrapper对象，用于构建更新题库信息的条件和要更新的字段。
         LambdaUpdateWrapper<Repo> updateWrapper = new LambdaUpdateWrapper<Repo>()
-                .eq(Repo::getId, id).set(Repo::getTitle, repo.getTitle());
+                // 设置更新条件为题库的ID等于传入的id参数，确保更新的是指定的题库记录。
+                .eq(Repo::getId, id)
+                // 设置要更新的字段为题库的标题，将其更新为传入Repo对象中的标题值。
+                .set(Repo::getTitle, repo.getTitle());
 
+        // 调用repoMapper的update方法，根据构建好的更新条件和要更新的字段来更新数据库中的题库记录。
         repoMapper.update(updateWrapper);
+        // 返回表示修改成功的结果信息，方便前端等地方知晓操作结果并展示相应提示给用户。
         return Result.success("修改成功");
     }
 
+    // 删除题库的方法，事务性操作，先清空题库内所有题目所属的题库ID，然后将该题库标记为已删除（逻辑删除），根据操作结果返回相应提示信息。
     @Override
     @Transactional
     public Result<String> deleteRepoById(Integer id) {
 
-        //题库内试题清空所属题库id
+        // 清空题库内试题所属的题库ID，创建一个LambdaUpdateWrapper对象用于构建更新题目信息的条件和要更新的字段。
         LambdaUpdateWrapper<Question> wrapper = new LambdaUpdateWrapper<Question>()
+                // 设置更新条件为题目所属的题库ID等于传入的要删除的题库ID。
                 .eq(Question::getRepoId, id)
+                // 设置要更新的字段为题目所属的题库ID，将其更新为null，表示清空所属题库关系。
                 .set(Question::getRepoId, null);
+        // 调用questionMapper的update方法，根据构建的条件更新数据库中相关题目的所属题库ID字段。
         questionMapper.update(wrapper);
-        //删除题库
+
+        // 创建一个LambdaUpdateWrapper对象，用于构建删除题库的逻辑（这里采用逻辑删除，设置删除标记字段）。
         LambdaUpdateWrapper<Repo> repoLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
-        repoLambdaUpdateWrapper.eq(Repo::getId,id)
-                .set(Repo::getIsDeleted,1);
+        // 设置更新条件为题库的ID等于传入的要删除的题库ID。
+        repoLambdaUpdateWrapper.eq(Repo::getId, id)
+                // 设置题库的删除标记字段（假设名为isDeleted）为1，表示已删除。
+                .set(Repo::getIsDeleted, 1);
+        // 调用repoMapper的update方法，根据构建的条件执行逻辑删除操作，返回受影响的行数，即实际更新的记录数。
         int result = repoMapper.update(repoLambdaUpdateWrapper);
+        // 如果更新操作影响的行数大于0，表示删除操作成功，返回删除成功的结果信息。
         if (result > 0) {
             return Result.success("删除成功");
         }
+        // 如果更新操作影响的行数为0，表示删除操作失败，返回删除失败的结果信息。
         return Result.failed("删除失败");
     }
 
+    // 获取题库列表的方法，根据当前用户角色（教师或其他角色）以及传入的题库标题模糊查询条件，从数据库中获取相应的题库列表信息，返回包含查询结果的成功提示信息。
     @Override
     public Result<List<RepoListVO>> getRepoList(String repoTitle) {
         List<RepoListVO> list;
+        // 判断当前用户角色是否为"role_teacher"（通常代表教师角色，具体含义由业务定义）。
         if ("role_teacher".equals(SecurityUtil.getRole())) {
+            // 如果是教师角色，调用repoMapper的selectRepoList方法，传入题库标题和当前用户ID，获取该教师创建的符合标题模糊查询条件的题库列表。
             list = repoMapper.selectRepoList(repoTitle, SecurityUtil.getUserId());
         } else {
+            // 如果不是教师角色（可能是其他角色，比如管理员等），调用repoMapper的selectRepoList方法，传入题库标题和默认值0（具体含义由业务决定，可能表示获取所有或公共的题库等情况），获取相应的题库列表。
             list = repoMapper.selectRepoList(repoTitle, 0);
         }
+        // 返回包含查询到的题库列表信息的成功结果信息，方便前端展示给用户查看。
         return Result.success("获取成功", list);
     }
 
+    // 获取题库分页信息的方法，根据当前用户角色（教师或其他角色）、页码、每页数量以及传入的题库标题模糊查询条件，从数据库中获取相应的分页题库信息，返回包含分页结果的成功提示信息。
     @Override
     public Result<IPage<RepoVO>> pagingRepo(Integer pageNum, Integer pageSize, String title) {
 
+        // 创建一个IPage对象，用于封装分页相关信息，设置当前页码和每页显示数量。
         IPage<RepoVO> page = new Page<>(pageNum, pageSize);
 
+        // 判断当前用户角色是否为"role_teacher"（通常代表教师角色，具体含义由业务定义）。
         if ("role_teacher".equals(SecurityUtil.getRole())) {
-            //教师只查询自己的题库
+            // 如果是教师角色，调用repoMapper的pagingRepo方法，传入分页对象、题库标题和当前用户ID，获取该教师创建的符合标题模糊查询条件的分页题库信息，将结果赋值给page对象。
             page = repoMapper.pagingRepo(page, title, SecurityUtil.getUserId());
         } else {
-            //管理员可以获取所有题库
+            // 如果不是教师角色（可能是其他角色，比如管理员等），调用repoMapper的pagingRepo方法，传入分页对象、题库标题和默认值0（具体含义由业务决定，可能表示获取所有或公共的题库等情况），获取相应的分页题库信息，将结果赋值给page对象。
             page = repoMapper.pagingRepo(page, title, 0);
         }
 
+        // 返回包含分页题库信息的成功结果信息，方便前端进行分页展示等操作，这里第一个参数为null，可能是预留用于传递其他提示信息等情况。
         return Result.success(null, page);
     }
 
+    // 获取包含练习相关信息的题库信息的方法，根据页码、每页数量以及传入的题库标题模糊查询条件，从数据库中获取相应的分页题库信息，并可以进一步填充每个题库的刷题次数等相关练习信息（当前代码中填充刷题次数的逻辑被注释掉了），返回包含分页结果的成功提示信息。
     @Override
     public Result<IPage<ExerciseRepoVO>> getRepo(Integer pageNum, Integer pageSize, String title) {
+        // 创建一个IPage对象，用于封装分页相关信息，设置当前页码和每页显示数量。
         IPage<ExerciseRepoVO> page = new Page<>(pageNum, pageSize);
+        // 调用repoMapper的selectRepo方法，传入分页对象和题库标题，获取相应的分页题库信息，将结果赋值给page对象。
         page = repoMapper.selectRepo(page, title);
 //        page.getRecords().forEach(repoVO -> {
 //            //填充以刷题数
 //            LambdaQueryWrapper<ExerciseRecord> wrapper = new LambdaQueryWrapper<ExerciseRecord>().eq(ExerciseRecord::getRepoId, repoVO.getId())
-//                    .eq(ExerciseRecord::getUserId, SecurityUtil.getUserId());
+//                   .eq(ExerciseRecord::getUserId, SecurityUtil.getUserId());
 //
 //            repoVO.setExerciseCount(exerciseRecordMapper.selectCount(wrapper).intValue());
 
 //        });
+        // 返回包含分页题库信息的成功结果信息，方便前端进行分页展示等操作，这里第一个参数为null，可能是预留用于传递其他提示信息等情况。
         return Result.success(null, page);
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/RoleServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/RoleServiceImpl.java
index 8cbee1a..3b22ccf 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/RoleServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/RoleServiceImpl.java
@@ -1,20 +1,29 @@
 package cn.org.alan.exam.service.impl;
 
+// 导入RoleMapper接口，它是用于操作角色（Role）相关数据的持久层接口，比如对角色数据进行增删改查等操作（从命名推测其功能）
 import cn.org.alan.exam.mapper.RoleMapper;
+// 导入Role实体类，代表角色相关的实体对象，包含了角色的各种属性信息，例如角色名称、角色权限等
 import cn.org.alan.exam.model.entity.Role;
+// 导入IRoleService接口，该接口定义了角色相关的业务服务方法，规定了具体有哪些业务操作需要实现，例如获取角色列表、添加角色等
 import cn.org.alan.exam.service.IRoleService;
+// 导入ServiceImpl类，这是MyBatis Plus提供的基础服务实现类，它提供了很多通用的数据库操作方法，方便在此基础上扩展具体业务逻辑的实现
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入Spring的Service注解，用于标记该类是一个服务层组件，Spring容器会对其进行管理，使其能够参与依赖注入等相关机制
 import org.springframework.stereotype.Service;
 
 /**
  * <p>
- *  服务实现类
+ *  服务实现类，这里应该是针对角色相关业务逻辑的服务实现类（可根据具体业务完善文档注释内容进一步明确其功能）
  * </p>
  *
  * @author WeiJin
  * @since 2024-03-21
  */
+// 使用@Service注解将该类标记为Spring容器管理的服务层组件，意味着在Spring应用中可以通过依赖注入的方式在其他地方使用这个服务类
 @Service
+// 定义RoleServiceImpl类，它继承自ServiceImpl<RoleMapper, Role>，同时实现了IRoleService接口
+// 通过继承ServiceImpl可以复用其中已有的通用数据库操作方法，再按照IRoleService接口中定义的业务方法来实现具体针对角色的业务逻辑
+// 目前类体为空，表示暂时没有添加额外的业务方法实现，如果后续有添加角色、删除角色、查询角色等业务逻辑相关的方法，就需要在这里进行具体的编写
 public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements IRoleService {
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/StatServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/StatServiceImpl.java
index 92959ad..b14f9cc 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/StatServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/StatServiceImpl.java
@@ -22,7 +22,7 @@ import java.util.List;
 
 /**
  * <p>
- * 服务实现类
+ * 服务实现类，用于实现统计相关业务逻辑的服务层类，例如获取班级人数统计、试卷统计等各类统计信息。
  * </p>
  *
  * @author WeiJin
@@ -31,82 +31,117 @@ import java.util.List;
 @Service
 public class StatServiceImpl extends ServiceImpl<ExamGradeMapper, ExamGrade> implements IStatService {
 
+    // 使用 @Resource 注解注入 StatMapper，用于操作统计相关数据的持久层接口，可能包含各种统计查询方法（从命名推测其功能）
     @Resource
     private StatMapper statMapper;
+    // 注入 GradeMapper，用于操作班级相关数据的持久层接口，比如查询班级数量等操作（在统计班级相关信息时可能会用到）
     @Resource
     private GradeMapper gradeMapper;
+    // 注入 ExamMapper，用于操作考试相关数据的持久层接口，例如查询考试数量等操作（在统计考试相关信息时可能会用到）
     @Resource
     private ExamMapper examMapper;
+    // 注入 QuestionMapper，用于操作题目相关数据的持久层接口，像查询题目数量等操作（在统计题目相关信息时可能会用到）
     @Resource
     private QuestionMapper questionMapper;
+    // 注入 UserDailyLoginDurationMapper，用于操作用户每日登录时长相关数据的持久层接口，推测在获取每日相关统计信息时会用到
     @Resource
     private UserDailyLoginDurationMapper userDailyLoginDurationMapper;
 
-
     /**
-     * 各班人数统计信息
+     * 各班人数统计信息的方法，根据当前用户角色（教师或其他角色）从数据库获取相应的各班人数统计信息，并返回包含查询结果的成功提示信息。
      *
-     * @return
+     * @return 包含各班人数统计信息的 Result 结果对象，成功时包含具体数据及提示信息。
      */
     @Override
     public Result<List<GradeStudentVO>> getStudentGradeCount() {
-        //获取班级
+        // 定义用于存储各班人数统计信息的列表，类型为 GradeStudentVO，初始未赋值。
         List<GradeStudentVO> gradeStudentVOs;
+        // 判断当前用户角色是否为 "role_teacher"（通常代表教师角色，具体含义由业务定义）。
         if ("role_teacher".equals(SecurityUtil.getRole())) {
+            // 如果是教师角色，调用 statMapper 的 StudentGradeCount 方法，传入参数 2 和当前用户 ID，获取该教师相关的各班人数统计信息。
+            // 这里的参数 2 具体含义可能由业务逻辑决定，可能是用于区分不同的统计条件或筛选情况等。
             gradeStudentVOs = statMapper.StudentGradeCount(2, SecurityUtil.getUserId());
         } else {
+            // 如果不是教师角色（可能是其他角色，比如管理员等），调用 statMapper 的 StudentGradeCount 方法，传入参数 3 和当前用户 ID，获取相应的各班人数统计信息。
+            // 同样，参数 3 的具体含义由业务逻辑确定，用于特定的统计筛选等情况。
             gradeStudentVOs = statMapper.StudentGradeCount(3, SecurityUtil.getUserId());
         }
 
+        // 返回包含各班人数统计信息的成功结果信息，方便前端展示给用户查看，"查询成功" 为提示消息，gradeStudentVOs 为具体的数据列表。
         return Result.success("查询成功", gradeStudentVOs);
     }
 
     /**
-     * 各班试卷统计信息
+     * 各班试卷统计信息的方法，根据当前用户角色（教师或其他角色）从数据库获取相应的各班试卷统计信息，并返回包含查询结果的成功提示信息。
      *
-     * @return
+     * @return 包含各班试卷统计信息的 Result 结果对象，成功时包含具体数据及提示信息。
      */
     @Override
     public Result<List<GradeExamVO>> getExamGradeCount() {
-        //获取班级
+        // 定义用于存储各班试卷统计信息的列表，类型为 GradeExamVO，初始未赋值。
         List<GradeExamVO> gradeExamVOs;
+        // 判断当前用户角色是否为 "role_teacher"（通常代表教师角色，具体含义由业务定义）。
         if ("role_teacher".equals(SecurityUtil.getRole())) {
+            // 如果是教师角色，调用 statMapper 的 ExamGradeCount 方法，传入参数 2 和当前用户 ID，获取该教师相关的各班试卷统计信息。
+            // 参数 2 的具体含义同上述类似，由业务逻辑决定，用于特定的统计条件或筛选情况。
             gradeExamVOs = statMapper.ExamGradeCount(2, SecurityUtil.getUserId());
         } else {
+            // 如果不是教师角色（可能是其他角色，比如管理员等），调用 statMapper 的 ExamGradeCount 方法，传入参数 3 和当前用户 ID，获取相应的各班试卷统计信息。
             gradeExamVOs = statMapper.ExamGradeCount(3, SecurityUtil.getUserId());
         }
 
+        // 返回包含各班试卷统计信息的成功结果信息，便于前端展示给用户，"查询成功" 为提示消息，gradeExamVOs 为具体的数据列表。
         return Result.success("查询成功", gradeExamVOs);
     }
 
     /**
-     * 所有班级、试卷、试题数量统计信息
+     * 所有班级、试卷、试题数量统计信息的方法，根据当前用户角色（管理员或教师）分别统计相应的班级、试卷、试题数量，封装到 AllStatsVO 对象中并返回包含该对象的成功提示信息。
      *
-     * @return
+     * @return 包含所有班级、试卷、试题数量统计信息的 Result 结果对象，成功时包含具体数据及提示信息。
      */
     @Override
     public Result<AllStatsVO> getAllCount() {
+        // 创建一个 AllStatsVO 对象，用于封装所有班级、试卷、试题数量的统计信息，初始各属性值为空。
         AllStatsVO allStatsVO = new AllStatsVO();
+        // 获取当前用户的角色信息，用于后续判断是管理员还是教师角色来进行不同的统计逻辑。
         String role = SecurityUtil.getRole();
-        if("role_admin".equals(role)){
+        // 判断当前用户角色是否为 "role_admin"（通常代表管理员角色，具体含义由业务定义）。
+        if ("role_admin".equals(role)) {
+            // 如果是管理员角色，通过 gradeMapper 的 selectCount 方法，传入 null（表示无额外查询条件，统计所有班级数量）获取班级总数，并设置到 allStatsVO 对象中。
             allStatsVO.setClassCount(gradeMapper.selectCount(null).intValue());
+            // 同样，通过 examMapper 的 selectCount 方法，传入 null（统计所有考试数量）获取考试总数，设置到 allStatsVO 对象中。
             allStatsVO.setExamCount(examMapper.selectCount(null).intValue());
+            // 通过 questionMapper 的 selectCount 方法，传入 null（统计所有题目数量）获取题目总数，设置到 allStatsVO 对象中。
             allStatsVO.setQuestionCount(questionMapper.selectCount(null).intValue());
-        }else if("role_teacher".equals(role)){
+        } else if ("role_teacher".equals(role)) {
+            // 如果是教师角色，通过 gradeMapper 的 selectCount 方法，传入一个 LambdaQueryWrapper 对象，设置查询条件为班级所属用户 ID 等于当前教师的用户 ID，获取该教师创建的班级数量，并设置到 allStatsVO 对象中。
             allStatsVO.setClassCount(gradeMapper.selectCount(new LambdaQueryWrapper<Grade>().eq(Grade::getUserId,
-                    SecurityUtil.getUserId())).intValue());
+                            SecurityUtil.getUserId()))
+                    .intValue());
+            // 通过 examMapper 的 selectCount 方法，传入一个 LambdaQueryWrapper 对象，设置查询条件为考试创建者用户 ID 等于当前教师的用户 ID，获取该教师创建的考试数量，并设置到 allStatsVO 对象中。
             allStatsVO.setExamCount(examMapper.selectCount(
-                    new LambdaQueryWrapper<Exam>().eq(Exam::getUserId,SecurityUtil.getUserId())).intValue());
+                            new LambdaQueryWrapper<Exam>().eq(Exam::getUserId, SecurityUtil.getUserId()))
+                    .intValue());
+            // 通过 questionMapper 的 selectCount 方法，传入一个 LambdaQueryWrapper 对象，设置查询条件为题目创建者用户 ID 等于当前教师的用户 ID，获取该教师创建的题目数量，并设置到 allStatsVO 对象中。
             allStatsVO.setQuestionCount(questionMapper.selectCount(
-                    new LambdaQueryWrapper<Question>().eq(Question::getUserId,SecurityUtil.getUserId())).intValue());
+                            new LambdaQueryWrapper<Question>().eq(Question::getUserId, SecurityUtil.getUserId()))
+                    .intValue());
         }
+
+        // 返回包含所有统计信息的成功结果信息，方便前端展示给用户查看，"查询成功" 为提示消息，allStatsVO 为包含具体统计数据的对象。
         return Result.success("查询成功", allStatsVO);
     }
 
+    /**
+     * 获取每日相关统计信息的方法，根据当前用户 ID 从数据库获取相应的每日统计信息，并返回包含查询结果的成功提示信息。
+     *
+     * @return 包含每日统计信息的 Result 结果对象，成功时包含具体数据及提示信息。
+     */
     @Override
     public Result<List<DailyVO>> getDaily() {
+        // 调用 userDailyLoginDurationMapper 的 getDaily 方法，传入当前用户 ID，获取该用户的每日相关统计信息（从方法名推测可能是登录时长等相关信息），返回一个 DailyVO 类型的列表。
         List<DailyVO> daily = userDailyLoginDurationMapper.getDaily(SecurityUtil.getUserId());
-        return Result.success("请求成功",daily);
+        // 返回包含每日统计信息的成功结果信息，便于前端展示给用户，"请求成功" 为提示消息，daily 为具体的数据列表。
+        return Result.success("请求成功", daily);
     }
-}
-
+}
\ No newline at end of file
-- 
2.34.1


From c6b83d29f166fd21235e485f36af5bb98fae220e Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Wed, 18 Dec 2024 16:57:36 +0800
Subject: [PATCH 08/10] main1122

---
 .../service/impl/UserBookServiceImpl.java     | 130 +++++++------
 .../UserDailyLoginDurationServiceImpl.java    |  15 +-
 .../impl/UserExamsScoreServiceImpl.java       |  55 +++++-
 .../impl/UserExerciseRecordServiceImpl.java   |  13 +-
 .../exam/service/impl/UserServiceImpl.java    | 171 +++++++-----------
 5 files changed, 209 insertions(+), 175 deletions(-)

diff --git a/src/main/java/cn/org/alan/exam/service/impl/UserBookServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/UserBookServiceImpl.java
index 50250c5..94c8b35 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/UserBookServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/UserBookServiceImpl.java
@@ -28,183 +28,195 @@ import java.util.*;
 import java.util.stream.Collectors;
 
 /**
- * 错题本服务实现类
+ * 错题本服务实现类，用于实现错题本相关业务逻辑，例如获取错题本分页数据、错题详情等操作。
  *
  * @author Alan
  * @since 2024-03-21
  */
 @Service
 public class UserBookServiceImpl extends ServiceImpl<UserBookMapper, UserBook> implements IUserBookService {
+    // 注入UserBookMapper，用于操作错题本数据的持久层接口，比如查询错题本记录、插入、删除错题本相关数据等操作。
     @Resource
     private UserBookMapper userBookMapper;
+    // 注入QuestionMapper，用于操作题目数据的持久层接口，可能在获取错题对应的题目详情等操作中使用。
     @Resource
     private QuestionMapper questionMapper;
+    // 注入OptionMapper，用于操作题目选项数据的持久层接口，例如获取题目选项信息等操作（与题目相关联）。
     @Resource
     private OptionMapper optionMapper;
+    // 注入ExamQuAnswerMapper，可能用于操作考试题目答案相关数据的持久层接口（从命名推测其功能）。
     @Resource
     private ExamQuAnswerMapper examQuAnswerMapper;
+    // 注入UserBookConverter，用于不同错题本相关对象之间的转换（比如实体对象和视图对象等）。
     @Resource
     private UserBookConverter userBookConverter;
+    // 注入IQuestionService，这是题目相关的业务服务接口，可调用其中已定义的题目相关业务方法（如获取题目详情等）。
     @Resource
     private IQuestionService questionService;
+    // 注入IOptionService，这是题目选项相关的业务服务接口，可调用其中已定义的选项相关业务方法（如获取选项详情等）。
     @Resource
     private IOptionService optionService;
 
+    // 获取错题本分页数据的方法，根据页码、每页数量以及考试名称等条件，返回包含分页信息和错题本视图对象列表的结果。
     @Override
     public Result<IPage<UserPageBookVO>> getPage(Integer pageNum, Integer pageSize, String examName) {
+        // 创建一个Page对象，用于封装分页相关信息，设置当前页码和每页显示数量。
         Page<UserPageBookVO> page = new Page<>(pageNum, pageSize);
+        // 获取当前用户的角色信息，用于后续判断不同角色的逻辑处理（可能涉及不同权限查看不同数据等情况）。
         String role = SecurityUtil.getRole();
         int roleId = 0;
-        if("role_admin".equals(role)){
-            roleId =3;
-        }else if ("role_teacher".equals(role)){
+        // 根据用户角色进行不同的角色ID赋值，这里假设不同角色有对应的数字标识（具体含义由业务定义）。
+        if ("role_admin".equals(role)) {
+            roleId = 3;
+        } else if ("role_teacher".equals(role)) {
             roleId = 2;
-        }else {
+        } else {
             roleId = 1;
         }
-        Page<UserPageBookVO> userPageBookVOPage = userBookMapper.selectPageVo(page, examName, SecurityUtil.getUserId(),roleId);
+        // 调用userBookMapper的selectPageVo方法，传入分页对象、考试名称、当前用户ID以及角色ID，获取符合条件的错题本分页数据（具体查询逻辑在该方法内部实现），并将结果赋值给userPageBookVOPage对象。
+        Page<UserPageBookVO> userPageBookVOPage = userBookMapper.selectPageVo(page, examName, SecurityUtil.getUserId(), roleId);
+        // 返回包含分页信息和错题本视图对象列表的成功结果信息，方便前端进行分页展示等操作，"查询成功" 为提示消息，userPageBookVOPage为具体的分页数据对象。
         return Result.success("查询成功", userPageBookVOPage);
     }
 
+    // 根据考试ID获取对应的错题本信息（转换为特定视图对象列表）的方法，返回包含查询结果的成功提示信息。
     @Override
     public Result<List<ReUserExamBookVO>> getReUserExamBook(Integer examId) {
-        // 根据考试id查询考试试题表
+        // 根据考试id查询考试试题表，创建一个LambdaQueryWrapper对象，用于构建查询错题本记录的条件，这里设置考试ID和用户ID作为查询条件。
         LambdaQueryWrapper<UserBook> userBookLambdaQueryWrapper = new LambdaQueryWrapper<>();
         userBookLambdaQueryWrapper.eq(UserBook::getExamId, examId)
                 .eq(UserBook::getUserId, SecurityUtil.getUserId());
+        // 调用userBookMapper的selectList方法，根据构建的查询条件获取符合条件的错题本记录列表（即UserBook实体对象列表）。
         List<UserBook> userBook = userBookMapper.selectList(userBookLambdaQueryWrapper);
-        // 实体转换
+        // 进行实体转换，调用userBookConverter的listEntityToVo方法，将获取到的UserBook实体对象列表转换为ReUserExamBookVO视图对象列表，方便后续返回展示给前端等操作。
         List<ReUserExamBookVO> reUserExamBookVOS = userBookConverter.listEntityToVo(userBook);
+        // 返回包含查询到的错题本视图对象列表的成功结果信息，便于前端展示给用户查看，"查询成功" 为提示消息，reUserExamBookVOS为具体的数据列表。
         return Result.success("查询成功", reUserExamBookVOS);
     }
 
+    // 根据题目ID获取错题本中一道题目的详细信息的方法，返回包含该题目详细信息的视图对象的成功提示信息，如果题目不存在则返回相应错误提示。
     @Override
     public Result<BookOneQuVO> getBookOne(Integer quId) {
+        // 创建一个BookOneQuVO对象，用于封装要返回的错题本中一道题目的详细信息，初始各属性值为空。
         BookOneQuVO bookOneQuVO = new BookOneQuVO();
-        // 问题
+        // 通过questionService的getById方法（调用了Question相关业务服务接口的方法），根据题目ID获取对应的题目详细信息（Question实体对象），用于后续设置错题本中题目详情相关属性。
         Question quById = questionService.getById(quId);
-        if( quById==null){
+        // 如果获取到的题目实体对象为空，即该题不存在，返回相应的错误提示信息。
+        if (quById == null) {
             return Result.failed("该题不存在");
         }
 
-        // 基本信息
+        // 设置错题本中题目视图对象的图片信息属性，取值为从题目实体对象中获取的图片信息（假设题目实体中有保存图片相关字段）。
         bookOneQuVO.setImage(quById.getImage());
+        // 设置错题本中题目视图对象的题目内容属性，取值为从题目实体对象中获取的题目内容。
         bookOneQuVO.setContent(quById.getContent());
+        // 设置错题本中题目视图对象的题目类型属性，取值为从题目实体对象中获取的题目类型（例如单选题、多选题等不同类型的标识）。
         bookOneQuVO.setQuType(quById.getQuType());
-        // 答案列表
+        // 查询该题目的答案列表，创建一个LambdaQueryWrapper对象，用于构建查询题目选项的条件，这里设置题目ID作为查询条件，用于获取该题对应的所有选项信息。
         LambdaQueryWrapper<Option> optionLambdaQuery = new LambdaQueryWrapper<>();
         optionLambdaQuery.eq(Option::getQuId, quId);
+        // 调用optionMapper的selectList方法，根据构建的查询条件获取符合条件的题目选项列表（即Option实体对象列表），并设置到错题本中题目视图对象的答案列表属性中。
         List<Option> list = optionMapper.selectList(optionLambdaQuery);
         bookOneQuVO.setAnswerList(list);
+        // 返回包含错题本中一道题目的详细信息的成功结果信息，方便前端展示给用户查看，"获取成功" 为提示消息，bookOneQuVO为具体的题目详细信息视图对象。
         return Result.success("获取成功", bookOneQuVO);
     }
+
+    // 处理错题本中题目作答情况并返回相应结果的方法，根据传入的错题作答表单信息，判断作答是否正确、移除已答对的错题等操作，并返回对应的结果信息。
     @Override
     public Result<AddBookAnswerVO> addBookAnswer(ReUserBookForm reUserBookForm) {
-        // 创建返回视图
+        // 创建一个AddBookAnswerVO对象，用于封装要返回的错题作答相关结果信息，初始各属性值为空。
         AddBookAnswerVO addBookAnswerVO = new AddBookAnswerVO();
-        // 未作答
+        // 判断用户是否未作答，如果传入的答案为空字符串（通过StringUtils工具类判断），则直接返回表示未作答的成功提示信息。
         if (StringUtils.isBlank(reUserBookForm.getAnswer())) {
             return Result.success("未作答");
         }
-        // 查询试题类型
+        // 查询试题类型，创建一个LambdaQueryWrapper对象，用于构建查询题目的条件，这里设置题目ID作为查询条件，用于获取对应的题目详细信息（主要是获取题目类型）。
         LambdaQueryWrapper<Question> QuWrapper = new LambdaQueryWrapper<>();
         QuWrapper.eq(Question::getId, reUserBookForm.getQuId());
+        // 调用questionMapper的selectOne方法，根据构建的查询条件获取对应的题目详细信息（这里获取到的是Question实体对象，因为使用selectOne，预期返回单个题目对象）。
         Question qu = questionMapper.selectOne(QuWrapper);
+        // 获取题目类型（从题目实体对象中获取题目类型字段的值），用于后续根据不同题目类型进行不同的作答判断逻辑。
         Integer quType = qu.getQuType();
-        // 设置试题分析
+        // 设置试题分析属性，取值为从题目实体对象中获取的试题分析内容（假设题目实体中有保存试题分析相关字段），将其设置到要返回的结果视图对象中。
         addBookAnswerVO.setAnalysis(qu.getAnalysis());
-        // 设置正确答案
+        // 设置正确答案属性，先创建一个LambdaQueryWrapper对象，用于构建查询题目选项的条件，这里设置题目ID作为查询条件，用于获取该题对应的所有选项信息。
         LambdaQueryWrapper<Option> opWrapper = new LambdaQueryWrapper<>();
         opWrapper.eq(Option::getQuId, reUserBookForm.getQuId());
+        // 调用optionMapper的selectList方法，根据构建的查询条件获取符合条件的题目选项列表（即Option实体对象列表）。
         List<Option> options = optionMapper.selectList(opWrapper);
+        // 初始化一个空字符串，用于后续拼接正确答案（在某些题目类型下可能需要拼接多个正确答案等情况）。
         String current = "";
+        // 创建一个ArrayList，用于存储正确答案对应的序号（在某些题目类型下可能需要根据序号来判断答案情况等），初始为空。
         ArrayList<Integer> strings = new ArrayList<>();
+        // 遍历获取到的题目选项列表，找出其中标记为正确答案的选项（通过判断选项实体对象中的是否正确标识字段，假设为isRight，值为1表示正确），将其序号添加到strings列表中。
         for (Option temp : options) {
             if (temp.getIsRight() == 1) {
                 strings.add(temp.getSort());
             }
         }
+        // 将strings列表中的序号转换为字符串列表，方便后续拼接等操作，使用Java 8的Stream API进行转换。
         List<String> stringList = strings.stream().map(String::valueOf).collect(Collectors.toList());
+        // 使用逗号将字符串列表中的元素拼接成一个字符串，得到正确答案的表示形式（例如对于多选题可能有多个正确答案，用逗号分隔）。
         String result = String.join(",", stringList);
-        if(quType ==4){
+        // 如果题目类型是简答题（假设题目类型4代表简答题），设置正确答案属性为题目选项列表中的第一个选项的内容（简答题通常可能只有一个用于填写答案的选项，这里从代码逻辑推测）。
+        if (quType == 4) {
             addBookAnswerVO.setRightAnswers(options.get(0).getContent());
-        }else{
+        } else {
+            // 如果不是简答题，设置正确答案属性为前面拼接好的正确答案字符串（包含多个正确答案用逗号分隔的情况等）。
             addBookAnswerVO.setRightAnswers(result);
         }
 
-        // 判断是否正确并移除正确试题
+        // 根据不同的题目类型进行不同的作答判断逻辑，使用Java 17的新特性switch表达式来简化代码结构，根据作答情况返回相应的结果信息。
         return switch (quType) {
+            // 题目类型为单选题的情况
             case 1 -> {
+                // 通过optionService的getById方法（调用了Option相关业务服务接口的方法），根据用户作答的选项ID获取对应的选项详细信息（Option实体对象），用于判断作答是否正确。
                 Option byId = optionService.getById(reUserBookForm.getAnswer());
+                // 如果获取到的选项对象中标记为正确答案（通过判断选项实体对象中的是否正确标识字段，值为1表示正确），说明回答正确，进行相应操作。
                 if (byId.getIsRight() == 1) {
+                    // 创建一个LambdaQueryWrapper对象，用于构建删除错题本记录的条件，这里设置用户ID、考试ID和题目ID作为查询条件，用于定位要删除的错题本记录（即已答对的错题，从错题本中移除）。
                     LambdaQueryWrapper<UserBook> userBookLambdaQueryWrapper = new LambdaQueryWrapper<>();
                     userBookLambdaQueryWrapper.eq(UserBook::getUserId, SecurityUtil.getUserId())
                             .eq(UserBook::getExamId, reUserBookForm.getExamId())
                             .eq(UserBook::getQuId, reUserBookForm.getQuId());
+                    // 调用userBookMapper的delete方法，根据构建的条件删除对应的错题本记录，返回受影响的行数（即实际删除的记录数），这里暂时未使用该返回值。
                     int row = userBookMapper.delete(userBookLambdaQueryWrapper);
+                    // 设置回答正确标识为1，表示回答正确，将其设置到要返回的结果视图对象中。
                     addBookAnswerVO.setCorrect(1);
+                    // 使用yield关键字返回表示回答正确且已移出错题本的成功提示信息，包含更新后的结果视图对象addBookAnswerVO。
                     yield Result.success("回答正确，已移出错题本", addBookAnswerVO);
                 } else {
+                    // 如果选项对象不是正确答案，设置回答正确标识为0，表示回答错误，将其设置到要返回的结果视图对象中。
                     addBookAnswerVO.setCorrect(0);
+                    // 使用yield关键字返回表示回答错误的成功提示信息，包含结果视图对象addBookAnswerVO。
                     yield Result.success("回答错误", addBookAnswerVO);
                 }
 
             }
+            // 题目类型为多选题的情况
             case 2 -> {
-                // 查找正确答案
+                // 查找正确答案，创建一个LambdaQueryWrapper对象，用于构建查询正确选项的条件，这里设置选项为正确答案（通过判断选项实体对象中的是否正确标识字段，值为1表示正确）以及题目ID作为查询条件，用于获取该题对应的所有正确选项信息。
                 LambdaQueryWrapper<Option> optionWrapper = new LambdaQueryWrapper<>();
                 optionWrapper.eq(Option::getIsRight, 1)
                         .eq(Option::getQuId, reUserBookForm.getQuId());
+                // 调用optionMapper的selectList方法，根据构建的查询条件获取符合条件的正确选项列表（即Option实体对象列表）。
                 List<Option> examQuAnswers = optionMapper.selectList(optionWrapper);
-                // 解析用户作答
+                // 解析用户作答，将用户传入的以逗号分隔的作答字符串转换为整数列表（假设用户作答的是选项的ID，用逗号分隔多个选项ID），使用Java 8的Stream API进行转换。
                 List<Integer> quIds = Arrays.stream(reUserBookForm.getAnswer().split(","))
                         .map(Integer::parseInt)
                         .toList();
-                // 判读啊是否正确
+                // 判读啊是否正确（这里可能代码有拼写错误，正确应为“判断”，以下按照正确逻辑解读注释），遍历正确选项列表，检查用户作答的选项ID列表中是否包含当前正确选项的ID，如果包含则说明回答错误（因为多选题需要全部选对才正确）。
                 for (Option temp : examQuAnswers) {
                     boolean containsBanana = quIds.contains(temp.getId());
                     if (containsBanana) {
                         yield Result.success("回答错误");
                     }
                 }
+                // 如果遍历完所有正确选项，用户作答的选项ID列表都不包含正确选项的ID，说明回答正确，进行相应操作。
                 LambdaQueryWrapper<UserBook> userBookWrapper = new LambdaQueryWrapper<>();
                 userBookWrapper.eq(UserBook::getUserId, SecurityUtil.getUserId())
                         .eq(UserBook::getExamId, reUserBookForm.getExamId())
                         .eq(UserBook::getQuId, reUserBookForm.getQuId());
                 userBookMapper.delete(userBookWrapper);
-                yield Result.success("回答正确");
-            }
-            case 3 -> {
-                Option byId = optionService.getById(reUserBookForm.getAnswer());
-                if (byId.getIsRight() == 1) {
-                    LambdaQueryWrapper<UserBook> userBookLambdaQueryWrapper = new LambdaQueryWrapper<>();
-                    userBookLambdaQueryWrapper.eq(UserBook::getUserId, SecurityUtil.getUserId())
-                            .eq(UserBook::getExamId, reUserBookForm.getExamId())
-                            .eq(UserBook::getQuId, reUserBookForm.getQuId());
-                    userBookMapper.delete(userBookLambdaQueryWrapper);
-                    addBookAnswerVO.setCorrect(1);
-                    yield Result.success("回答正确，已移除错题本", addBookAnswerVO);
-                } else {
-                    addBookAnswerVO.setCorrect(0);
-                    yield Result.success("回答错误", addBookAnswerVO);
-                }
-            }
-            case 4 -> {
-                if("1".equals(reUserBookForm.getAnswer())){
-                    LambdaQueryWrapper<UserBook> userBookLambdaQueryWrapper = new LambdaQueryWrapper<>();
-                    userBookLambdaQueryWrapper.eq(UserBook::getUserId, SecurityUtil.getUserId())
-                            .eq(UserBook::getExamId, reUserBookForm.getExamId())
-                            .eq(UserBook::getQuId, reUserBookForm.getQuId());
-                    userBookMapper.delete(userBookLambdaQueryWrapper);
-                    yield Result.success("回答正确，已移除错题本", addBookAnswerVO);
-                }
-                addBookAnswerVO.setCorrect(0);
-                yield Result.success("回答错误", addBookAnswerVO);
-
-            }
-            default -> {
-                yield Result.failed("请求错误，请联系管理员解决");
-            }
-        };
-    }
-}
+                yield Result.success("回答正确");
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/UserDailyLoginDurationServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/UserDailyLoginDurationServiceImpl.java
index 25adfba..35d9495 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/UserDailyLoginDurationServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/UserDailyLoginDurationServiceImpl.java
@@ -1,19 +1,32 @@
 package cn.org.alan.exam.service.impl;
 
+// 导入UserDailyLoginDurationMapper接口，它是用于操作用户每日登录时长（UserDailyLoginDuration）相关数据的持久层接口，比如对用户每日登录时长数据进行增删改查等操作（从命名推测其功能）
 import cn.org.alan.exam.mapper.UserDailyLoginDurationMapper;
+// 导入UserExamsScoreMapper接口，它是用于操作用户考试成绩（UserExamsScore）相关数据的持久层接口，可用于对用户考试成绩数据进行相应的数据库操作（从命名推测其功能），此处虽然当前类未直接使用，但可能是在整个项目的相关业务逻辑中存在关联导入的情况
 import cn.org.alan.exam.mapper.UserExamsScoreMapper;
+// 导入UserDailyLoginDuration实体类，代表用户每日登录时长相关的实体对象，包含了如登录日期、登录时长等各种属性信息，用于存储和传递与用户每日登录时长相关的数据
 import cn.org.alan.exam.model.entity.UserDailyLoginDuration;
+// 导入UserExamsScore实体类，代表用户考试成绩相关的实体对象，包含了如考试ID、用户ID、成绩分数等属性信息，用于体现用户在不同考试中的成绩情况
 import cn.org.alan.exam.model.entity.UserExamsScore;
+// 导入IUserDailyLoginDurationService接口，该接口定义了用户每日登录时长相关的业务服务方法，规定了具体有哪些业务操作需要实现，例如获取用户某段时间内的登录时长统计、记录每日登录时长等
 import cn.org.alan.exam.service.IUserDailyLoginDurationService;
+// 导入IUserExamsScoreService接口，该接口定义了用户考试成绩相关的业务服务方法，像查询用户特定考试成绩、更新成绩等操作（同样，虽当前类未直接关联使用，但可能在整体业务中有联系）
 import cn.org.alan.exam.service.IUserExamsScoreService;
+// 导入ServiceImpl类，这是MyBatis Plus提供的基础服务实现类，它提供了很多通用的数据库操作方法，方便在此基础上扩展具体业务逻辑的实现，减少重复代码编写，提高开发效率
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入Spring的Service注解，用于标记该类是一个服务层组件，Spring容器会对其进行管理，使其能够参与依赖注入等相关机制，便于在其他组件中方便地调用该服务类的方法
 import org.springframework.stereotype.Service;
 
 /**
  * @Author Alan
  * @Version
  * @Date 2024/5/28 10:46 PM
+ * 这是用户每日登录时长服务的实现类，应该是针对用户每日登录时长相关业务逻辑的服务实现类（可根据具体业务完善文档注释内容进一步明确其功能）
  */
 @Service
+// 定义UserDailyLoginDurationServiceImpl类，它继承自ServiceImpl<UserDailyLoginDurationMapper, UserDailyLoginDuration>，同时实现了IUserDailyLoginDurationService接口
+// 通过继承ServiceImpl可以复用其中已有的通用数据库操作方法，再按照IUserDailyLoginDurationService接口中定义的业务方法来实现具体针对用户每日登录时长的业务逻辑
+// 目前类体为空，表示暂时没有添加额外的业务方法实现，如果后续有添加记录用户每日登录时长、查询用户登录时长统计等业务逻辑相关的方法，就需要在这里进行具体的编写
 public class UserDailyLoginDurationServiceImpl extends ServiceImpl<UserDailyLoginDurationMapper, UserDailyLoginDuration> implements IUserDailyLoginDurationService {
-}
+
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/UserExamsScoreServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/UserExamsScoreServiceImpl.java
index 10eb57d..1eda7ed 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/UserExamsScoreServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/UserExamsScoreServiceImpl.java
@@ -24,7 +24,7 @@ import java.util.List;
 
 /**
  * <p>
- * 服务实现类
+ * 服务实现类，用于实现用户考试成绩相关业务逻辑的服务层类，例如成绩分页查询、成绩导出以及获取考试成绩统计信息等操作。
  * </p>
  *
  * @author WeiJin
@@ -32,46 +32,87 @@ import java.util.List;
  */
 @Service
 public class UserExamsScoreServiceImpl extends ServiceImpl<UserExamsScoreMapper, UserExamsScore> implements IUserExamsScoreService {
+    // 使用 @Resource 注解注入 UserExamsScoreMapper，用于操作用户考试成绩数据的持久层接口，比如查询成绩、插入成绩等数据库操作（从命名推测其功能）。
     @Resource
     private UserExamsScoreMapper userExamsScoreMapper;
+    // 注入 ExamMapper，用于操作考试相关数据的持久层接口，例如查询考试名称等操作（在获取成绩相关信息时可能会用到）。
     @Resource
     private ExamMapper examMapper;
+    // 注入 ExamGradeMapper，用于操作考试成绩等级相关数据的持久层接口（可能涉及成绩等级划分等相关业务逻辑，具体根据业务定义）。
     @Resource
     private ExamGradeMapper examGradeMapper;
 
+    /**
+     * 分页查询用户成绩的方法，根据页码、每页数量、班级ID、考试ID以及真实姓名等条件，从数据库获取相应的分页用户成绩信息，并返回包含分页结果的成功提示信息。
+     *
+     * @param pageNum 页码，用于指定要获取的是第几页的数据。
+     * @param pageSize 每页数量，即每页显示多少条成绩记录。
+     * @param gradeId 班级ID，用于筛选特定班级的学生成绩（可能为null表示不限班级）。
+     * @param examId 考试ID，用于筛选特定考试的成绩记录（可能为null表示不限考试）。
+     * @param realName 真实姓名，用于模糊查询匹配学生姓名的成绩记录（可能为null表示不按姓名筛选）。
+     * @return 包含分页用户成绩信息的 Result 结果对象，成功时包含具体的分页数据及提示信息。
+     */
     @Override
     public Result<IPage<UserScoreVO>> pagingScore(Integer pageNum, Integer pageSize, Integer gradeId, Integer examId, String realName) {
+        // 创建一个 IPage 对象，用于封装分页相关信息，设置当前页码和每页显示数量。
         IPage<UserScoreVO> page = new Page<>(pageNum, pageSize);
+        // 调用 userExamsScoreMapper 的 pagingScore 方法，传入分页对象、班级ID、考试ID以及真实姓名，获取符合条件的分页用户成绩信息，并将结果赋值给 page 对象（具体查询逻辑在该方法内部实现）。
         page = userExamsScoreMapper.pagingScore(page, gradeId, examId, realName);
+        // 返回包含分页用户成绩信息的成功结果信息，方便前端进行分页展示等操作，这里第一个参数为null，可能是预留用于传递其他提示信息等情况，page 为具体的分页数据对象。
         return Result.success(null, page);
     }
 
+    /**
+     * 导出成绩的方法，根据考试ID和班级ID获取成绩信息，为成绩添加排名信息，获取对应的考试名称，然后使用 Excel 工具类将成绩数据生成为 Excel 文件并响应给客户端（通过 HttpServletResponse）。
+     *
+     * @param response HttpServletResponse 对象，用于向客户端发送响应，包含生成的 Excel 文件数据。
+     * @param examId 考试ID，用于筛选要导出成绩的特定考试。
+     * @param gradeId 班级ID，用于筛选特定班级学生的成绩进行导出（可能为null表示导出所有班级的相关成绩）。
+     */
     @Override
     public void exportScores(HttpServletResponse response, Integer examId, Integer gradeId) {
-        //获取成绩信息
+        // 获取成绩信息，调用 userExamsScoreMapper 的 selectScores 方法，传入考试ID和班级ID，从数据库中获取符合条件的成绩数据（以 ExportScoreVO 列表形式返回），这些成绩数据将用于生成 Excel 文件。
         List<ExportScoreVO> scores = userExamsScoreMapper.selectScores(examId, gradeId);
+        // 创建一个长度为1的数组，用于记录排名序号，初始值为0（这里通过数组实现类似引用传递的效果，方便在Lambda表达式中修改值）。
         final int[] sort = {0};
+        // 使用 Lambda 表达式遍历成绩列表，为每个成绩记录设置排名信息，排名序号从1开始自增（通过 ++sort[0] 操作实现自增并赋值给排名字段）。
         scores.forEach(exportScoreVO -> exportScoreVO.setRanking(++sort[0]));
 
-        //获取考试名
+        // 获取考试名，创建一个 LambdaQueryWrapper 对象，用于构建查询考试信息的条件，这里设置考试ID作为查询条件，并指定只查询考试标题字段（通过 select 方法指定），用于获取对应的考试名称（后续用于 Excel 文件的命名等情况）。
         LambdaQueryWrapper<Exam> wrapper = new LambdaQueryWrapper<Exam>().eq(Exam::getId, examId).select(Exam::getTitle);
+        // 调用 examMapper 的 selectOne 方法，根据构建的查询条件获取对应的考试信息（这里获取到的是Exam实体对象，因为使用selectOne，预期返回单个考试对象），从中获取考试名称。
         Exam exam = examMapper.selectOne(wrapper);
-        //生成表格并响应
+
+        // 生成表格并响应，调用 ExcelUtils 工具类的 export 方法，传入 HttpServletResponse 对象、考试名称、成绩数据列表以及成绩数据对应的实体类（ExportScoreVO.class），该方法内部会将成绩数据生成为 Excel 文件，并通过 response 设置响应头和输出流将 Excel 文件发送给客户端。
         ExcelUtils.export(response, exam.getTitle(), scores, ExportScoreVO.class);
 
     }
 
+    /**
+     * 获取考试成绩信息（可能包含统计信息等，根据业务逻辑）的方法，根据页码、每页数量、考试标题以及班级ID等条件，结合当前用户角色（教师或其他角色），从数据库获取相应的分页考试成绩信息，并返回包含分页结果的成功提示信息。
+     *
+     * @param pageNum 页码，用于指定要获取的是第几页的数据。
+     * @param pageSize 每页数量，即每页显示多少条成绩记录。
+     * @param examTitle 考试标题，用于模糊查询匹配特定考试的成绩记录（可能为null表示不限考试标题）。
+     * @param gradeId 班级ID，用于筛选特定班级的学生成绩（可能为null表示不限班级）。
+     * @return 包含分页考试成绩信息的 Result 结果对象，成功时包含具体的分页数据及提示信息。
+     */
     @Override
-    public Result<IPage<GradeScoreVO>> getExamScoreInfo(Integer pageNum, Integer pageSize, String examTitle,Integer gradeId) {
+    public Result<IPage<GradeScoreVO>> getExamScoreInfo(Integer pageNum, Integer pageSize, String examTitle, Integer gradeId) {
+        // 创建一个 IPage 对象，用于封装分页相关信息，设置当前页码和每页显示数量。
         IPage<GradeScoreVO> page = new Page<>(pageNum, pageSize);
+        // 判断当前用户角色是否为 "role_teacher"（通常代表教师角色，具体含义由业务定义）。
         if ("role_teacher".equals(SecurityUtil.getRole())) {
+            // 如果是教师角色，调用 userExamsScoreMapper 的 scoreStatistics 方法，传入分页对象、班级ID、考试标题、当前用户ID以及角色标识2（具体含义由业务逻辑决定，可能用于区分不同的统计条件或权限等情况），获取符合教师角色相关条件的分页考试成绩信息，并将结果赋值给 page 对象（具体查询统计逻辑在该方法内部实现）。
             page = userExamsScoreMapper
-                    .scoreStatistics(page,gradeId,examTitle,SecurityUtil.getUserId(),2);
+                    .scoreStatistics(page, gradeId, examTitle, SecurityUtil.getUserId(), 2);
         } else {
+            // 如果不是教师角色（可能是其他角色，比如管理员等），调用 userExamsScoreMapper 的 scoreStatistics 方法，传入分页对象、班级ID、考试标题、当前用户ID以及角色标识3（同样由业务逻辑确定其含义，用于特定的统计筛选等情况），获取相应的分页考试成绩信息，并将结果赋值给 page 对象。
             page = userExamsScoreMapper
                     .scoreStatistics(page, gradeId, examTitle, SecurityUtil.getUserId(), 3);
         }
 
+        // 返回包含分页考试成绩信息的成功结果信息，方便前端进行展示等操作，"查询成功" 为提示消息，page 为具体的分页数据对象。
         return Result.success("查询成功", page);
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/UserExerciseRecordServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/UserExerciseRecordServiceImpl.java
index f4754ef..48b2788 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/UserExerciseRecordServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/UserExerciseRecordServiceImpl.java
@@ -1,20 +1,29 @@
 package cn.org.alan.exam.service.impl;
 
+// 导入UserExerciseRecordMapper接口，它是用于操作用户练习记录（UserExerciseRecord）相关数据的持久层接口，可实现诸如对用户练习记录数据进行增删改查等操作（从命名推测其功能）
 import cn.org.alan.exam.mapper.UserExerciseRecordMapper;
+// 导入UserExerciseRecord实体类，代表用户练习记录相关的实体对象，包含了像练习时间、练习题目、练习得分等各种属性信息，用于存储和传递与用户练习情况相关的数据
 import cn.org.alan.exam.model.entity.UserExerciseRecord;
+// 导入IUserExerciseRecordService接口，该接口定义了用户练习记录相关的业务服务方法，规定了具体有哪些业务操作需要实现，例如记录用户每次练习的详细情况、查询用户的练习历史记录等
 import cn.org.alan.exam.service.IUserExerciseRecordService;
+// 导入ServiceImpl类，这是MyBatis Plus提供的基础服务实现类，它提供了很多通用的数据库操作方法，方便在此基础上扩展具体业务逻辑的实现，减少重复编写代码，提高开发效率
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入Spring的Service注解，用于标记该类是一个服务层组件，Spring容器会对其进行管理，使其能够参与依赖注入等相关机制，方便在其他地方通过依赖注入的方式使用这个服务类
 import org.springframework.stereotype.Service;
 
 /**
  * <p>
- *  服务实现类
+ *  服务实现类，这里应该是针对用户练习记录相关业务逻辑的服务实现类（可根据具体业务完善文档注释内容进一步明确其功能）
  * </p>
  *
  * @author WeiJin
  * @since 2024-03-21
  */
+// 使用@Service注解将该类标记为Spring容器管理的服务层组件，意味着在Spring应用中可以通过依赖注入的方式在其他组件中调用这个服务类的方法
 @Service
+// 定义UserExerciseRecordServiceImpl类，它继承自ServiceImpl<UserExerciseRecordMapper, UserExerciseRecord>，同时实现了IUserExerciseRecordService接口
+// 通过继承ServiceImpl可以复用其中已有的通用数据库操作方法，后续可按照IUserExerciseRecordService接口中定义的业务方法来实现具体针对用户练习记录的业务逻辑
+// 目前类体为空，表示暂时没有添加额外的业务方法实现，如果后续有添加记录用户练习情况、查询用户练习记录统计信息等业务逻辑相关的方法，就需要在这里进行具体的编写
 public class UserExerciseRecordServiceImpl extends ServiceImpl<UserExerciseRecordMapper, UserExerciseRecord> implements IUserExerciseRecordService {
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/UserServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/UserServiceImpl.java
index 94f3de4..ee0d0cc 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/UserServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/UserServiceImpl.java
@@ -31,228 +31,187 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 
-
 /**
  * @author WeiJin
  * @since 2024-03-21
+ * 这是用户相关业务逻辑的服务实现类，实现了IUserService接口，用于处理如用户创建、密码修改、用户删除、用户信息查询等各类与用户相关的操作。
  */
 @Service
 @Slf4j
 public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
 
+    // 注入UserMapper，用于操作用户数据的持久层接口，比如插入、更新、查询、删除用户记录等操作。
     @Resource
     private UserMapper userMapper;
+    // 注入StringRedisTemplate，用于操作Redis字符串类型数据，常用于缓存相关操作，比如删除缓存、存储用户登录相关的token等。
     @Resource
     private StringRedisTemplate stringRedisTemplate;
+    // 注入HttpServletRequest，用于获取HTTP请求相关信息，例如在后续可能用于获取请求中的会话信息等（如删除密码修改成功后对应会话的token）。
     @Resource
     private HttpServletRequest request;
+    // 注入UserConverter，用于不同用户相关对象之间的转换（比如表单对象和实体对象等），方便在不同业务逻辑中进行数据格式的适配。
     @Resource
     private UserConverter userConverter;
+    // 注入GradeMapper，用于操作班级相关数据的持久层接口，可能在涉及用户与班级关联的业务逻辑中使用，比如查询用户所在班级、添加用户到班级等操作。
     @Resource
     private GradeMapper gradeMapper;
+    // 注入CertificateUserMapper，可能用于操作用户证书相关数据的持久层接口（从命名推测其功能，可能涉及用户资质认证等相关业务逻辑）。
     @Resource
     private CertificateUserMapper certificateUserMapper;
+    // 注入ExamMapper，用于操作考试相关数据的持久层接口，例如查询用户创建的考试、删除用户相关考试记录等操作（与用户在考试方面的业务相关）。
     @Resource
     private ExamMapper examMapper;
+    // 注入ExamQuAnswerMapper，可能用于操作考试题目答案相关数据的持久层接口（推测用于处理用户在考试中作答的题目答案等相关业务逻辑）。
     @Resource
     private ExamQuAnswerMapper examQuAnswerMapper;
+    // 注入ExerciseRecordMapper，用于操作用户练习记录相关数据的持久层接口，比如删除用户的练习记录等操作（与用户练习情况相关）。
     @Resource
     private ExerciseRecordMapper exerciseRecordMapper;
+    // 注入GradeExerciseMapper，可能用于操作班级与练习相关关联数据的持久层接口（从命名推测其功能，也许涉及班级内学生练习相关业务逻辑）。
     @Resource
     private GradeExerciseMapper gradeExerciseMapper;
+    // 注入ManualScoreMapper，可能用于操作手动评分相关数据的持久层接口（可能用于处理如主观题老师手动给分等相关业务逻辑）。
     @Resource
     private ManualScoreMapper manualScoreMapper;
+    // 注入NoticeMapper，用于操作公告相关数据的持久层接口，例如查询用户创建的公告、删除用户相关公告记录等操作（与系统公告业务相关）。
     @Resource
     private NoticeMapper noticeMapper;
+    // 注入QuestionMapper，用于操作题目数据的持久层接口，可能在涉及用户创建的题目、删除用户相关题目等业务逻辑中使用。
     @Resource
     private QuestionMapper questionMapper;
+    // 注入RepoMapper，用于操作题库相关数据的持久层接口，比如查询用户创建的题库、删除用户相关题库记录等操作（与用户在题库方面的业务相关）。
     @Resource
     private RepoMapper repoMapper;
+    // 注入UserBookMapper，用于操作用户错题本相关数据的持久层接口，例如删除用户的错题本记录等操作（与用户错题本业务相关）。
     @Resource
     private UserBookMapper userBookMapper;
+    // 注入OptionMapper，用于操作题目选项数据的持久层接口，例如删除用户创建题目对应的选项等操作（与题目选项相关且和用户创建题目等业务有关联）。
     @Resource
     private OptionMapper optionMapper;
+    // 注入NoticeGradeMapper，可能用于操作公告与班级关联相关数据的持久层接口（推测用于处理公告针对哪些班级展示等相关业务逻辑）。
     @Resource
     private NoticeGradeMapper noticeGradeMapper;
+    // 注入IQuestionService，这是题目相关的业务服务接口，此处用于调用题目相关业务方法（如上传头像复用了上传图片的方法，这里调用其上传图片功能）。
     @Resource
     private IQuestionService iQuestionService;
 
-
+    // 创建用户的方法，根据传入的UserForm对象创建新用户，进行一些必要的属性设置和验证后插入到数据库中，成功返回创建成功的提示信息，失败返回相应错误提示。
     @Override
     public Result<String> createUser(UserForm userForm) {
+        // 使用BCryptPasswordEncoder对默认密码"123456"进行加密，并设置到用户表单对象的密码字段中，通常新用户会有一个初始密码，后续可自行修改。
         userForm.setPassword(new BCryptPasswordEncoder().encode("123456"));
-        //教师只能创建学生
+        // 判断当前用户角色是否为"role_teacher"（通常代表教师角色，具体含义由业务定义），如果是教师角色，只能创建学生用户（这里假设学生角色的ID为1，具体由业务规定），设置用户表单对象的角色ID为学生角色ID。
         if ("role_teacher".equals(SecurityUtil.getRole())) {
             userForm.setRoleId(1);
         }
-        //避免管理员创建用户不传递角色
+        // 避免管理员创建用户时不传递角色信息的情况，如果用户表单对象中的角色ID为null或者为0，返回提示要求选择用户角色的错误信息。
         if (userForm.getRoleId() == null || userForm.getRoleId() == 0) {
             return Result.failed("请选择用户角色");
         }
+        // 将UserForm对象转换为User实体对象，方便后续持久化操作，使用UserConverter进行转换。
         User user = userConverter.fromToEntity(userForm);
+        // 调用userMapper的insert方法将用户数据插入到数据库中，执行插入操作。
         userMapper.insert(user);
+        // 返回表示用户创建成功的结果信息，通常可以在前端等地方展示给用户相应提示。
         return Result.success("用户创建成功");
 
     }
 
+    // 修改用户密码的方法，根据传入的UserForm对象中的新旧密码信息进行验证和更新操作，密码修改成功后清除Redis中对应的token（用于让用户重新登录），并返回相应的提示信息，验证失败返回错误提示。
     @Override
     public Result<String> updatePassword(UserForm userForm) {
+        // 验证两次输入的新密码是否一致，如果不一致，返回两次密码不一致的错误提示信息。
         if (!userForm.getNewPassword().equals(userForm.getCheckedPassword())) {
             return Result.failed("两次密码不一致");
         }
+        // 获取当前登录用户的ID，通过SecurityUtil工具类获取（具体获取逻辑在该工具类中实现，可能从登录信息等方面获取当前用户的唯一标识ID）。
         Integer userId = SecurityUtil.getUserId();
+        // 使用BCryptPasswordEncoder验证输入的旧密码是否与数据库中存储的当前用户的密码匹配，如果不匹配，返回旧密码错误的提示信息。
         if (!new BCryptPasswordEncoder()
-                .matches(userForm.getOriginPassword(),userMapper.selectById(userId).getPassword())) {
+                .matches(userForm.getOriginPassword(), userMapper.selectById(userId).getPassword())) {
             return Result.failed("旧密码错误");
         }
-        //密码加密
+        // 对新密码进行加密，使用BCryptPasswordEncoder将新密码加密后设置到用户表单对象的密码字段中，用于后续更新到数据库中存储加密后的密码。
         userForm.setPassword(new BCryptPasswordEncoder().encode(userForm.getNewPassword()));
+        // 设置用户表单对象的ID为当前登录用户的ID，确保更新的是当前登录用户的密码信息。
         userForm.setId(userId);
+        // 调用userMapper的updateById方法，根据用户表单对象转换后的用户实体对象（通过UserConverter转换）来更新数据库中当前用户的密码信息，返回受影响的行数，即实际更新的记录数。
         int updated = userMapper.updateById(userConverter.fromToEntity(userForm));
-        //密码修改成功清除redis的token，让用户重新登录
+        // 如果更新操作影响的行数大于0，表示密码修改成功，清除Redis中对应会话的token（这里假设token存储在Redis中，键为请求会话的ID加上"token"字符串），让用户重新登录，然后返回修改成功并提示重新登录的结果信息。
         if (updated > 0) {
             stringRedisTemplate.delete(request.getSession().getId() + "token");
             return Result.success("修改成功，请重新登录");
         }
+        // 如果更新操作影响的行数为0，表示密码修改失败（可能是其他原因导致更新未成功），返回旧密码错误的提示信息（这里可以根据实际情况细化错误提示）。
         return Result.failed("旧密码错误");
 
     }
 
+    // 批量删除用户的方法，事务性操作，根据传入的以逗号分隔的用户ID字符串，将对应的用户及其相关联的数据（如用户创建的考试、练习记录、题目等多方面相关数据）进行删除操作，成功返回删除成功的提示信息，具体删除逻辑中部分代码被注释掉，可按需取消注释启用。
     @Override
     @Transactional
     public Result<String> deleteBatchByIds(String ids) {
+        // 将传入的以逗号分隔的字符串形式的用户ID列表转换为Integer类型的列表，使用Java 8的Stream API进行转换。
         List<Integer> userIds = Arrays.stream(ids.split(",")).map(Integer::parseInt).toList();
-        // //删除用户证书
+
+        // //删除用户证书，调用certificateUserMapper的deleteByUserIds方法，传入用户ID列表批量删除用户证书相关记录（假设该方法实现了批量删除逻辑，当前代码中此部分被注释掉，可按需启用）。
         // certificateUserMapper.deleteByUserIds(userIds);
-        // //删除用户创建的考试
+        // //删除用户创建的考试，调用examMapper的deleteByUserIds方法，传入用户ID列表批量删除用户创建的考试记录（同样被注释掉，可按需启用）。
         // examMapper.deleteByUserIds(userIds);
-        // //删除用户考试作答记录
+        // //删除用户考试作答记录，调用examQuAnswerMapper的deleteByUserIds方法，传入用户ID列表批量删除用户考试作答记录（注释状态，可按需启用）。
         // examQuAnswerMapper.deleteByUserIds(userIds);
-        // //删除用户练习记录
+        // //删除用户练习记录，调用exerciseRecordMapper的deleteByUserIds方法，传入用户ID列表批量删除用户练习记录（注释部分，可按需启用）。
         // exerciseRecordMapper.deleteByUserIds(userIds);
-        // //清除用户表中的班级id
+        // //清除用户表中的班级id，先调用gradeMapper的selectIdsByUserIds方法，传入用户ID列表获取这些用户对应的班级ID列表（假设该方法实现了查询逻辑）。
         // List<Integer> gradeIds = gradeMapper.selectIdsByUserIds(userIds);
+        // //如果获取到的班级ID列表不为空，表示有相关班级需要处理，调用userMapper的removeGradeIdByGradeIds方法，传入班级ID列表清除用户表中对应的班级ID关联（假设该方法实现了清除逻辑，当前代码中这部分整体被注释掉，可按需启用）。
         // if (!gradeIds.isEmpty()) {
         //     userMapper.removeGradeIdByGradeIds(gradeIds);
         // }
-        //
-        // //删除用户创建的班级
+
+        // //删除用户创建的班级，调用gradeMapper的deleteByUserId方法，传入用户ID列表批量删除用户创建的班级记录（注释部分，可按需启用）。
         // gradeMapper.deleteByUserId(userIds);
-        // //删除用户创建的可供学生练习的题库关联表
+        // //删除用户创建的可供学生练习的题库关联表，调用gradeExerciseMapper的deleteByUserIds方法，传入用户ID列表批量删除相关记录（注释状态，可按需启用）。
         // gradeExerciseMapper.deleteByUserIds(userIds);
-        // //删除用户批改的主观题分数
+        // //删除用户批改的主观题分数，调用manualScoreMapper的deleteByUserIds方法，传入用户ID列表批量删除用户批改主观题分数的相关记录（注释内容，可按需启用）。
         // manualScoreMapper.deleteByUserIds(userIds);
-        // //删除公告与班级关联表
-        // //1.获取公告id
+        // //删除公告与班级关联表，以下是分步骤操作的逻辑，先获取公告id，再根据公告id删除关联。
+        // //1.获取公告id，调用noticeMapper的selectIdsByUserIds方法，传入用户ID列表获取这些用户创建的公告对应的公告ID列表（假设该方法实现了查询逻辑，当前被注释，可按需启用）。
         // List<Integer> noticeIds = noticeMapper.selectIdsByUserIds(userIds);
-        // //2.删除公告与班级关联
+        // //2.删除公告与班级关联，如果获取到的公告ID列表不为空，表示有相关公告需要处理，调用noticeGradeMapper的deleteByNoticeIds方法，传入公告ID列表删除公告与班级的关联记录（假设该方法实现了删除逻辑，这部分整体被注释掉，可按需启用）。
         // if (!noticeIds.isEmpty()) {
         //     noticeGradeMapper.deleteByNoticeIds(noticeIds);
         // }
-        // //删除用户创建的公告
+        // //删除用户创建的公告，调用noticeMapper的deleteByUserIds方法，传入用户ID列表批量删除用户创建的公告记录（注释部分，可按需启用）。
         // noticeMapper.deleteByUserIds(userIds);
-        //
-        // //删除试题选项
-        // //1.获取用户创建的试题id
+
+        // //删除试题选项，先获取用户创建的试题id，调用questionMapper的selectIdsByUserIds方法，传入用户ID列表获取这些用户创建的试题对应的试题ID列表（假设该方法实现了查询逻辑，当前代码中处于注释状态，可按需启用）。
         // List<Integer> quIds = questionMapper.selectIdsByUserIds(userIds);
-        // //2.根据试题id列表删除选项
+        // //2.根据试题id列表删除选项，如果获取到的试题ID列表不为空，表示有相关试题选项需要处理，调用optionMapper的deleteBatchByQuIds方法，传入试题ID列表批量删除对应的试题选项（假设该方法实现了批量删除逻辑，这部分被注释掉，可按需启用）。
         // if (!quIds.isEmpty()) {
         //     optionMapper.deleteBatchByQuIds(quIds);
         // }
-        // //删除用户创建的试题
+        // //删除用户创建的试题，调用questionMapper的deleteByUserIds方法，传入用户ID列表批量删除用户创建的试题记录（注释内容，可按需启用）。
         // questionMapper.deleteByUserIds(userIds);
-        // //删除用户创建的题库
+        // //删除用户创建的题库，调用repoMapper的deleteByUserIds方法，传入用户ID列表批量删除用户创建的题库记录（注释部分，可按需启用）。
         // repoMapper.deleteByUserIds(userIds);
-        // //删除用户的错题本
+        // //删除用户的错题本，调用userBookMapper的deleteByUserIds方法，传入用户ID列表批量删除用户的错题本记录（注释状态，可按需启用）。
         // userBookMapper.deleteByUserIds(userIds);
-        // //删除用户
+        // //删除用户，调用userMapper的deleteByUserIds方法，传入用户ID列表删除对应的用户记录，返回受影响的行数，即实际删除的用户数量。
         Integer row = userMapper.deleteByUserIds(userIds);
-        // //
+        // 返回删除成功的结果信息，目前代码中只是简单返回成功提示，实际可根据row的值进一步判断是否真的删除成功等情况进行更准确的提示信息返回（比如如果row为0可以返回更详细的失败提示等）。
         return Result.success("删除成功");
     }
 
+    // 从Excel文件导入用户数据的方法，事务性操作，先对文件类型进行判断，读取文件内容并补充必要的参数，然后将用户数据批量插入到数据库中，成功返回导入成功的提示信息，失败返回相应错误提示，使用了异常处理注解来简化异常抛出处理。
     @SneakyThrows(Exception.class)
     @Override
     @Transactional
     public Result<String> importUsers(MultipartFile file) {
-        //文件类型判断
+        // 文件类型判断，调用ExcelUtils工具类的isExcel方法，检查传入的文件是否是合法的Excel文件（xls或xlsx格式），如果不是则返回文件类型错误的提示信息。
         if (!ExcelUtils.isExcel(Objects.requireNonNull(file.getOriginalFilename()))) {
             return Result.failed("文件类型必须是xls或xlsx");
         }
-        //读取文件
+        // 读取文件，调用ExcelUtils的readMultipartFile方法，读取传入的MultipartFile类型的Excel文件，并转换为UserForm对象列表（假设该方法实现了读取并转换逻辑）。
         List<UserForm> list = ExcelUtils.readMultipartFile(file, UserForm.class);
-        //参数补充
-        list.forEach(userForm -> {
-            userForm.setPassword(new BCryptPasswordEncoder().encode("123456"));
-            userForm.setCreateTime(DateTimeUtil.getDateTime());
-            if (userForm.getRoleId() == null) {
-                userForm.setRoleId(1);
-            }
-        });
-
-        if (list.size() > 300) {
-            return Result.failed("表中最多存放300条数据");
-        }
-        userMapper.insertBatchUser(userConverter.listFromToEntity(list));
-        return Result.success("用户导入成功");
-    }
-
-    @Override
-    public Result<UserVO> info() {
-        UserVO userVo = userMapper.info(SecurityUtil.getUserId());
-        userVo.setPassword(null);
-        return Result.success(null, userVo);
-    }
-
-    @Override
-    public Result<String> joinGrade(String code) {
-        //获取班级信息
-        LambdaQueryWrapper<Grade> wrapper = new LambdaQueryWrapper<Grade>().eq(Grade::getCode, code);
-        Grade grade = gradeMapper.selectOne(wrapper);
-        if (Objects.isNull(grade)) {
-            return Result.failed("班级口令不存在");
-        }
-        User user = new User();
-        user.setId(SecurityUtil.getUserId());
-        user.setGradeId(grade.getId());
-        int updated = userMapper.updateById(user);
-        if (updated > 0) {
-            stringRedisTemplate.delete("cache:grade:getPaging:"+SecurityUtil.getUserId().toString());
-            return Result.success("加入班级：" + grade.getGradeName() + "成功");
-        }
-        return Result.failed("加入失败");
-    }
-
-    @Override
-    public Result<IPage<UserVO>> pagingUser(Integer pageNum, Integer pageSize, Integer gradeId, String realName) {
-        IPage<UserVO> page = new Page<>(pageNum, pageSize);
-        if ("role_teacher".equals(SecurityUtil.getRole())) {
-            page = userMapper.pagingUser(page, gradeId, realName, SecurityUtil.getUserId(),1);
-        } else {
-            page = userMapper.pagingUser(page, gradeId, realName, SecurityUtil.getUserId(),null);
-        }
-
-        return Result.success(null, page);
-    }
-
-    @Transactional
-    @Override
-    public Result<String> uploadAvatar(MultipartFile file) {
-        Result<String> result = iQuestionService.uploadImage(file);
-        System.out.println(result);
-        if (result.getCode() == 0) {
-            return Result.failed("图片上传失败");
-        }
-        String url = result.getData();
-        System.out.println(url);
-        User user = new User();
-        user.setId(SecurityUtil.getUserId());
-        user.setAvatar(url);
-        if (userMapper.updateById(user) > 0) {
-            return Result.success("上传成功", url);
-        }
-        return Result.failed("图片上传失败");
-    }
-
-
-}
+        // 参数补充，遍历读取到的UserForm对象列表
\ No newline at end of file
-- 
2.34.1


From 89a1ee70f4d69f3167916fd7e4fe8eaf7f28bc20 Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Wed, 18 Dec 2024 17:17:36 +0800
Subject: [PATCH 09/10] main1122

---
 .../alan/exam/security/SysUserDetails.java    |  23 +-
 .../exam/service/impl/NoticeServiceImpl.java  |  40 +-
 .../service/impl/QuestionServiceImpl.java     |  81 +++-
 .../service/impl/UserBookServiceImpl.java     |  63 ++-
 .../cn/org/alan/exam/util/CryptoUtils.java    | 378 +++++-------------
 5 files changed, 289 insertions(+), 296 deletions(-)

diff --git a/src/main/java/cn/org/alan/exam/security/SysUserDetails.java b/src/main/java/cn/org/alan/exam/security/SysUserDetails.java
index cb66976..924c0dc 100644
--- a/src/main/java/cn/org/alan/exam/security/SysUserDetails.java
+++ b/src/main/java/cn/org/alan/exam/security/SysUserDetails.java
@@ -1,6 +1,5 @@
 package cn.org.alan.exam.security;
 
-
 import cn.org.alan.exam.model.entity.User;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -12,59 +11,75 @@ import java.util.Collection;
 import java.util.List;
 
 /**
- * Spring Security 用户对象
+ * Spring Security 用户对象，该类实现了Spring Security的UserDetails接口，用于在安全框架中表示用户的详细信息，
+ * 包括用户的权限、基本信息等，以便进行认证和授权相关的操作。
  *
  * @author haoxr
  * @since 3.0.0
  */
+// 使用Lombok的 @Data注解，自动生成类的Getter、Setter、toString、equals、hashCode等方法，简化代码编写
 @Data
+// 使用Lombok的 @NoArgsConstructor注解，自动生成无参构造函数，方便对象的创建和初始化
 @NoArgsConstructor
 public class SysUserDetails implements UserDetails {
+    // 用于存储用户的权限列表，权限类型为SimpleGrantedAuthority，它是Spring Security中表示权限的一种简单实现，通常包含权限名称（如 "ROLE_ADMIN"、"ROLE_USER" 等）
     private List<SimpleGrantedAuthority> permissions;
+    // 关联的实际业务中的用户实体对象，包含了如用户名、密码、用户其他属性等详细信息，用于获取和传递与用户相关的业务数据
     private User user;
+    // 用户名，用于在Spring Security认证等流程中作为用户的标识，与UserDetails接口中定义的方法对应，此处可能后续会根据业务逻辑有具体赋值或使用情况
     private String username;
 
+    // 构造函数，接收一个User对象，用于初始化SysUserDetails对象时关联对应的业务用户实体，方便后续获取用户相关信息进行认证授权等操作
     public SysUserDetails(User user) {
         this.user = user;
     }
+
+    // 实现UserDetails接口的方法，用于获取用户的权限集合，在Spring Security的授权流程中会调用该方法来判断用户具有哪些权限，这里直接返回之前定义的permissions列表
     @Override
     public Collection<? extends GrantedAuthority> getAuthorities() {
         return permissions;
     }
 
+    // 设置用户权限的方法，外部可以通过调用该方法来为当前用户对象设置相应的权限列表，方便在用户权限管理等业务场景中更新用户权限信息
     public void setPermissions(List<SimpleGrantedAuthority> permissions) {
         this.permissions = permissions;
     }
 
+    // 实现UserDetails接口的方法，用于获取用户的密码，从关联的User实体对象中获取密码信息，并在获取后将User实体中的密码字段设置为空字符串（可能出于安全考虑，防止密码在后续不必要的场景中被意外获取到），然后返回密码
     @Override
     public String getPassword() {
-        String myPassword=user.getPassword();
+        String myPassword = user.getPassword();
         user.setPassword("");
         return myPassword;
     }
 
+    // 实现UserDetails接口的方法，用于获取用户的用户名，这里从关联的User实体对象中获取用户名（通常是业务中定义的用户标识字段，如账号名等）并返回，作为Spring Security认证流程中识别用户的重要依据
     @Override
     public String getUsername() {
         return user.getUserName();
     }
 
+    // 实现UserDetails接口的方法，用于判断用户账号是否未过期，在Spring Security的认证逻辑中会参考该方法的返回值来确定账号有效性，这里直接返回true，表示默认账号未过期，可根据实际业务需求进行具体逻辑修改
     @Override
     public boolean isAccountNonExpired() {
         return true;
     }
 
+    // 实现UserDetails接口的方法，用于判断用户账号是否未锁定，同样在Spring Security的认证检查中起作用，返回true表示默认账号未锁定，可根据业务规则调整该逻辑，比如根据数据库中账号锁定字段等来判断
     @Override
     public boolean isAccountNonLocked() {
         return true;
     }
 
+    // 实现UserDetails接口的方法，用于判断用户的凭证（通常就是密码）是否未过期，此处返回true表示默认凭证未过期，若有密码有效期等业务需求可在此处实现相应逻辑判断
     @Override
     public boolean isCredentialsNonExpired() {
         return true;
     }
 
+    // 实现UserDetails接口的方法，用于判断用户账号是否启用，返回true表示默认用户账号是启用状态，可根据业务情况（如用户是否被禁用的标识字段等）来具体实现该方法的逻辑判断
     @Override
     public boolean isEnabled() {
         return true;
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/NoticeServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/NoticeServiceImpl.java
index 899e429..14fd20f 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/NoticeServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/NoticeServiceImpl.java
@@ -254,13 +254,47 @@ public class NoticeServiceImpl extends ServiceImpl<NoticeMapper, Notice> impleme
         List<Integer> missIds = new ArrayList<>();
         // 遍历查询到的公告ID列表，检查每个ID在缓存中是否存在，如果不存在则添加到未命中ID列表中
         for (Integer id : noticeIds) {
+            // 遍历noticeIds列表，noticeIds可能是存储了通知（Notice）相关记录的ID集合，这里每次循环取出一个通知的ID，用于后续的缓存判断等操作。
             if (!cachedGradesMap.containsKey(id)) {
+                // 判断cachedGradesMap（推测是一个缓存中存储的已查询到的通知对象的映射，键为通知ID，值为对应的通知对象，这里从命名来看可能是缓存了NoticeVO类型的对象，但需结合上下文确定）中是否包含当前遍历到的通知ID，如果不包含，表示该通知ID对应的通知对象在缓存中未找到（缓存未命中）。
                 missIds.add(id);
+                // 将未在缓存中找到的通知ID添加到missIds列表中，missIds用于收集所有缓存未命中的通知ID，后续会根据这些ID从数据库中查询相应的通知信息并更新缓存。
             }
         }
 
-        // 如果存在未命中缓存的公告ID，即missIds列表不为空
+// 如果有未命中的ID，从数据库批量查询并更新缓存
         if (!missIds.isEmpty()) {
-            // 调用noticeMapper的batchSelectByIds方法，从数据库中批量查询未命中缓存的公告数据，并转换为NoticeVO对象列表（假设noticeMapper中实现了该方法）
+            // 判断missIds列表是否为空，即是否存在缓存未命中的通知ID，如果不为空，表示有需要从数据库查询并更新缓存的数据，执行以下操作。
             List<NoticeVO> missedGrades = noticeMapper.batchSelectByIds(missIds);
-            // 使用Java 8的Stream API，将NoticeVO对象列表转换为以公告ID为键，NoticeVO对象为
\ No newline at end of file
+            // 调用noticeMapper（可能是操作通知数据的持久层接口，用于与数据库交互）的batchSelectByIds方法，传入收集到的缓存未命中的通知ID列表missIds，从数据库中批量查询对应的通知信息，返回的是NoticeVO类型的列表，每个NoticeVO对象代表一条通知记录的相关信息，存储在missedGrades变量中。
+
+            // 假设GradeVO的ID为getId()，使用Collectors.toMap转换
+            Map<Integer, NoticeVO> missedGradesMap = missedGrades.stream()
+                    .collect(Collectors.toMap(NoticeVO::getId, Function.identity()));
+            // 使用Java 8的Stream API对查询到的通知信息列表missedGrades进行处理，将其转换为一个以通知ID为键，通知对象（NoticeVO）为值的Map。Collectors.toMap方法接收两个参数，第一个参数NoticeVO::getId表示使用NoticeVO对象的getId方法获取的返回值（即通知ID）作为键，第二个参数Function.identity()表示直接使用原NoticeVO对象作为值，这样就构建了方便后续操作的映射关系，存储在missedGradesMap变量中。
+
+            // 更新缓存
+            cacheClient.batchPut("cache:notice:getNotice:", missedGradesMap, 10L, TimeUnit.MINUTES);
+            // 调用cacheClient（可能是用于操作缓存的客户端工具类）的batchPut方法，将构建好的包含未命中通知对象的映射missedGradesMap存储到缓存中，缓存的键前缀为 "cache:notice:getNotice:"，同时设置缓存的过期时间为10分钟，时间单位为分钟（TimeUnit.MINUTES），这样可以在一定时间内缓存这些通知信息，提高后续查询效率。
+
+            // 合并缓存结果
+            cachedGradesMap.putAll(missedGradesMap);
+            // 将新查询到并存储到missedGradesMap中的通知对象映射合并到cachedGradesMap中，使得cachedGradesMap包含了最新的缓存数据，无论是之前已存在的缓存数据还是本次新查询并更新的缓存数据，保证缓存数据的完整性。
+        }
+
+// 根据ID列表从缓存中获取完整的GradeVO对象列表
+        List<NoticeVO> finalResult = new ArrayList<>(noticeIds.size());
+// 创建一个ArrayList对象，用于存储最终要返回的通知对象列表，初始容量设置为noticeIds的大小，这样可以在一定程度上避免列表扩容带来的性能开销，提高性能（虽然ArrayList会自动扩容，但预先指定合适容量可以优化性能）。
+        for (Integer id : noticeIds) {
+            finalResult.add(cachedGradesMap.get(id));
+            // 再次遍历noticeIds列表，从合并后的缓存映射cachedGradesMap中获取每个通知ID对应的通知对象（NoticeVO），并添加到finalResult列表中，这样finalResult就包含了根据传入的通知ID列表从缓存中获取到的完整的通知对象集合。
+        }
+
+// 构建并返回IPage对象
+        IPage<NoticeVO> resultPage = new Page<>(pageNum, pageSize, Long.valueOf(total));
+// 创建一个IPage类型的分页对象resultPage，使用Page的构造函数进行初始化，传入当前页码pageNum、每页显示数量pageSize以及总记录数total（这里将total转换为Long类型传入，具体total的来源和含义需结合上下文确定），用于构建分页相关的数据结构，方便前端进行分页展示等操作。
+        resultPage.setRecords(finalResult);
+// 将包含通知对象的finalResult列表设置为分页对象resultPage的记录列表，即将查询到的通知数据填充到分页对象中，使其符合分页展示的要求，包含了分页信息以及具体的数据记录。
+
+        return Result.success("查询成功", resultPage);
+// 返回一个表示操作成功的Result结果对象，其中包含提示信息“查询成功”以及构建好的分页对象resultPage，方便前端等调用者获取查询结果并根据分页信息进行展示和后续处理，具体Result对象的结构和使用方式需结合项目中相关定义来看。
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/QuestionServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/QuestionServiceImpl.java
index 5a064cd..2538119 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/QuestionServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/QuestionServiceImpl.java
@@ -75,7 +75,7 @@ public class QuestionServiceImpl extends ServiceImpl<QuestionMapper, Question> i
         // 入参校验，获取题目表单中的选项列表
         List<Option> options = questionFrom.getOptions();
         // 判断题目类型不是简答题（假设题目类型4代表简答题）且选项为空或者选项数量小于2时，不符合要求，返回错误提示
-        if (questionFrom.getQuType()!= 4 && (Objects.isNull(options) || options.size() < 2)) {
+        if (questionFrom.getQuType() != 4 && (Objects.isNull(options) || options.size() < 2)) {
             return Result.failed("非简答题的试题选项不能少于两个");
         }
 
@@ -104,7 +104,7 @@ public class QuestionServiceImpl extends ServiceImpl<QuestionMapper, Question> i
         }
 
         // 如果题目插入成功，题目数据有了有效的ID（这里假设插入后会自动生成ID），进行缓存相关操作
-        if (question.getId()!= null) { // 确保ID有效
+        if (question.getId() != null) { // 确保ID有效
             // 如果是更新操作（此处逻辑可能不太准确，实际上是添加操作，但代码结构类似更新时的缓存处理逻辑），先从缓存中移除旧数据
             // 根据题目ID删除对应的缓存数据，缓存键格式为"cache:question:pagingQuestion:" + 题目ID
             stringRedisTemplate.delete("cache:question:pagingQuestion:" + question.getId().toString());
@@ -232,7 +232,7 @@ public class QuestionServiceImpl extends ServiceImpl<QuestionMapper, Question> i
         }
 
         // 如果题目更新成功，题目数据有了有效的ID（这里假设更新前后ID不变且不为空），进行缓存相关操作
-        if (question.getId()!= null) { // 确保ID有效
+        if (question.getId() != null) { // 确保ID有效
             // 如果是更新操作，先从缓存中移除旧数据，根据题目ID删除对应的缓存数据，缓存键格式为"cache:question:pagingQuestion:" + 题目ID
             stringRedisTemplate.delete("cache:question:pagingQuestion:" + question.getId().toString());
             // QuestionVO questionVO = questionConverter.QuestionToQuestionVO(question); // 转换为视图对象
@@ -261,24 +261,77 @@ public class QuestionServiceImpl extends ServiceImpl<QuestionMapper, Question> i
 
         // 遍历转换后的QuestionFrom对象列表，处理每个题目表单对象对应的题目及选项数据插入逻辑
         for (QuestionFrom questionFrom : list) {
-            // 将QuestionFrom对象转换为Question实体对象，方便后续持久化操作，使用QuestionConverter进行转换
+            // 遍历传入的QuestionFrom类型的列表，QuestionFrom可能是用于接收前端传递过来的题目相关数据的表单对象（从命名推测其功能），每次循环处理一个题目相关的数据对象。
             Question question = questionConverter.fromToEntity(questionFrom);
-            // 设置题目所属的题库ID为传入的id参数
+            // 使用questionConverter（可能是一个用于对象转换的工具类）将QuestionFrom对象转换为Question实体对象，方便后续持久化操作，Question实体对象应该是对应数据库中存储题目信息的实体类实例，包含了如题目内容、类型等各种属性。
             question.setRepoId(id);
-            // 插入单个题目数据到数据库中，调用questionMapper的insert方法
+            // 将题目实体对象的RepoId属性设置为传入的id值，推测RepoId可能是用于关联题目所属的题库ID等相关信息（具体含义需结合业务逻辑确定）。
+            // 添加单题获取Id
             questionMapper.insert(question);
-
-            // 批量添加选项，获取题目表单中的选项列表
+            // 调用questionMapper（可能是操作题目数据的持久层接口，用于与数据库交互）的insert方法，将转换后的题目实体对象插入到数据库中，插入成功后数据库会为该题目记录分配一个唯一的ID（通常是自增长的主键），并且这个ID会回填到question对象中（假设使用了相应的数据库框架支持此功能）。
+            // 批量添加选项
             List<Option> options = questionFrom.getOptions();
-            // 创建一个长度为1的数组，用于记录选项的排序序号，初始值为0（这里通过数组实现类似引用传递的效果，方便在Lambda表达式中修改值）
+            // 从QuestionFrom对象中获取其包含的选项列表，Option对象应该是代表题目选项相关信息的实体类，每个Option实例存储了一个选项的具体内容、是否正确等属性，这里获取到的是当前题目对应的所有选项信息列表。
             final int[] count = {0};
-            // 遍历题目表单中的每个选项，设置选项的相关属性并建立与题目的关联
+            // 创建一个长度为1的整数数组，用于记录选项的序号，初始值设为0，通过数组的方式可以在Lambda表达式中修改其值（类似一种简单的引用传递效果，因为Java的Lambda表达式中修改外部局部变量有限制）。
             options.forEach(option -> {
-                // 简答题答案默认给正确（假设题目类型4代表简答题，这里根据题目类型设置选项的是否正确属性）
+                // 简答题答案默认给正确
                 if (question.getQuType() == 4) {
+                    // 判断当前题目（question对象）的题目类型（QuType属性）是否为4（推测4代表简答题类型，具体需结合业务定义），如果是简答题类型，则将当前选项的IsRight属性设置为1，表示该选项为正确答案（对于简答题可能默认只有一个正确答案的设定）。
                     option.setIsRight(1);
                 }
-                // 设置选项的排序序号，每次自增1
                 option.setSort(++count[0]);
-                // 设置选项所属题目的ID为刚插入题目的ID，建立关联
-                option.setQuId(question
\ No newline at end of file
+                // 为当前选项设置序号，通过自增操作（++count[0]）给选项的Sort属性赋值，使其按照顺序依次递增，用于表示选项的排列顺序，方便后续展示等操作。
+                option.setQuId(question.getId());
+                // 将当前选项的QuId属性设置为当前题目的ID（即前面插入题目记录后回填到question对象中的ID值），建立选项与题目的关联关系，表明该选项属于当前这个题目。
+            });
+
+            // 避免简答题没有答案
+            if (!options.isEmpty()) {
+                // 判断选项列表是否为空，即确保当前题目有选项信息（虽然简答题可能默认有一个答案选项，但也需要排除没有任何选项数据的情况），如果不为空，则执行以下批量插入选项的操作。
+                optionMapper.insertBatch(options);
+                // 调用optionMapper（可能是操作选项数据的持久层接口）的insertBatch方法，将整理好的选项列表批量插入到数据库中，实现一次插入多个选项记录的操作，提高插入效率。
+            }
+            if (question.getId() != null) { // 确保ID有效
+                // 如果题目实体对象的ID不为空（即前面插入题目操作成功获取到了有效的ID），执行以下缓存相关的操作（可能是为了保证数据一致性，更新缓存中的题目数据）。
+                // 如果是更新操作，先从缓存中移除旧数据，然后重新放入最新的数据
+                stringRedisTemplate.delete("cache:question:pagingQuestion:" + question.getId().toString()); // 删除旧缓存
+                // 调用stringRedisTemplate（用于操作Redis字符串类型数据的工具类，常用于缓存相关操作）的delete方法，根据构建的缓存键（格式为 "cache:question:pagingQuestion:" 加上题目ID的字符串形式）删除对应的缓存数据，目的是移除旧的题目缓存信息，避免缓存数据不一致。
+                // QuestionVO questionVO = questionConverter.QuestionToQuestionVO(question); // 转换为视图对象
+                // 注释掉的这行代码原本可能是使用questionConverter（前面用于对象转换的工具类）将Question实体对象转换为QuestionVO对象（推测是用于展示给前端的视图对象，包含了前端需要展示的题目相关信息），但当前代码中这行被注释掉了，可能暂不需要此转换操作或者后续会有其他处理方式。
+                // Map<Integer, QuestionVO> map = Map.of(questionVO.getId(), questionVO);
+                // 注释掉的这行代码原本可能是创建一个只包含当前题目视图对象（questionVO）的Map，以题目ID为键，题目视图对象为值，可能用于后续缓存存储等操作，但同样被注释掉了，可能暂不执行此逻辑。
+                // cacheClient.batchPut("cache:question:pagingQuestion:", map, 10L, TimeUnit.MINUTES); // 存储新数据
+                // 注释掉的这行代码原本可能是使用cacheClient（可能是缓存操作相关的客户端工具类）的batchPut方法，将包含最新题目视图对象的Map数据存储到缓存中，设置缓存过期时间为10分钟，以实现缓存更新，保证下次获取题目数据时能获取到最新的信息，但目前代码中此操作被注释掉了，暂不执行缓存存储新数据的逻辑。
+            }
+
+        }
+        return Result.success("导入成功");
+// 当遍历完所有题目相关的数据对象并完成相应的插入、关联以及缓存相关操作（如果有的话）后，返回一个表示操作成功的Result结果对象，其中包含提示信息“导入成功”，用于告知调用者题目数据导入操作已顺利完成，具体Result对象的结构和使用方式需结合项目中相关定义来看。
+
+        @SneakyThrows(IOException.class)
+// 使用 @SneakyThrows注解，用于简化异常处理，当方法内部抛出IOException异常时，会自动将异常向上抛出，避免了显式编写try-catch块来处理异常（但需要注意在合适的调用层次上进行统一的异常处理），这里表示该方法可能会抛出输入输出相关的异常（比如文件读取等操作可能出现的异常）。
+        @Override
+        public Result<String> uploadImage (MultipartFile file){
+            // 实现接口中定义的上传图片方法，接收一个MultipartFile类型的文件对象，用于上传图片文件，该方法的功能是将传入的图片文件上传到指定位置（可能是云存储等地方）并返回相应的结果信息。
+            if (!aliOSSUtil.isImage(Objects.requireNonNull(file.getOriginalFilename()))) {
+                // 调用aliOSSUtil（可能是用于与阿里云对象存储服务交互或者进行文件类型判断等相关操作的工具类）的isImage方法，传入文件的原始文件名（通过Objects.requireNonNull确保文件名不为空），判断该文件是否是图片格式，如果不是图片格式，则执行以下返回操作。
+                return Result.failed("该文件不是常用图片格式(png、jpg、jpeg、bmp)");
+                // 返回一个表示操作失败的Result结果对象，包含提示信息“该文件不是常用图片格式(png、jpg、jpeg、bmp)”，告知调用者上传的文件不符合图片格式要求，具体Result对象的结构和使用方式需结合项目中相关定义来看。
+            }
+            if (aliOSSUtil.isOverSize(file)) {
+                // 调用aliOSSUtil的isOverSize方法，传入文件对象，判断该文件大小是否超过了规定的限制（从方法名推测是用于判断文件大小是否超出限制的功能），如果文件大小超过限制，则执行以下返回操作。
+                return Result.failed("图片大小不能超过50KB");
+                // 返回一个表示操作失败的Result结果对象，包含提示信息“图片大小不能超过50KB”，告知调用者上传的图片文件大小不符合要求，具体Result对象的结构和使用方式需结合项目中相关定义来看。
+            }
+            String url = aliOSSUtil.upload(file);
+            // 调用aliOSSUtil的upload方法，传入文件对象，将图片文件上传到指定位置（比如阿里云对象存储等地方），并返回上传后文件的访问地址（如果上传成功），存储在url变量中。
+            if (StringUtils.isBlank(url)) {
+                // 判断返回的文件访问地址是否为空字符串，如果为空，表示图片上传失败，执行以下返回操作。
+                return Result.failed("图片上传失败");
+                // 返回一个表示操作失败的Result结果对象，包含提示信息“图片上传失败”，告知调用者图片上传过程出现问题，具体Result对象的结构和使用方式需结合项目中相关定义来看。
+            }
+            return Result.success("图片上传成功", url);
+            // 如果文件访问地址不为空，说明图片上传成功，返回一个表示操作成功的Result结果对象，包含提示信息“图片上传成功”以及上传后文件的访问地址（通过第二个参数传递），方便调用者获取图片的访问路径进行后续操作，具体Result对象的结构和使用方式需结合项目中相关定义来看。
+        }
+    }
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/service/impl/UserBookServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/UserBookServiceImpl.java
index 94c8b35..be69226 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/UserBookServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/UserBookServiceImpl.java
@@ -219,4 +219,65 @@ public class UserBookServiceImpl extends ServiceImpl<UserBookMapper, UserBook> i
                         .eq(UserBook::getExamId, reUserBookForm.getExamId())
                         .eq(UserBook::getQuId, reUserBookForm.getQuId());
                 userBookMapper.delete(userBookWrapper);
-                yield Result.success("回答正确");
\ No newline at end of file
+                yield Result.success("回答正确");
+            }
+            case 3 -> {
+                // 当满足条件为3时的逻辑分支，同样可能对应不同的题型或业务场景下的处理逻辑（具体依业务而定）
+                // 通过optionService（可能是选项相关的业务服务类）的getById方法，根据从reUserBookForm对象中获取的答案（推测此处答案可能是一个选项ID之类的标识），从数据库中获取对应的选项信息，存储在byId变量中。
+                Option byId = optionService.getById(reUserBookForm.getAnswer());
+                if (byId.getIsRight() == 1) {
+                    // 判断获取到的选项的“是否为正确答案”字段（isRight）的值是否为1，即判断用户选择的这个选项是否是正确答案。
+                    // 如果是正确答案，执行以下操作，准备从错题本中移除对应的题目记录。
+                    // 创建一个LambdaQueryWrapper<UserBook>对象，用于构建删除错题本记录的条件，方式和前面类似，目的是准确找到要删除的错题本记录。
+                    LambdaQueryWrapper<UserBook> userBookLambdaQueryWrapper = new LambdaQueryWrapper<>();
+                    // 添加查询条件，设置错题本记录对应的用户ID与通过SecurityUtil获取的当前登录用户的ID相等，限定操作的是当前用户的错题本记录。
+                    userBookLambdaQueryWrapper.eq(UserBook::getUserId, SecurityUtil.getUserId())
+                            // 继续添加条件，使错题本记录中的考试ID与从reUserBookForm对象中获取的考试ID相等，进一步确定要删除的错题本记录范围。
+                            .eq(UserBook::getExamId, reUserBookForm.getExamId())
+                            // 再添加条件，让错题本记录中的题目ID与从reUserBookForm对象中获取的题目ID相等，确保精准定位到要删除的那条错题本记录。
+                            .eq(UserBook::getQuId, reUserBookForm.getQuId());
+                    // 使用userBookMapper的delete方法，传入构建好的删除条件userBookLambdaQueryWrapper，从数据库中删除对应的错题本记录，实现移除错题本中已答对题目的功能。
+                    userBookMapper.delete(userBookLambdaQueryWrapper);
+                    // 设置addBookAnswerVO（可能是用于封装答题相关信息返回给前端等的对象）中的correct字段为1，表示回答正确，具体addBookAnswerVO的结构和使用场景需结合项目整体逻辑来看。
+                    addBookAnswerVO.setCorrect(1);
+                    // 返回一个表示回答正确的Result结果对象，同时包含提示信息“回答正确，已移除错题本”以及答题相关信息的addBookAnswerVO对象，方便前端展示和后续处理。
+                    yield Result.success("回答正确，已移除错题本", addBookAnswerVO);
+                } else {
+                    // 如果用户选择的选项不是正确答案，执行以下操作。
+                    // 设置addBookAnswerVO中的correct字段为0，表示回答错误，同样addBookAnswerVO的使用和含义需结合项目整体来看。
+                    addBookAnswerVO.setCorrect(0);
+                    // 返回一个表示回答错误的Result结果对象，同时包含答题相关信息的addBookAnswerVO对象，方便前端展示和后续处理。
+                    yield Result.success("回答错误", addBookAnswerVO);
+                }
+            }
+            case 4 -> {
+                // 当满足条件为4时的逻辑分支，也是对应特定业务场景下的处理逻辑（具体由业务规则决定）
+                if("1".equals(reUserBookForm.getAnswer())){
+                    // 判断用户作答的答案是否为 "1"（具体含义需结合业务来看，可能代表某种特定选择或情况），如果是则执行以下操作，准备从错题本中移除对应的题目记录。
+                    // 创建一个LambdaQueryWrapper<UserBook>对象，用于构建删除错题本记录的条件，和前面类似，用于准确找到要删除的错题本记录。
+                    LambdaQueryWrapper<UserBook> userBookLambdaQueryWrapper = new LambdaQueryWrapper<>();
+                    // 添加查询条件，设置错题本记录对应的用户ID与通过SecurityUtil获取的当前登录用户的ID相等，确保操作的是当前用户的错题本记录。
+                    userBookLambdaQueryWrapper.eq(UserBook::getUserId, SecurityUtil.getUserId())
+                            // 继续添加条件，使错题本记录中的考试ID与从reUserBookForm对象中获取的考试ID相等，进一步确定要删除的错题本记录范围。
+                            .eq(UserBook::getExamId, reUserBookForm.getExamId())
+                            // 再添加条件，让错题本记录中的题目ID与从reUserBookForm对象中获取的题目ID相等，确保精准定位到要删除的那条错题本记录。
+                            .eq(UserBook::getQuId, reUserBookForm.getQuId());
+                    // 使用userBookMapper的delete方法，传入构建好的删除条件userBookLambdaQueryWrapper，从数据库中删除对应的错题本记录，实现移除错题本中已答对题目的功能。
+                    userBookMapper.delete(userBookLambdaQueryWrapper);
+                    // 返回一个表示回答正确的Result结果对象，同时包含提示信息“回答正确，已移除错题本”以及答题相关信息的addBookAnswerVO对象，方便前端展示和后续处理。
+                    yield Result.success("回答正确，已移除错题本", addBookAnswerVO);
+                }
+                // 如果用户作答的答案不是 "1"，执行以下操作，表示回答错误。
+                addBookAnswerVO.setCorrect(0);
+                // 返回一个表示回答错误的Result结果对象，同时包含答题相关信息的addBookAnswerVO对象，方便前端展示和后续处理。
+                yield Result.success("回答错误", addBookAnswerVO);
+
+            }
+            default -> {
+                // 当以上所有case条件都不满足时的默认处理逻辑，即处理其他未明确列举的情况。
+                // 返回一个表示请求错误的Result结果对象，包含提示信息“请求错误，请联系管理员解决”，提示用户出现了不符合预期的情况，需要联系管理员进一步排查处理。
+                yield Result.failed("请求错误，请联系管理员解决");
+            }
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/util/CryptoUtils.java b/src/main/java/cn/org/alan/exam/util/CryptoUtils.java
index b24fd95..21a569f 100644
--- a/src/main/java/cn/org/alan/exam/util/CryptoUtils.java
+++ b/src/main/java/cn/org/alan/exam/util/CryptoUtils.java
@@ -1,7 +1,5 @@
 package cn.org.alan.exam.util;
 
-
-
 import cn.org.alan.exam.util.CryptoUtils.Algorithm.Encryption;
 import cn.org.alan.exam.util.CryptoUtils.Algorithm.Signing;
 import org.apache.commons.lang3.StringUtils;
@@ -11,7 +9,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import org.springframework.stereotype.Component;
 
-
 import javax.crypto.Cipher;
 import javax.crypto.KeyGenerator;
 import javax.crypto.NoSuchPaddingException;
@@ -40,7 +37,7 @@ import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
- * 支持AES、DES、RSA加密、数字签名以及生成对称密钥和非对称密钥对
+ * 支持AES、DES、RSA加密、数字签名以及生成对称密钥和非对称密钥对，该工具类提供了一系列加密、解密、签名、验签以及密钥生成相关的功能方法，方便在项目中进行安全相关的操作。
  */
 
 /**
@@ -51,353 +48,186 @@ import java.util.concurrent.ConcurrentHashMap;
 @Component
 public class CryptoUtils {
 
+    // 定义默认的字符编码格式为UTF-8，用于处理字符串和字节之间的转换操作，保证统一的编码标准。
     private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
+    // 获取Base64的编码器实例，用于将字节数据编码为Base64格式的字符串，常用于加密后数据的编码传输等场景。
     private static final Encoder BASE64_ENCODER = Base64.getEncoder();
+    // 获取Base64的解码器实例，用于将Base64格式的字符串解码为原始字节数据，比如在解密等操作前对密文进行解码。
     private static final Decoder BASE64_DECODER = Base64.getDecoder();
 
+    // 使用ConcurrentHashMap缓存KeyFactory实例，以算法（Algorithm类型）为键，方便后续快速获取相应算法的KeyFactory，避免重复创建，提高性能，并且支持并发访问。
     private static final Map<Algorithm, KeyFactory> KEY_FACTORY_CACHE = new ConcurrentHashMap<>();
+    // 使用HashMap缓存Cipher实例，同样以算法（Algorithm类型）为键，用于存储加密、解密操作时对应的Cipher对象，减少创建开销，但需注意非并发安全情况下的使用场景（此处代码中有相应的同步处理机制保证线程安全）。
     private static final Map<Algorithm, Cipher> CIPHER_CACHE = new HashMap<>();
 
     /**
-     * 生成对称密钥，目前支持的算法有AES、DES
-     * @param algorithm
-     * @return
-     * @throws NoSuchAlgorithmException
+     * 生成对称密钥，目前支持的算法有AES、DES，根据指定的算法生成相应的对称密钥，并将其编码为Base64格式的字符串返回。
+     *
+     * @param algorithm 要生成对称密钥的算法类型，通过Algorithm枚举类型传入，如Algorithm.AES_ECB_PKCS5等。
+     * @return 生成的对称密钥的Base64编码字符串表示形式。
+     * @throws NoSuchAlgorithmException 如果指定的算法不存在，则抛出此异常。
      */
     public static String generateSymmetricKey(Algorithm algorithm) throws NoSuchAlgorithmException {
+        // 根据指定的算法名称获取对应的KeyGenerator实例，用于生成对称密钥。
         KeyGenerator generator = KeyGenerator.getInstance(algorithm.getName());
+        // 使用算法对应的默认密钥长度（通过Algorithm中定义的keySize属性获取）初始化KeyGenerator，准备生成密钥。
         generator.init(algorithm.getKeySize());
+        // 生成对称密钥，返回的SecretKey对象包含了实际的密钥数据。
         SecretKey secretKey = generator.generateKey();
+        // 将生成的对称密钥转换为字节数组后，使用Base64编码器将其编码为字符串并返回，方便存储和传输。
         return BASE64_ENCODER.encodeToString(secretKey.getEncoded());
     }
 
     /**
-     * 生成非对称密钥对，目前支持的算法有RSA、DSA。备注：默认生成的密钥格式为PKCS8
-     * @param algorithm
-     * @return
-     * @throws NoSuchAlgorithmException
+     * 生成非对称密钥对，目前支持的算法有RSA、DSA。备注：默认生成的密钥格式为PKCS8，根据指定的非对称加密算法生成一对公钥和私钥，并分别编码为Base64格式的字符串，封装在AsymmetricKeyPair对象中返回。
+     *
+     * @param algorithm 要生成非对称密钥对的算法类型，通过Algorithm枚举类型传入，如Algorithm.RSA_ECB_PKCS1等。
+     * @return 包含生成的公钥和私钥的Base64编码字符串的AsymmetricKeyPair对象。
+     * @throws NoSuchAlgorithmException 如果指定的算法不存在，则抛出此异常。
      */
     public static AsymmetricKeyPair generateAsymmetricKeyPair(Algorithm algorithm) throws NoSuchAlgorithmException {
+        // 根据指定的算法名称获取对应的KeyPairGenerator实例，用于生成非对称密钥对。
         KeyPairGenerator generator = KeyPairGenerator.getInstance(algorithm.getName());
+        // 使用算法对应的默认密钥长度（通过Algorithm中定义的keySize属性获取）初始化KeyPairGenerator，准备生成密钥对。
         generator.initialize(algorithm.getKeySize());
+        // 生成非对称密钥对，返回的KeyPair对象包含了公钥和私钥。
         KeyPair keyPair = generator.generateKeyPair();
+        // 将公钥转换为字节数组后，使用Base64编码器将其编码为字符串，得到公钥的Base64编码表示形式。
         String publicKey = BASE64_ENCODER.encodeToString(keyPair.getPublic().getEncoded());
+        // 将私钥转换为字节数组后，使用Base64编码器将其编码为字符串，得到私钥的Base64编码表示形式。
         String privateKey = BASE64_ENCODER.encodeToString(keyPair.getPrivate().getEncoded());
+        // 创建AsymmetricKeyPair对象，将公钥和私钥的Base64编码字符串传入，封装后返回。
         return new AsymmetricKeyPair(publicKey, privateKey);
     }
 
+    /**
+     * 使用RSA算法（具体为RSA_ECB_PKCS1模式）对明文进行加密，调用encryptAsymmetrically方法实现加密逻辑，传入公钥文本和明文数据进行加密操作。
+     *
+     * @param publicKeyText 公钥的Base64编码字符串表示形式，用于加密操作。
+     * @param plainText 要加密的明文内容，即原始未加密的数据。
+     * @return 加密后的密文，以Base64编码字符串形式返回。
+     * @throws Exception 如果在加密过程中出现任何问题（如密钥格式错误、加密算法执行异常等），则抛出异常。
+     */
     public static String encryptByRSA(String publicKeyText, String plainText) throws Exception {
         return encryptAsymmetrically(publicKeyText, plainText, Encryption.RSA_ECB_PKCS1);
     }
 
+    /**
+     * 使用RSA算法（具体为RSA_ECB_PKCS1模式）对密文进行解密，调用decryptAsymmetrically方法实现解密逻辑，传入私钥文本和密文数据进行解密操作。
+     *
+     * @param privateKeyText 私钥的Base64编码字符串表示形式，用于解密操作。
+     * @param ciphertext 要解密的密文内容，即经过加密后的Base64编码字符串数据。
+     * @return 解密后的明文内容，以字符串形式返回。
+     * @throws Exception 如果在解密过程中出现任何问题（如密钥格式错误、解密算法执行异常等），则抛出异常。
+     */
     public static String decryptByRSA(String privateKeyText, String ciphertext) throws Exception {
         return decryptAsymmetrically(privateKeyText, ciphertext, Encryption.RSA_ECB_PKCS1);
     }
 
     /**
-     * SHA1签名算法和DSA加密算法结合使用生成数字签名
-     * @param privateKeyText
-     * @param msg
-     * @return 数字签名
-     * @throws Exception
+     * SHA1签名算法和DSA加密算法结合使用生成数字签名，调用doSign方法，传入私钥文本、待签名消息以及相应的加密和签名算法类型，实现数字签名的生成逻辑。
+     *
+     * @param privateKeyText 私钥的Base64编码字符串表示形式，用于数字签名操作。
+     * @param msg 待加签内容，即要进行数字签名的数据，通常是重要的业务信息等。
+     * @return 生成的数字签名，以Base64编码字符串形式返回。
+     * @throws Exception 如果在数字签名生成过程中出现任何问题（如密钥格式错误、签名算法执行异常等），则抛出异常。
      */
     public static String signBySHA1WithDSA(String privateKeyText, String msg) throws Exception {
         return doSign(privateKeyText, msg, Encryption.DSA, Signing.SHA1WithDSA);
     }
 
     /**
-     * SHA1签名算法和RSA加密算法结合使用生成数字签名
-     * @param privateKeyText 私钥
-     * @param msg 待加签内容
-     * @return 数字签名
-     * @throws Exception
+     * SHA1签名算法和RSA加密算法结合使用生成数字签名，调用doSign方法，传入私钥文本、待签名消息以及相应的加密和签名算法类型，实现数字签名的生成逻辑。
+     *
+     * @param privateKeyText 私钥的Base64编码字符串表示形式，用于数字签名操作。
+     * @param msg 待加签内容，即要进行数字签名的数据，通常是重要的业务信息等。
+     * @return 生成的数字签名，以Base64编码字符串形式返回。
+     * @throws Exception 如果在数字签名生成过程中出现任何问题（如密钥格式错误、签名算法执行异常等），则抛出异常。
      */
     public static String signBySHA1WithRSA(String privateKeyText, String msg) throws Exception {
         return doSign(privateKeyText, msg, Encryption.RSA_ECB_PKCS1, Signing.SHA1WithRSA);
     }
 
     /**
-     * SHA256签名算法和RSA加密算法结合使用生成数字签名
-     * @param privateKeyText 私钥
-     * @param msg 待加签内容
-     * @return 数字签名
-     * @throws Exception
+     * SHA256签名算法和RSA加密算法结合使用生成数字签名，调用doSign方法，传入私钥文本、待签名消息以及相应的加密和签名算法类型，实现数字签名的生成逻辑。
+     *
+     * @param privateKeyText 私钥的Base64编码字符串表示形式，用于数字签名操作。
+     * @param msg 待加签内容，即要进行数字签名的数据，通常是重要的业务信息等。
+     * @return 生成的数字签名，以Base64编码字符串形式返回。
+     * @throws Exception 如果在数字签名生成过程中出现任何问题（如密钥格式错误、签名算法执行异常等），则抛出异常。
      */
     public static String signBySHA256WithRSA(String privateKeyText, String msg) throws Exception {
         return doSign(privateKeyText, msg, Encryption.RSA_ECB_PKCS1, Signing.SHA256WithRSA);
     }
 
     /**
-     * SHA1签名算法和DSA加密算法检验数字签名
-     * @param publicKeyText 公钥
-     * @param msg 待验签内容
-     * @param signatureText 数字
-     * @return 检验是否成功
-     * @throws Exception
+     * SHA1签名算法和DSA加密算法检验数字签名，调用doVerify方法，传入公钥文本、待验签内容、数字签名以及相应的加密和签名算法类型，实现数字签名验证逻辑，判断签名是否有效。
+     *
+     * @param publicKeyText 公钥的Base64编码字符串表示形式，用于数字签名验证操作。
+     * @param msg 待验签内容，即要验证数字签名对应的原始数据，需与签名时的数据一致。
+     * @param signatureText 数字签名的Base64编码字符串表示形式，用于验证是否匹配。
+     * @return 检验是否成功，返回true表示数字签名验证通过，即签名有效；返回false表示验证失败，签名可能被篡改或无效。
+     * @throws Exception 如果在数字签名验证过程中出现任何问题（如密钥格式错误、验证算法执行异常等），则抛出异常。
      */
     public static boolean verifyBySHA1WithDSA(String publicKeyText, String msg, String signatureText) throws Exception {
         return doVerify(publicKeyText, msg, signatureText, Encryption.DSA, Signing.SHA1WithDSA);
     }
 
     /**
-     * SHA1签名算法和RSA加密算法检验数字签名
-     * @param publicKeyText 公钥
-     * @param msg 待验签内容
-     * @param signatureText 签名
-     * @return 校验是否成功
-     * @throws Exception
+     * SHA1签名算法和RSA加密算法检验数字签名，调用doVerify方法，传入公钥文本、待验签内容、数字签名以及相应的加密和签名算法类型，实现数字签名验证逻辑，判断签名是否有效。
+     *
+     * @param publicKeyText 公钥的Base64编码字符串表示形式，用于数字签名验证操作。
+     * @param msg 待验签内容，即要验证数字签名对应的原始数据，需与签名时的数据一致。
+     * @param signatureText 签名的Base64编码字符串表示形式，用于验证是否匹配。
+     * @return 校验是否成功，返回true表示数字签名验证通过，即签名有效；返回false表示验证失败，签名可能被篡改或无效。
+     * @throws Exception 如果在数字签名验证过程中出现任何问题（如密钥格式错误、验证算法执行异常等），则抛出异常。
      */
     public static boolean verifyBySHA1WithRSA(String publicKeyText, String msg, String signatureText) throws Exception {
         return doVerify(publicKeyText, msg, signatureText, Encryption.RSA_ECB_PKCS1, Signing.SHA1WithRSA);
     }
 
     /**
-     * SHA256签名算法和RSA加密算法检验数字签名
-     * @param publicKeyText 公钥
-     * @param msg 待验签内容
-     * @param signatureText 签名
-     * @return 校验是否成功
-     * @throws Exception
+     * SHA256签名算法和RSA加密算法检验数字签名，调用doVerify方法，传入公钥文本、待验签内容、数字签名以及相应的加密和签名算法类型，实现数字签名验证逻辑，判断签名是否有效。
+     *
+     * @param publicKeyText 公钥的Base64编码字符串表示形式，用于数字签名验证操作。
+     * @param msg 待验签内容，即要验证数字签名对应的原始数据，需与签名时的数据一致。
+     * @param signatureText 签名的Base64编码字符串表示形式，用于验证是否匹配。
+     * @return 校验是否成功，返回true表示数字签名验证通过，即签名有效；返回false表示验证失败，签名可能被篡改或无效。
+     * @throws Exception 如果在数字签名验证过程中出现任何问题（如密钥格式错误、验证算法执行异常等），则抛出异常。
      */
-    public static boolean verifyBySHA256WithRSA(String publicKeyText, String msg, String signatureText) throws Exception {
+    public static boolean verifyBySHA256WithRSA(String publicKeyText, String msg, signatureText) throws Exception {
         return doVerify(publicKeyText, msg, signatureText, Encryption.RSA_ECB_PKCS1, Signing.SHA256WithRSA);
     }
 
     /**
-     * 对称加密
-     * @param secretKey 密钥
-     * @param iv 加密向量，只有CBC模式才支持，如果是CBC则必传
-     * @param plainText 明文
-     * @param algorithm 对称加密算法，如AES、DES
-     * @return
-     * @throws Exception
+     * 对称加密，根据传入的对称密钥、加密向量（部分模式需要）、明文以及指定的对称加密算法，对明文进行加密操作，并返回加密后的密文（Base64编码字符串形式）。
+     *
+     * @param secretKey 对称密钥的Base64编码字符串表示形式，用于加密操作。
+     * @param iv 加密向量，只有CBC模式才支持，如果是CBC则必传，用于增加加密的安全性和随机性（不同模式下使用情况不同）。
+     * @param plainText 要加密的明文内容，即原始未加密的数据。
+     * @param algorithm 对称加密算法类型，通过Algorithm枚举类型传入，如Algorithm.AES_ECB_PKCS5等。
+     * @return 加密后的密文，以Base64编码字符串形式返回。
+     * @throws Exception 如果在加密过程中出现任何问题（如密钥格式错误、加密算法执行异常等），则抛出异常。
      */
     public static String encryptSymmetrically(String secretKey, String iv, String plainText, Algorithm algorithm) throws Exception {
+        // 先将Base64编码的对称密钥解码并重新生成SecretKey实例，用于后续的加密操作。
         SecretKey key = decodeSymmetricKey(secretKey, algorithm);
-        IvParameterSpec ivParameterSpec = StringUtils.isBlank(iv) ? null : decodeIv(iv);
+        // 根据传入的加密向量字符串（如果非空）解码生成IvParameterSpec实例，用于指定加密的初始向量信息（CBC模式等需要），若为空则设置为null表示不需要初始向量（如ECB模式）。
+        IvParameterSpec ivParameterSpec = StringUtils.isBlank(iv)? null : decodeIv(iv);
+        // 将明文字符串按照默认字符编码格式（UTF-8）转换为字节数组，准备进行加密操作。
         byte[] plainTextInBytes = plainText.getBytes(DEFAULT_CHARSET);
+        // 调用transform方法，传入算法、加密模式、密钥、加密向量以及明文字节数组，执行实际的加密操作，得到加密后的字节数组。
         byte[] ciphertextInBytes = transform(algorithm, Cipher.ENCRYPT_MODE, key, ivParameterSpec, plainTextInBytes);
 
+        // 将加密后的字节数组使用Base64编码器转换为字符串并返回，作为最终的加密结果（密文）。
         return BASE64_ENCODER.encodeToString(ciphertextInBytes);
     }
 
-    /**
-     * 对称解密
-     * @param secretKey 密钥
-     * @param iv 加密向量，只有CBC模式才支持，如果是CBC则必传
-     * @param ciphertext 密文
-     * @param algorithm 对称加密算法，如AES、DES
-     * @return
-     * @throws Exception
-     */
-    public static String decryptSymmetrically(String secretKey, String iv, String ciphertext, Algorithm algorithm) throws Exception {
-        SecretKey key = decodeSymmetricKey(secretKey, algorithm);
-        IvParameterSpec ivParameterSpec = StringUtils.isBlank(iv) ? null : decodeIv(iv);
-        byte[] ciphertextInBytes = BASE64_DECODER.decode(ciphertext);
-        byte[] plainTextInBytes = transform(algorithm, Cipher.DECRYPT_MODE, key, ivParameterSpec, ciphertextInBytes);
-        return new String(plainTextInBytes, DEFAULT_CHARSET);
-    }
-
-    /**
-     * 非对称加密
-     * @param publicKeyText 公钥
-     * @param plainText 明文
-     * @param algorithm 非对称加密算法
-     * @return
-     * @throws Exception
-     */
-    public static String encryptAsymmetrically(String publicKeyText, String plainText, Algorithm algorithm) throws Exception {
-        PublicKey publicKey = regeneratePublicKey(publicKeyText, algorithm);
-        byte[] plainTextInBytes = plainText.getBytes(DEFAULT_CHARSET);
-        byte[] ciphertextInBytes = transform(algorithm, Cipher.ENCRYPT_MODE, publicKey, plainTextInBytes);
-        return BASE64_ENCODER.encodeToString(ciphertextInBytes);
-    }
-
-    /**
-     * 非对称解密
-     * @param privateKeyText 私钥
-     * @param ciphertext 密文
-     * @param algorithm 非对称加密算法
-     * @return
-     * @throws Exception
-     */
-    public static String decryptAsymmetrically(String privateKeyText, String ciphertext, Algorithm algorithm) throws Exception {
-        PrivateKey privateKey = regeneratePrivateKey(privateKeyText, algorithm);
-        byte[] ciphertextInBytes = BASE64_DECODER.decode(ciphertext);
-        byte[] plainTextInBytes = transform(algorithm, Cipher.DECRYPT_MODE, privateKey, ciphertextInBytes);
-        return new String(plainTextInBytes, DEFAULT_CHARSET);
-    }
-
-    /**
-     * 生成数字签名
-     * @param privateKeyText 私钥
-     * @param msg 传输的数据
-     * @param encryptionAlgorithm 加密算法，见Algorithm中的加密算法
-     * @param signatureAlgorithm 签名算法，见Algorithm中的签名算法
-     * @return 数字签名
-     * @throws Exception
-     */
-    public static String doSign(String privateKeyText, String msg, Algorithm encryptionAlgorithm, Algorithm signatureAlgorithm)
-            throws Exception {
-        PrivateKey privateKey = regeneratePrivateKey(privateKeyText, encryptionAlgorithm);
-        // Signature只支持签名算法
-        Signature signature = Signature.getInstance(signatureAlgorithm.getName());
-        signature.initSign(privateKey);
-        signature.update(msg.getBytes(DEFAULT_CHARSET));
-        byte[] signatureInBytes = signature.sign();
-        return BASE64_ENCODER.encodeToString(signatureInBytes);
-    }
-
-    /**
-     * 数字签名验证
-     * @param publicKeyText 公钥
-     * @param msg 传输的数据
-     * @param signatureText 数字签名
-     * @param encryptionAlgorithm 加密算法，见Algorithm中的加密算法
-     * @param signatureAlgorithm 签名算法，见Algorithm中的签名算法
-     * @return 校验是否成功
-     * @throws Exception
-     */
-    public static boolean doVerify(String publicKeyText, String msg, String signatureText, Algorithm encryptionAlgorithm,
-                                   Algorithm signatureAlgorithm) throws Exception {
-        PublicKey publicKey = regeneratePublicKey(publicKeyText, encryptionAlgorithm);
-        Signature signature = Signature.getInstance(signatureAlgorithm.getName());
-        signature.initVerify(publicKey);
-        signature.update(msg.getBytes(DEFAULT_CHARSET));
-        return signature.verify(BASE64_DECODER.decode(signatureText));
-    }
-
-    /**
-     * 将密钥进行Base64位解码，重新生成SecretKey实例
-     * @param secretKey 密钥
-     * @param algorithm 算法
-     * @return
-     */
-    private static SecretKey decodeSymmetricKey(String secretKey, Algorithm algorithm) {
-        byte[] key = BASE64_DECODER.decode(secretKey);
-        return new SecretKeySpec(key, algorithm.getName());
-    }
-
-    private static IvParameterSpec decodeIv(String iv) {
-        byte[] ivInBytes = BASE64_DECODER.decode(iv);
-        return new IvParameterSpec(ivInBytes);
-    }
-
-    private static PublicKey regeneratePublicKey(String publicKeyText, Algorithm algorithm)
-            throws NoSuchAlgorithmException, InvalidKeySpecException {
-        byte[] keyInBytes = BASE64_DECODER.decode(publicKeyText);
-        KeyFactory keyFactory = getKeyFactory(algorithm);
-        // 公钥必须使用RSAPublicKeySpec或者X509EncodedKeySpec
-        KeySpec publicKeySpec = new X509EncodedKeySpec(keyInBytes);
-        PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
-        return publicKey;
-    }
-
-    private static PrivateKey regeneratePrivateKey(String key, Algorithm algorithm) throws Exception {
-        byte[] keyInBytes = BASE64_DECODER.decode(key);
-        KeyFactory keyFactory = getKeyFactory(algorithm);
-        // 私钥必须使用RSAPrivateCrtKeySpec或者PKCS8EncodedKeySpec
-        KeySpec privateKeySpec = new PKCS8EncodedKeySpec(keyInBytes);
-        PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);
-        return privateKey;
-    }
-
-    private static KeyFactory getKeyFactory(Algorithm algorithm) throws NoSuchAlgorithmException {
-        KeyFactory keyFactory = KEY_FACTORY_CACHE.get(algorithm);
-        if (keyFactory == null) {
-            keyFactory = KeyFactory.getInstance(algorithm.getName());
-            KEY_FACTORY_CACHE.put(algorithm, keyFactory);
-        }
-
-        return keyFactory;
-    }
-
-    private static byte[] transform(Algorithm algorithm, int mode, Key key, byte[] msg) throws Exception {
-        return transform(algorithm, mode, key, null, msg);
-    }
-
-    private static byte[] transform(Algorithm algorithm, int mode, Key key, IvParameterSpec iv, byte[] msg) throws Exception {
-        Cipher cipher = CIPHER_CACHE.get(algorithm);
-        // double check，减少上下文切换
-        if (cipher == null) {
-            synchronized (CryptoUtils.class) {
-                if ((cipher = CIPHER_CACHE.get(algorithm)) == null) {
-                    cipher = determineWhichCipherToUse(algorithm);
-                    CIPHER_CACHE.put(algorithm, cipher);
-                }
-                cipher.init(mode, key, iv);
-                return cipher.doFinal(msg);
-            }
-        }
-
-        synchronized (CryptoUtils.class) {
-            cipher.init(mode, key, iv);
-            return cipher.doFinal(msg);
-        }
-    }
-
-    private static Cipher determineWhichCipherToUse(Algorithm algorithm) throws NoSuchAlgorithmException, NoSuchPaddingException {
-        Cipher cipher;
-        String transformation = algorithm.getTransformation();
-        // 官方推荐的transformation使用algorithm/mode/padding组合，SunJCE使用ECB作为默认模式，使用PKCS5Padding作为默认填充
-        if (StringUtils.isNotEmpty(transformation)) {
-            cipher = Cipher.getInstance(transformation);
-        } else {
-            cipher = Cipher.getInstance(algorithm.getName());
-        }
-
-        return cipher;
-    }
-
-    /**
-     * 算法分为加密算法和签名算法，更多算法实现见：<br/>
-     * <a href="https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html#impl">jdk8中的标准算法</a>
-     */
-    public static class Algorithm {
-
-        public interface Encryption {
-            Algorithm AES_ECB_PKCS5 = new Algorithm("AES", "AES/ECB/PKCS5Padding", 128);
-            Algorithm AES_CBC_PKCS5 = new Algorithm("AES", "AES/CBC/PKCS5Padding", 128);
-            Algorithm DES_ECB_PKCS5 = new Algorithm("DES", "DES/ECB/PKCS5Padding", 56);
-            Algorithm DES_CBC_PKCS5 = new Algorithm("DES", "DES/CBC/PKCS5Padding", 56);
-            Algorithm RSA_ECB_PKCS1 = new Algorithm("RSA", "RSA/ECB/PKCS1Padding", 1024);
-            Algorithm DSA = new Algorithm("DSA", 1024);
-        }
-
-        public interface Signing {
-            Algorithm SHA1WithDSA = new Algorithm("SHA1withDSA", 1024);
-            Algorithm SHA1WithRSA = new Algorithm("SHA1WithRSA", 2048);
-            Algorithm SHA256WithRSA = new Algorithm("SHA256WithRSA", 2048);
-        }
-
-        @Getter
-        private String name;
-        @Getter
-        private String transformation;
-        @Getter
-        private int keySize;
-
-        public Algorithm(String name, int keySize) {
-            this(name, null, keySize);
-        }
-
-        public Algorithm(String name, String transformation, int keySize) {
-            this.name = name;
-            this.transformation = transformation;
-            this.keySize = keySize;
-        }
-
-    }
-
-    @Data
-    @NoArgsConstructor
-    @AllArgsConstructor
-    public static class AsymmetricKeyPair {
-
-        private String publicKey;
-        private String privateKey;
-    }
-
-}
-
-
+/**
+ * 对称解密，根据传入的对称密钥、加密向量（部分模式需要）、密文以及指定的对称加密算法，对密文进行解密操作，并返回解密后的明文内容。
+ *
+ * @param secretKey 对称密钥的Base64编码字符串表示形式，用于解密操作。
+ * @param iv 加密向量，只有CBC模式才支持，如果是CBC则必传，用于匹配加密时的初始向量信息（保证解密正确）。
+ * @param ciphertext 要解密的密文内容，即经过加密后的Base64编码字符串数据。
+ * @param algorithm 对称加密算法类型，通过Algorithm枚举类型传入，如Algorithm.AES_ECB_PKCS5等。
+ * @return 解密后的明文内容，以字符串形式返回。
\ No newline at end of file
-- 
2.34.1


From 71041f45b0a9760f9e271c9c0845f03a82284b2f Mon Sep 17 00:00:00 2001
From: fmy <2733603802@qq.com>
Date: Wed, 18 Dec 2024 17:37:59 +0800
Subject: [PATCH 10/10] main1122

---
 .../exam/service/impl/UserServiceImpl.java    | 127 +++++-
 .../cn/org/alan/exam/util/CryptoUtils.java    | 362 +++++++++++++++++-
 2 files changed, 484 insertions(+), 5 deletions(-)

diff --git a/src/main/java/cn/org/alan/exam/service/impl/UserServiceImpl.java b/src/main/java/cn/org/alan/exam/service/impl/UserServiceImpl.java
index ee0d0cc..134b6fc 100644
--- a/src/main/java/cn/org/alan/exam/service/impl/UserServiceImpl.java
+++ b/src/main/java/cn/org/alan/exam/service/impl/UserServiceImpl.java
@@ -205,13 +205,132 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IU
 
     // 从Excel文件导入用户数据的方法，事务性操作，先对文件类型进行判断，读取文件内容并补充必要的参数，然后将用户数据批量插入到数据库中，成功返回导入成功的提示信息，失败返回相应错误提示，使用了异常处理注解来简化异常抛出处理。
     @SneakyThrows(Exception.class)
+// 使用 @SneakyThrows 注解，当方法内部抛出 Exception 异常时，会自动将异常向上抛出，避免了显式编写 try-catch 块来处理异常（但需要注意在合适的调用层次上进行统一的异常处理），这里表示该方法可能会出现各种异常情况，都统一按此方式处理。
     @Override
+// 表示重写了接口中定义的方法，说明该方法是实现某个接口规范要求的具体实现逻辑。
     @Transactional
+// 声明该方法是事务性的，意味着在这个方法执行过程中涉及到的数据库操作（如插入、更新、删除等）会被当作一个整体事务来处理，要么全部成功提交，要么全部回滚，保证数据的一致性和完整性。
     public Result<String> importUsers(MultipartFile file) {
-        // 文件类型判断，调用ExcelUtils工具类的isExcel方法，检查传入的文件是否是合法的Excel文件（xls或xlsx格式），如果不是则返回文件类型错误的提示信息。
+        // 文件类型判断
+        // 检查传入的文件是否是合法的 Excel 文件（xls 或 xlsx 格式），调用 ExcelUtils 工具类的 isExcel 方法进行判断，传入文件的原始文件名（通过 Objects.requireNonNull 确保文件名不为空）。
         if (!ExcelUtils.isExcel(Objects.requireNonNull(file.getOriginalFilename()))) {
-            return Result.failed("文件类型必须是xls或xlsx");
+            // 如果不是合法的 Excel 文件格式，返回一个表示操作失败的 Result 结果对象，其中包含提示信息“文件类型必须是 xls 或 xlsx”，告知调用者文件格式不符合要求，具体 Result 对象的结构和使用方式需结合项目中相关定义来看。
+            return Result.failed("文件类型必须是 xls 或 xlsx");
         }
-        // 读取文件，调用ExcelUtils的readMultipartFile方法，读取传入的MultipartFile类型的Excel文件，并转换为UserForm对象列表（假设该方法实现了读取并转换逻辑）。
+        // 读取文件
+        // 调用 ExcelUtils 工具类的 readMultipartFile 方法，传入文件对象和 UserForm 类信息，读取 Excel 文件内容并转换为 UserForm 类型的列表，UserForm 可能是用于接收 Excel 文件中每行数据对应的用户信息的表单对象，存储在 list 变量中。
         List<UserForm> list = ExcelUtils.readMultipartFile(file, UserForm.class);
-        // 参数补充，遍历读取到的UserForm对象列表
\ No newline at end of file
+        // 参数补充
+        // 遍历读取到的 UserForm 列表，对每个 UserForm 对象进行一些必要参数的补充设置操作，以下是具体的设置逻辑。
+        list.forEach(userForm -> {
+            // 使用 BCryptPasswordEncoder（Spring Security 提供的密码加密工具类）对默认密码“123456”进行加密，并将加密后的密码设置到 UserForm 对象的密码字段中，通常用于为新导入的用户设置初始密码。
+            userForm.setPassword(new BCryptPasswordEncoder().encode("123456"));
+            // 调用 DateTimeUtil 工具类的 getDateTime 方法获取当前日期时间信息，并设置到 UserForm 对象的创建时间（createTime）字段中，用于记录用户的创建时间。
+            userForm.setCreateTime(DateTimeUtil.getDateTime());
+            // 判断 UserForm 对象中的角色 ID（roleId）字段是否为 null，如果是，表示没有指定角色，这里默认将角色 ID 设置为 1（具体角色 ID 为 1 代表什么角色需结合业务逻辑确定，可能是学生等默认角色）。
+            if (userForm.getRoleId() == null) {
+                userForm.setRoleId(1);
+            }
+        });
+
+        // 判断读取到的用户信息列表的大小是否超过 300，如果超过了限制数量，返回一个表示操作失败的 Result 结果对象，包含提示信息“表中最多存放 300 条数据”，告知调用者导入的数据量超出了允许范围。
+        if (list.size() > 300) {
+            return Result.failed("表中最多存放 300 条数据");
+        }
+        // 调用 userMapper（可能是操作用户数据的持久层接口，用于与数据库交互）的 insertBatchUser 方法，先使用 userConverter（可能是用于对象转换的工具类）的 listFromToEntity 方法将 UserForm 列表转换为对应的用户实体对象列表，然后将这些用户实体对象批量插入到数据库中，实现批量导入用户的功能。
+        userMapper.insertBatchUser(userConverter.listFromToEntity(list));
+        // 如果用户数据批量插入成功，返回一个表示操作成功的 Result 结果对象，包含提示信息“用户导入成功”，告知调用者用户导入操作已顺利完成，具体 Result 对象的结构和使用方式需结合项目中相关定义来看。
+        return Result.success("用户导入成功");
+    }
+
+    @Override
+// 重写接口中定义的方法，用于获取用户信息相关的业务逻辑实现。
+    public Result<UserVO> info() {
+        // 调用 userMapper（操作用户数据的持久层接口）的 info 方法，传入通过 SecurityUtil 工具类获取的当前登录用户的 ID（SecurityUtil.getUserId() 获取用户 ID 的具体实现逻辑在该工具类中定义），从数据库中查询并获取当前用户的详细信息，返回的是 UserVO 类型的对象，UserVO 可能是用于展示给前端等调用者的用户视图对象，包含了部分用户信息，存储在 userVo 变量中。
+        UserVO userVo = userMapper.info(SecurityUtil.getUserId());
+        // 将获取到的用户视图对象 userVo 中的密码字段设置为 null，可能出于安全考虑，防止将密码信息传递到前端等地方，保证用户信息的安全性。
+        userVo.setPassword(null);
+        // 返回一个表示操作成功的 Result 结果对象，第二个参数传入处理后的用户视图对象 userVo，告知调用者获取用户信息成功，并将用户信息传递给调用者，具体 Result 对象的结构和使用方式需结合项目中相关定义来看，这里第一个参数传入 null 可能是符合 Result 类的构造函数要求或者业务上不需要额外传递特定的提示信息（具体依项目设定）。
+        return Result.success(null, userVo);
+    }
+
+    @Override
+// 重写接口中定义的方法，用于用户加入班级相关的业务逻辑实现。
+    public Result<String> joinGrade(String code) {
+        // 获取班级信息
+        // 创建一个 LambdaQueryWrapper<Grade> 对象，用于构建查询班级信息的条件，LambdaQueryWrapper 是 MyBatis Plus 提供的方便构建查询条件的工具类，这里用于查询 Grade 类型（可能代表班级实体类）的数据。
+        LambdaQueryWrapper<Grade> wrapper = new LambdaQueryWrapper<Grade>().eq(Grade::getCode, code);
+        // 调用 gradeMapper（可能是操作班级数据的持久层接口）的 selectOne 方法，传入构建好的查询条件 wrapper，从数据库中查询符合班级口令（code）的班级信息，返回的是 Grade 类型的对象，代表查询到的班级实体信息，存储在 grade 变量中，如果没有找到匹配的班级则返回 null。
+        Grade grade = gradeMapper.selectOne(wrapper);
+        // 判断查询到的班级对象是否为 null，如果是，表示没有找到对应的班级（班级口令不存在），返回一个表示操作失败的 Result 结果对象，包含提示信息“班级口令不存在”，告知调用者输入的班级口令有误，无法加入班级，具体 Result 对象的结构和使用方式需结合项目中相关定义来看。
+        if (Objects.isNull(grade)) {
+            return Result.failed("班级口令不存在");
+        }
+        // 创建一个 User 类型的用户对象，用于后续更新用户与班级关联信息的操作，这里先初始化该对象。
+        User user = new User();
+        // 设置用户对象的 ID 为通过 SecurityUtil 工具类获取的当前登录用户的 ID，确保操作的是当前登录用户的信息。
+        user.setId(SecurityUtil.getUserId());
+        // 设置用户对象的班级 ID（gradeId）为查询到的班级的 ID（grade.getId()），建立用户与班级的关联关系，准备将当前用户加入到该班级中。
+        user.setGradeId(grade.getId());
+        // 调用 userMapper 的 updateById 方法，传入构建好的用户对象，根据用户 ID 更新数据库中对应用户的班级关联信息，返回受影响的行数，即实际更新的记录数，存储在 updated 变量中。
+        int updated = userMapper.updateById(user);
+        // 判断更新操作影响的行数是否大于 0，如果大于 0，表示用户成功加入班级，执行以下操作。
+        if (updated > 0) {
+            // 调用 stringRedisTemplate（用于操作 Redis 字符串类型数据的工具类，常用于缓存相关操作）的 delete 方法，删除 Redis 中对应缓存键（格式为 "cache:grade:getPaging:" 加上当前登录用户的 ID 的字符串形式）的缓存数据，目的可能是清除与用户班级相关的缓存信息，确保后续获取的班级信息是最新的。
+            stringRedisTemplate.delete("cache:grade:getPaging:" + SecurityUtil.getUserId().toString());
+            // 返回一个表示操作成功的 Result 结果对象，包含提示信息“加入班级：”加上班级名称（grade.getGradeName()）再加上“成功”，告知调用者已成功加入指定班级，具体 Result 对象的结构和使用方式需结合项目中相关定义来看。
+            return Result.success("加入班级：" + grade.getGradeName() + "成功");
+        }
+        // 如果更新操作影响的行数不大于 0，表示用户加入班级操作失败，返回一个表示操作失败的 Result 结果对象，包含提示信息“加入失败”，告知调用者加入班级的操作未成功，具体 Result 对象的结构和使用方式需结合项目中相关定义来看。
+        return Result.failed("加入失败");
+    }
+
+    @Override
+// 重写接口中定义的方法，用于实现用户分页查询相关的业务逻辑。
+    public Result<IPage<UserVO>> pagingUser(Integer pageNum, Integer pageSize, Integer gradeId, String realName) {
+        // 创建一个 IPage<UserVO> 类型的分页对象 page，使用 Page 的构造函数进行初始化，传入当前页码 pageNum 和每页显示数量 pageSize，用于构建分页相关的数据结构，方便后续设置分页数据以及返回给前端进行分页展示等操作。
+        IPage<UserVO> page = new Page<>(pageNum, pageSize);
+        // 判断当前用户的角色（通过 SecurityUtil 工具类的 getRole 方法获取，具体获取逻辑在该工具类中定义）是否为“role_teacher”（可能代表教师角色，具体含义由业务定义），如果是教师角色，执行以下操作。
+        if ("role_teacher".equals(SecurityUtil.getRole())) {
+            // 调用 userMapper 的 pagingUser 方法，传入分页对象 page、班级 ID（gradeId）、真实姓名（realName）、当前登录用户的 ID（SecurityUtil.getUserId()）以及参数 1（具体该参数含义需结合业务逻辑确定，可能与教师角色下的查询条件等相关），根据这些条件查询并设置分页对象 page 中的用户数据信息，用于教师角色下的用户分页查询逻辑。
+            page = userMapper.pagingUser(page, gradeId, realName, SecurityUtil.getUserId(), 1);
+        } else {
+            // 如果当前用户不是教师角色，执行以下操作，同样调用 userMapper 的 pagingUser 方法，但传入的最后一个参数为 null（可能对应非教师角色下不同的查询条件或业务逻辑），根据相应条件查询并设置分页对象 page 中的用户数据信息，用于其他角色下的用户分页查询逻辑。
+            page = userMapper.pagingUser(page, gradeId, realName, SecurityUtil.getUserId(), null);
+        }
+
+        // 返回一个表示操作成功的 Result 结果对象，第二个参数传入构建好的分页对象 page，告知调用者用户分页查询成功，并将分页查询结果传递给调用者，具体 Result 对象的结构和使用方式需结合项目中相关定义来看，这里第一个参数传入 null 可能是符合 Result 类的构造函数要求或者业务上不需要额外传递特定的提示信息（具体依项目设定）。
+        return Result.success(null, page);
+    }
+
+    @Transactional
+// 声明该方法是事务性的，保证方法内涉及的数据库操作作为一个整体事务处理，确保数据一致性和完整性。
+    @Override
+// 重写接口中定义的方法，用于实现用户上传头像相关的业务逻辑。
+    public Result<String> uploadAvatar(MultipartFile file) {
+        // 调用 iQuestionService（可能是与题目相关的业务服务类，这里复用了其上传图片的功能，具体原因需结合业务逻辑确定）的 uploadImage 方法，传入文件对象，尝试上传用户头像文件，并获取上传操作的结果信息，存储在 result 变量中。
+        Result<String> result = iQuestionService.uploadImage(file);
+        // 打印上传操作的结果信息，可能用于调试等目的，查看上传过程中的返回结果情况（在实际生产环境中可能需要根据日志级别等进行合理配置，避免过多不必要的输出）。
+        System.out.println(result);
+        // 判断上传结果的状态码（通过 result.getCode() 获取，具体 Result 类中 code 字段的定义和含义需结合项目中相关定义来看）是否为 0，如果是 0，表示图片上传失败，执行以下返回操作。
+        if (result.getCode() == 0) {
+            return Result.failed("图片上传失败");
+        }
+        // 如果上传结果状态码不为 0，表示图片上传成功，获取上传后图片的访问地址（通过 result.getData() 获取，具体 Result 类中 data 字段用于存储相关数据的定义需结合项目中相关定义来看），存储在 url 变量中。
+        String url = result.getData();
+        // 再次打印图片的访问地址，同样可能用于调试等目的，查看获取到的地址是否正确（在实际应用中可根据情况决定是否保留此输出语句）。
+        System.out.println(url);
+        // 创建一个 User 类型的用户对象，用于后续更新用户头像信息的操作，这里先初始化该对象。
+        User user = new User();
+        // 设置用户对象的 ID 为通过 SecurityUtil 工具类获取的当前登录用户的 ID，确保操作的是当前登录用户的头像信息。
+        user.setId(SecurityUtil.getUserId());
+        // 设置用户对象的头像字段（avatar）为获取到的图片访问地址 url，准备将用户头像更新为新上传的图片。
+        user.setAvatar(url);
+        // 调用 userMapper 的 updateById 方法，传入构建好的用户对象，根据用户 ID 更新数据库中对应用户的头像信息，返回受影响的行数，即实际更新的记录数，判断该行数是否大于 0，如果大于 0，表示头像更新成功，执行以下返回操作。
+        if (userMapper.updateById(user) > 0) {
+            // 返回一个表示操作成功的 Result 结果对象，包含提示信息“上传成功”以及上传后图片的访问地址 url，告知调用者头像上传成功，并将图片地址传递给调用者，方便后续使用（比如在前端展示用户头像等），具体 Result 对象的结构和使用方式需结合项目中相关定义来看。
+            return Result.success("上传成功", url);
+        }
+        // 如果更新操作影响的行数不大于 0，表示头像更新失败，返回一个表示操作失败的 Result 结果对象，包含提示信息“图片上传失败”，告知调用者头像上传操作未成功，具体 Result 对象的结构和使用方式需结合项目中相关定义来看。
+        return Result.failed("图片上传失败");
+    }
\ No newline at end of file
diff --git a/src/main/java/cn/org/alan/exam/util/CryptoUtils.java b/src/main/java/cn/org/alan/exam/util/CryptoUtils.java
index 21a569f..1ab5e24 100644
--- a/src/main/java/cn/org/alan/exam/util/CryptoUtils.java
+++ b/src/main/java/cn/org/alan/exam/util/CryptoUtils.java
@@ -230,4 +230,364 @@ public class CryptoUtils {
  * @param iv 加密向量，只有CBC模式才支持，如果是CBC则必传，用于匹配加密时的初始向量信息（保证解密正确）。
  * @param ciphertext 要解密的密文内容，即经过加密后的Base64编码字符串数据。
  * @param algorithm 对称加密算法类型，通过Algorithm枚举类型传入，如Algorithm.AES_ECB_PKCS5等。
- * @return 解密后的明文内容，以字符串形式返回。
\ No newline at end of file
+ * @return 解密后的明文内容，以字符串形式返回。
+ * @throws Exception
+ */
+public static boolean verifyBySHA256WithRSA(String publicKeyText, String msg, String signatureText) throws Exception {
+    // 调用doVerify方法，传入公钥文本（publicKeyText）、待验证的消息（msg）、数字签名文本（signatureText）以及指定的加密算法（Encryption.RSA_ECB_PKCS1）和签名算法（Signing.SHA256WithRSA），
+    // 目的是使用RSA加密算法结合SHA256签名算法来验证给定的数字签名是否与消息匹配，最终返回验证结果（true表示验证通过，false表示验证失败）。
+    return doVerify(publicKeyText, msg, signatureText, Encryption.RSA_ECB_PKCS1, Signing.SHA256WithRSA);
+}
+
+    /**
+     * 对称加密
+     * @param secretKey 密钥，以Base64编码字符串形式传入，用于对称加密操作，是对称加密算法中用于加密和解密的关键数据。
+     * @param iv 加密向量，只有CBC模式才支持，如果是CBC则必传，用于增加加密的随机性和安全性，不同的加密模式下其使用情况不同，在CBC模式中与密钥共同作用来加密数据。
+     * @param plainText 明文，即需要进行加密的原始文本内容，是未经过加密处理的原始数据。
+     * @param algorithm 对称加密算法，如AES、DES，通过Algorithm枚举类型传入具体的算法实例，指定使用哪种对称加密算法来进行加密操作。
+     * @return 返回经过对称加密后的密文，以Base64编码字符串形式返回，方便存储和传输加密后的数据。
+     * @throws Exception 如果在加密过程中出现如密钥格式错误、加密算法执行异常等任何问题，则抛出异常。
+     */
+    public static String encryptSymmetrically(String secretKey, String iv, String plainText, Algorithm algorithm) throws Exception {
+        // 调用decodeSymmetricKey方法，传入对称密钥（secretKey）和指定的对称加密算法（algorithm），将Base64编码的对称密钥解码并重新生成SecretKey实例，用于后续的加密操作，得到实际可用的对称密钥对象，存储在key变量中。
+        SecretKey key = decodeSymmetricKey(secretKey, algorithm);
+        // 通过StringUtils.isBlank判断传入的加密向量（iv）是否为空字符串，如果为空，则将ivParameterSpec设置为null，表示不需要加密向量（例如在ECB等不需要加密向量的加密模式下）；
+        // 如果不为空，则调用decodeIv方法对加密向量进行解码并生成IvParameterSpec实例，用于指定加密的初始向量信息（在CBC模式等需要的情况下），存储在ivParameterSpec变量中。
+        IvParameterSpec ivParameterSpec = StringUtils.isBlank(iv)? null : decodeIv(iv);
+        // 将明文字符串（plainText）按照默认字符编码格式（DEFAULT_CHARSET，即UTF-8）转换为字节数组，准备进行加密操作，得到的字节数组存储在plainTextInBytes变量中，这是因为加密算法通常操作的是字节数据。
+        byte[] plainTextInBytes = plainText.getBytes(DEFAULT_CHARSET);
+        // 调用transform方法，传入对称加密算法（algorithm）、加密模式（Cipher.ENCRYPT_MODE表示加密操作）、生成的对称密钥（key）、加密向量（ivParameterSpec）以及明文字节数组（plainTextInBytes），
+        // 执行实际的对称加密操作，得到加密后的字节数组，存储在ciphertextInBytes变量中。
+        byte[] ciphertextInBytes = transform(algorithm, Cipher.ENCRYPT_MODE, key, ivParameterSpec, plainTextInBytes);
+
+        // 将加密后的字节数组（ciphertextInBytes）使用Base64编码器（BASE64_ENCODER）转换为字符串，即将二进制的加密数据编码为可方便存储和传输的Base64编码字符串形式，然后返回该字符串作为最终的加密结果（密文）。
+        return BASE64_ENCODER.encodeToString(ciphertextInBytes);
+    }
+
+    /**
+     * 对称解密
+     * @param secretKey 密钥，以Base64编码字符串形式传入，用于对称解密操作，需要与加密时使用的密钥一致才能正确解密数据。
+     * @param iv 加密向量，只有CBC模式才支持，如果是CBC则必传，用于匹配加密时使用的加密向量，保证解密过程能正确还原出原始明文数据。
+     * @param ciphertext 密文，即经过加密后的Base64编码字符串数据，是需要进行解密还原的加密内容。
+     * @param algorithm 对称加密算法，如AES、DES，通过Algorithm枚举类型传入具体的算法实例，指定使用哪种对称加密算法来进行解密操作，需要与加密时使用的算法相同。
+     * @return 返回解密后的明文内容，以字符串形式返回，是经过解密操作还原出的原始未加密文本。
+     * @throws Exception 如果在解密过程中出现如密钥格式错误、解密算法执行异常等任何问题，则抛出异常。
+     */
+    public static String decryptSymmetrically(String secretKey, String iv, String ciphertext, Algorithm algorithm) throws Exception {
+        // 调用decodeSymmetricKey方法，传入对称密钥（secretKey）和指定的对称加密算法（algorithm），将Base64编码的对称密钥解码并重新生成SecretKey实例，用于后续的解密操作，得到实际可用的对称密钥对象，存储在key变量中。
+        SecretKey key = decodeSymmetricKey(secretKey, algorithm);
+        // 通过StringUtils.isBlank判断传入的加密向量（iv）是否为空字符串，如果为空，则将ivParameterSpec设置为null，表示不需要加密向量（对应不需要加密向量的加密模式下的解密情况）；
+        // 如果不为空，则调用decodeIv方法对加密向量进行解码并生成IvParameterSpec实例，用于指定解密时的初始向量信息（在CBC模式等需要的情况下），存储在ivParameterSpec变量中。
+        IvParameterSpec ivParameterSpec = StringUtils.isBlank(iv)? null : decodeIv(iv);
+        // 使用Base64解码器（BASE64_DECODER）对传入的密文（ciphertext）进行解码，将Base64编码的字符串转换回原始的字节数组，得到的字节数组存储在ciphertextInBytes变量中，这是因为后续解密操作需要操作字节数据。
+        byte[] ciphertextInBytes = BASE64_DECODER.decode(ciphertext);
+        // 调用transform方法，传入对称加密算法（algorithm）、解密模式（Cipher.DECRYPT_MODE表示解密操作）、生成的对称密钥（key）、加密向量（ivParameterSpec）以及密文字节数组（ciphertextInBytes），
+        // 执行实际的对称解密操作，得到解密后的字节数组，存储在plainTextInBytes变量中。
+        byte[] plainTextInBytes = transform(algorithm, Cipher.DECRYPT_MODE, key, ivParameterSpec, ciphertextInBytes);
+        // 将解密后的字节数组（plainTextInBytes）按照默认字符编码格式（DEFAULT_CHARSET，即UTF-8）转换为字符串，即将字节数据还原为原始的文本内容，然后返回该字符串作为最终的解密结果（明文）。
+        return new String(plainTextInBytes, DEFAULT_CHARSET);
+    }
+
+    /**
+     * 非对称加密
+     * @param publicKeyText 公钥，以Base64编码字符串形式传入，用于非对称加密操作，在非对称加密体系中，公钥用于对数据进行加密，只有对应的私钥才能解密。
+     * @param plainText 明文，即需要进行加密的原始文本内容，是未经过加密处理的原始数据。
+     * @param algorithm 非对称加密算法，通过Algorithm枚举类型传入具体的算法实例，指定使用哪种非对称加密算法来进行加密操作，例如RSA等算法。
+     * @return 返回经过非对称加密后的密文，以Base64编码字符串形式返回，方便存储和传输加密后的数据。
+     * @throws Exception 如果在加密过程中出现如密钥格式错误、加密算法执行异常等任何问题，则抛出异常。
+     */
+    public static String encryptAsymmetrically(String publicKeyText, String plainText, Algorithm algorithm) throws Exception {
+        // 调用regeneratePublicKey方法，传入公钥文本（publicKeyText）和指定的非对称加密算法（algorithm），将Base64编码的公钥解码并重新生成PublicKey实例，用于后续的加密操作，得到实际可用的公钥对象，存储在publicKey变量中。
+        PublicKey publicKey = regeneratePublicKey(publicKeyText, algorithm);
+        // 将明文字符串（plainText）按照默认字符编码格式（DEFAULT_CHARSET，即UTF-8）转换为字节数组，准备进行加密操作，得到的字节数组存储在plainTextInBytes变量中，因为加密算法通常是基于字节数据进行操作的。
+        byte[] plainTextInBytes = plainText.getBytes(DEFAULT_CHARSET);
+        // 调用transform方法，传入非对称加密算法（algorithm）、加密模式（Cipher.ENCRYPT_MODE表示加密操作）、生成的公钥（publicKey）以及明文字节数组（plainTextInBytes），
+        // 执行实际的非对称加密操作，得到加密后的字节数组，存储在ciphertextInBytes变量中。
+        byte[] ciphertextInBytes = transform(algorithm, Cipher.ENCRYPT_MODE, publicKey, plainTextInBytes);
+        // 将加密后的字节数组（ciphertextInBytes）使用Base64编码器（BASE64_ENCODER）转换为字符串，即将二进制的加密数据编码为可方便存储和传输的Base64编码字符串形式，然后返回该字符串作为最终的加密结果（密文）。
+        return BASE64_ENCODER.encodeToString(ciphertextInBytes);
+    }
+/**
+ * 非对称解密
+ * @param privateKeyText 私钥
+ * @param ciphertext 密文
+ * @param algorithm 非对称加密算法
+ * @return
+ * @throws Exception
+ */
+public static String decryptAsymmetrically(String privateKeyText, String ciphertext, Algorithm algorithm) throws Exception {
+    // 调用regeneratePrivateKey方法，传入私钥文本（privateKeyText）和指定的非对称加密算法（algorithm），
+    // 目的是将Base64编码格式的私钥文本解码并重新生成对应的PrivateKey实例，以便后续用于解密操作，生成的私钥对象存储在privateKey变量中。
+    PrivateKey privateKey = regeneratePrivateKey(privateKeyText, algorithm);
+    // 使用Base64解码器（BASE64_DECODER）对传入的密文（ciphertext）进行解码操作，将Base64编码的密文字符串转换为原始的字节数组形式，
+    // 得到的字节数组存储在ciphertextInBytes变量中，因为后续的解密操作需要基于字节数据进行处理。
+    byte[] ciphertextInBytes = BASE64_DECODER.decode(ciphertext);
+    // 调用transform方法，传入非对称加密算法（algorithm）、解密模式（Cipher.DECRYPT_MODE表示进行解密操作）、刚生成的私钥（privateKey）以及密文字节数组（ciphertextInBytes），
+    // 执行实际的非对称解密操作，将密文字节数组还原为原始的明文字节数组，得到的明文字节数组存储在plainTextInBytes变量中。
+    byte[] plainTextInBytes = transform(algorithm, Cipher.DECRYPT_MODE, privateKey, ciphertextInBytes);
+    // 将解密得到的明文字节数组（plainTextInBytes）按照默认字符编码格式（DEFAULT_CHARSET，这里通常是UTF-8）转换为字符串形式，
+    // 从而将字节数据还原为原始的文本内容，最终返回这个解密后的字符串作为非对称解密的结果，也就是原始的明文信息。
+    return new String(plainTextInBytes, DEFAULT_CHARSET);
+}
+
+    /**
+     * 生成数字签名
+     * @param privateKeyText 私钥，以Base64编码字符串形式传入，用于数字签名操作，在数字签名过程中，私钥用于对要传输的数据生成唯一的签名标识，以保证数据的完整性和不可抵赖性。
+     * @param msg 传输的数据，即需要进行数字签名的原始数据内容，通常是一些重要的业务信息等，签名后接收方可以通过验证签名来确认数据是否被篡改。
+     * @param encryptionAlgorithm 加密算法，见Algorithm中的加密算法，用于指定在生成数字签名过程中涉及到的加密相关算法，例如可能是RSA等特定的加密算法，需与业务中约定的加密机制相匹配。
+     * @param signatureAlgorithm 签名算法，见Algorithm中的签名算法，用于明确具体采用哪种签名算法来生成数字签名，例如SHA1WithRSA等，不同的签名算法有不同的特性和安全性级别。
+     * @return 数字签名，以Base64编码字符串形式返回生成的数字签名，方便在网络传输等场景中传递该签名信息，接收方可以利用此签名进行验证操作。
+     * @throws Exception 如果在生成数字签名的过程中出现诸如密钥格式错误、签名算法执行异常等任何问题，则抛出异常。
+     */
+    public static String doSign(String privateKeyText, String msg, Algorithm encryptionAlgorithm, Algorithm signatureAlgorithm)
+            throws Exception {
+        // 调用regeneratePrivateKey方法，传入私钥文本（privateKeyText）和指定的加密算法（encryptionAlgorithm），
+        // 作用是将Base64编码的私钥解码并重新生成对应的PrivateKey实例，以便后续利用该私钥进行数字签名操作，生成的私钥对象存储在privateKey变量中。
+        PrivateKey privateKey = regeneratePrivateKey(privateKeyText, encryptionAlgorithm);
+        // 通过Signature.getInstance方法，根据传入的签名算法名称（signatureAlgorithm.getName()）获取对应的Signature实例，
+        // Signature是Java中用于处理数字签名相关操作的类，这里获取到的实例用于后续具体的签名生成操作，因为它只支持签名算法相关功能。
+        Signature signature = Signature.getInstance(signatureAlgorithm.getName());
+        // 使用获取到的Signature实例，调用initSign方法并传入私钥（privateKey）进行初始化操作，
+        // 此操作是为了告知签名对象后续将使用该私钥来生成数字签名，为签名过程做准备。
+        signature.initSign(privateKey);
+        // 调用signature的update方法，将需要签名的数据（msg）按照默认字符编码格式（DEFAULT_CHARSET，一般为UTF-8）转换为字节数组后传入，
+        // 这个操作是将待签名的数据传递给签名对象，以便它基于这些数据和之前初始化的私钥来生成数字签名，类似于告知签名对象要对哪些具体内容进行签名。
+        signature.update(msg.getBytes(DEFAULT_CHARSET));
+        // 调用signature的sign方法执行实际的数字签名生成操作，该方法会基于前面设置的私钥、待签名数据等信息生成数字签名，返回的是字节数组形式的签名结果，存储在signatureInBytes变量中。
+        byte[] signatureInBytes = signature.sign();
+        // 将生成的字节数组形式的数字签名（signatureInBytes）使用Base64编码器（BASE64_ENCODER）进行编码，转换为Base64编码字符串形式，
+        // 方便在网络传输等场景中传递该数字签名，最终返回这个编码后的字符串作为生成的数字签名结果。
+        return BASE64_ENCODER.encodeToString(signatureInBytes);
+    }
+
+    /**
+     * 数字签名验证
+     * @param publicKeyText 公钥，以Base64编码字符串形式传入，用于数字签名验证操作，在验证数字签名时，公钥与生成签名时使用的私钥相对应，通过公钥来验证签名是否是由对应的私钥生成的，以此确认数据的完整性和来源合法性。
+     * @param msg 传输的数据，即要验证数字签名对应的原始数据内容，需要与生成数字签名时使用的数据完全一致，否则验证会失败，该数据用于和签名一起进行验证比对。
+     * @param signatureText 数字签名，以Base64编码字符串形式传入，是之前生成的需要进行验证的数字签名信息，接收方获取到此签名后，使用对应的公钥和原始数据来验证其有效性。
+     * @param encryptionAlgorithm 加密算法，见Algorithm中的加密算法，用于指定在数字签名验证过程中涉及到的加密相关算法，需要与生成数字签名时使用的加密算法一致，确保验证的准确性。
+     * @param signatureAlgorithm 签名算法，见Algorithm中的签名算法，用于明确具体采用哪种签名算法来验证数字签名，要与生成数字签名时使用的签名算法相同，保证验证逻辑的正确性。
+     * @return 校验是否成功，返回true表示数字签名验证通过，即签名有效，意味着数据的完整性和来源合法性得到确认；返回false表示验证失败，签名可能被篡改或者来源不合法。
+     * @throws Exception 如果在数字签名验证的过程中出现诸如密钥格式错误、验证算法执行异常等任何问题，则抛出异常。
+     */
+    public static boolean doVerify(String publicKeyText, String msg, String signatureText, Algorithm encryptionAlgorithm,
+                                   Algorithm signatureAlgorithm) throws Exception {
+        // 调用regeneratePublicKey方法，传入公钥文本（publicKeyText）和指定的加密算法（encryptionAlgorithm），
+        // 目的是将Base64编码格式的公钥文本解码并重新生成对应的PublicKey实例，以便后续利用该公钥进行数字签名验证操作，生成的公钥对象存储在publicKey变量中。
+        PublicKey publicKey = regeneratePublicKey(publicKeyText, encryptionAlgorithm);
+        // 通过Signature.getInstance方法，根据传入的签名算法名称（signatureAlgorithm.getName()）获取对应的Signature实例，
+        // 用于后续具体的数字签名验证操作，因为它提供了验证签名有效性的相关功能。
+        Signature signature = Signature.getInstance(signatureAlgorithm.getName());
+        // 使用获取到的Signature实例，调用initVerify方法并传入公钥（publicKey）进行初始化操作，
+        // 此操作是为了告知验证对象后续将使用该公钥来验证数字签名，为验证过程做准备。
+        signature.initVerify(publicKey);
+        // 调用signature的update方法，将需要验证的数据（msg）按照默认字符编码格式（DEFAULT_CHARSET，一般为UTF-8）转换为字节数组后传入，
+        // 这个操作是将原始数据传递给验证对象，使其基于这些数据和之前初始化的公钥来进行数字签名验证，类似于告知验证对象要验证的原始数据内容是什么。
+        signature.update(msg.getBytes(DEFAULT_CHARSET));
+        // 调用signature的verify方法执行实际的数字签名验证操作，传入经过Base64解码后的数字签名（通过BASE64_DECODER.decode(signatureText)获取原始字节数组形式的签名），
+        // 该方法会基于前面设置的公钥、原始数据以及传入的数字签名信息进行验证，返回一个布尔值，表示验证是否成功，直接返回这个布尔值作为最终的验证结果。
+        return signature.verify(BASE64_DECODER.decode(signatureText));
+    }
+/**
+ * 将密钥进行Base64位解码，重新生成SecretKey实例
+ * @param secretKey 密钥
+ * @param algorithm 算法
+ * @return
+ */
+private static SecretKey decodeSymmetricKey(String secretKey, Algorithm algorithm) {
+    // 使用BASE64_DECODER（Base64解码器，在类中前面已定义）对传入的对称密钥字符串（secretKey）进行解码操作，
+    // 将Base64编码格式的密钥字符串转换为原始的字节数组形式，得到的字节数组存储在key变量中，以便后续基于字节数据构建SecretKey对象。
+    byte[] key = BASE64_DECODER.decode(secretKey);
+    // 使用SecretKeySpec类，根据解码后的字节数组（key）和指定的算法名称（algorithm.getName()）创建一个SecretKey实例，
+    // SecretKeySpec实现了SecretKey接口，用于包装字节数组形式的密钥数据，使其成为符合特定对称加密算法要求的密钥对象，最终返回这个SecretKey对象，用于后续的对称加密或解密操作等。
+    return new SecretKeySpec(key, algorithm.getName());
+}
+
+    private static IvParameterSpec decodeIv(String iv) {
+        // 使用BASE64_DECODER（Base64解码器）对传入的加密向量字符串（iv）进行解码操作，
+        // 将Base64编码格式的加密向量字符串转换为原始的字节数组形式，得到的字节数组存储在ivInBytes变量中，后续将基于此字节数组构建IvParameterSpec对象用于加密或解密操作（在需要加密向量的模式下）。
+        byte[] ivInBytes = BASE64_DECODER.decode(iv);
+        // 使用IvParameterSpec类，根据解码后的字节数组（ivInBytes）创建一个IvParameterSpec实例，
+        // IvParameterSpec用于指定加密或解密操作中使用的初始向量信息（在如CBC模式等需要加密向量的情况下），最终返回这个IvParameterSpec对象，用于相关加密或解密流程。
+        return new IvParameterSpec(ivInBytes);
+    }
+
+    private static PublicKey regeneratePublicKey(String publicKeyText, Algorithm algorithm)
+            throws NoSuchAlgorithmException, InvalidKeySpecException {
+        // 使用BASE64_DECODER（Base64解码器）对传入的公钥字符串（publicKeyText）进行解码操作，
+        // 将Base64编码格式的公钥字符串转换为原始的字节数组形式，得到的字节数组存储在keyInBytes变量中，以便后续基于这些字节数据构建PublicKey对象。
+        byte[] keyInBytes = BASE64_DECODER.decode(publicKeyText);
+        // 调用getKeyFactory方法，传入指定的算法（algorithm），获取对应的KeyFactory实例，KeyFactory用于根据特定算法创建密钥相关的对象（如公钥、私钥等），存储在keyFactory变量中。
+        KeyFactory keyFactory = getKeyFactory(algorithm);
+        // 按照Java加密规范要求，公钥必须使用RSAPublicKeySpec或者X509EncodedKeySpec来构建，这里使用X509EncodedKeySpec类，
+        // 根据解码后的字节数组（keyInBytes）创建一个公钥规范对象（KeySpec），用于后续通过KeyFactory生成具体的PublicKey对象，此规范定义了公钥的格式和数据内容等信息。
+        KeySpec publicKeySpec = new X509EncodedKeySpec(keyInBytes);
+        // 使用获取到的KeyFactory实例（keyFactory），调用其generatePublic方法并传入公钥规范对象（publicKeySpec），
+        // 执行实际的公钥生成操作，将符合规范的字节数据转换为可用的PublicKey对象，存储在publicKey变量中，该PublicKey对象可用于后续的非对称加密、数字签名验证等操作。
+        PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
+        // 返回生成的PublicKey对象，供调用者在需要使用公钥的地方（如加密、验证等操作）使用。
+        return publicKey;
+    }
+
+    private static PrivateKey regeneratePrivateKey(String key, Algorithm algorithm) throws Exception {
+        // 使用BASE64_DECODER（Base64解码器）对传入的私钥字符串（key）进行解码操作，
+        // 将Base64编码格式的私钥字符串转换为原始的字节数组形式，得到的字节数组存储在keyInBytes变量中，以便后续基于这些字节数据构建PrivateKey对象。
+        byte[] keyInBytes = BASE64_DECODER.decode(key);
+        // 调用getKeyFactory方法，传入指定的算法（algorithm），获取对应的KeyFactory实例，用于后续创建私钥对象，存储在keyFactory变量中。
+        KeyFactory keyFactory = getKeyFactory(algorithm);
+        // 按照Java加密规范要求，私钥必须使用RSAPrivateCrtKeySpec或者PKCS8EncodedKeySpec来构建，这里使用PKCS8EncodedKeySpec类，
+        // 根据解码后的字节数组（keyInBytes）创建一个私钥规范对象（KeySpec），用于定义私钥的格式和数据内容等信息，为生成私钥做准备。
+        KeySpec privateKeySpec = new PKCS8EncodedKeySpec(keyInBytes);
+        // 使用获取到的KeyFactory实例（keyFactory），调用其generatePrivate方法并传入私钥规范对象（privateKeySpec），
+        // 执行实际的私钥生成操作，将符合规范的字节数据转换为可用的PrivateKey对象，存储在privateKey变量中，该PrivateKey对象可用于后续的非对称解密、数字签名生成等操作。
+        PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);
+        // 返回生成的PrivateKey对象，供调用者在需要使用私钥的地方（如解密、签名等操作）使用。
+        return privateKey;
+    }
+
+    private static KeyFactory getKeyFactory(Algorithm algorithm) throws NoSuchAlgorithmException {
+        // 尝试从KEY_FACTORY_CACHE（一个以Algorithm为键，存储KeyFactory实例的缓存Map，在类中前面已定义）中获取指定算法（algorithm）对应的KeyFactory实例，
+        // 目的是先查看缓存中是否已经存在该算法的KeyFactory，如果存在则直接复用，避免重复创建，提高性能，获取到的实例存储在keyFactory变量中。
+        KeyFactory keyFactory = KEY_FACTORY_CACHE.get(algorithm);
+        // 判断从缓存中获取到的KeyFactory实例是否为null，如果是null，表示缓存中还没有该算法对应的KeyFactory实例，需要创建新的实例，执行以下操作。
+        if (keyFactory == null) {
+            // 通过KeyFactory.getInstance方法，根据指定算法的名称（algorithm.getName()）创建一个新的KeyFactory实例，
+            // 此方法会根据Java运行环境中支持的加密算法来查找并创建对应的KeyFactory，用于后续创建密钥相关对象（公钥、私钥等）。
+            keyFactory = KeyFactory.getInstance(algorithm.getName());
+            // 将新创建的KeyFactory实例放入KEY_FACTORY_CACHE缓存中，以算法（algorithm）为键进行存储，方便下次获取时直接使用，避免再次创建，提高效率。
+            KEY_FACTORY_CACHE.put(algorithm, keyFactory);
+        }
+
+        // 返回获取到（从缓存中或者新创建的）的KeyFactory实例，供调用者使用，例如用于生成公钥、私钥等操作。
+        return keyFactory;
+    }
+
+    private static byte[] transform(Algorithm algorithm, int mode, Key key, byte[] msg) throws Exception {
+        // 此方法重载了另一个transform方法，这里直接调用另一个带有更多参数的transform方法，传入算法（algorithm）、模式（mode）、密钥（key）、null（表示加密向量为默认值，具体由内部逻辑处理）以及消息字节数组（msg），
+        // 目的是统一通过另一个更完整参数的方法来处理字节数据的转换（加密或解密等操作），最终返回转换后的字节数组结果。
+        return transform(algorithm, mode, key, null, msg);
+    }
+
+    private static byte[] transform(Algorithm algorithm, int mode, Key key, IvParameterSpec iv, byte[] msg) throws Exception {
+        // 尝试从CIPHER_CACHE（一个以Algorithm为键，存储Cipher实例的缓存Map，在类中前面已定义）中获取指定算法（algorithm）对应的Cipher实例，
+        // Cipher实例用于执行加密或解密等实际操作，先查看缓存中是否已经存在该算法对应的Cipher，如果存在则直接复用，避免重复创建，减少开销，获取到的实例存储在cipher变量中。
+        Cipher cipher = CIPHER_CACHE.get(algorithm);
+        // double check，减少上下文切换
+        // 再次检查获取到的Cipher实例是否为null，这是一种双重检查机制，因为在多线程环境下，可能存在多个线程同时发现缓存中没有对应Cipher实例的情况，
+        // 通过再次检查来确保只有一个线程去创建并放入缓存，避免重复创建和不必要的上下文切换开销，提高并发性能。
+        if (cipher == null) {
+            // 使用synchronized关键字对CryptoUtils类进行同步锁控制，确保在同一时刻只有一个线程能进入以下代码块执行创建Cipher实例并放入缓存的操作，避免多线程并发冲突。
+            synchronized (CryptoUtils.class) {
+                // 再次检查（在进入同步块后）缓存中是否已经存在该算法对应的Cipher实例，因为可能在等待进入同步块的过程中，其他线程已经创建并放入缓存了，
+                // 如果还是null，表示确实需要创建新的Cipher实例，执行以下操作。
+                if ((cipher = CIPHER_CACHE.get(algorithm)) == null) {
+                    // 调用determineWhichCipherToUse方法，传入指定算法（algorithm），根据算法相关信息确定并创建对应的Cipher实例，
+                    // 该方法内部会根据算法的具体配置（如算法名称、转换模式等）来创建合适的Cipher对象，用于后续的加密或解密操作。
+                    cipher = determineWhichCipherToUse(algorithm);
+                    // 将新创建的Cipher实例放入CIPHER_CACHE缓存中，以算法（algorithm）为键进行存储，方便后续获取时直接使用，避免再次创建，提高效率。
+                    CIPHER_CACHE.put(algorithm, cipher);
+                }
+                // 使用获取到（从缓存中或者新创建的）的Cipher实例，调用其init方法，传入操作模式（mode，如加密模式或解密模式等）、密钥（key）以及加密向量（iv，可能为null，取决于具体算法和模式需求），
+                // 对Cipher实例进行初始化操作，使其准备好执行后续的加密或解密操作，根据传入的模式和密钥等信息来配置其内部状态。
+                cipher.init(mode, key, iv);
+                // 调用Cipher实例的doFinal方法，传入要处理的消息字节数组（msg），执行实际的加密或解密操作（取决于前面传入的模式是加密还是解密），
+                // 该方法会对消息字节数组进行相应处理，并返回处理后的字节数组结果，也就是加密或解密后的字节数组，最终返回这个结果字节数组供调用者使用。
+                return cipher.doFinal(msg);
+            }
+        }
+
+        // 如果第一次获取到的Cipher实例不为null（即缓存中已经存在可用的Cipher实例），执行以下操作，同样进行初始化和执行加密或解密操作。
+        synchronized (CryptoUtils.class) {
+            cipher.init(mode, key, iv);
+            return cipher.doFinal(msg);
+        }
+    }
+    private static Cipher determineWhichCipherToUse(Algorithm algorithm) throws NoSuchAlgorithmException, NoSuchPaddingException {
+        // 声明一个Cipher类型的变量cipher，用于存储后续创建的Cipher实例，Cipher类用于执行加密或解密操作，这里先进行变量声明，后续会根据具体情况创建并赋值。
+        Cipher cipher;
+        // 获取传入的Algorithm对象中定义的转换字符串（transformation），这个转换字符串通常遵循algorithm/mode/padding的格式（例如 "AES/CBC/PKCS5Padding"），
+        // 它用于指定加密或解密操作中具体的算法、模式（如ECB、CBC等加密模式）以及填充方式（如PKCS5Padding等）等信息，存储在transformation变量中。
+        String transformation = algorithm.getTransformation();
+        // 官方推荐的transformation使用algorithm/mode/padding组合，SunJCE使用ECB作为默认模式，使用PKCS5Padding作为默认填充
+        // 判断获取到的转换字符串（transformation）是否不为空（即是否有指定具体的算法、模式和填充相关信息），如果不为空，表示有明确的转换要求，执行以下操作。
+        if (StringUtils.isNotEmpty(transformation)) {
+            // 通过Cipher.getInstance方法，传入指定的转换字符串（transformation），创建一个对应的Cipher实例，
+            // 该方法会根据传入的转换字符串所表示的算法、模式和填充等信息，在Java加密框架中查找并创建合适的Cipher对象，用于后续的加密或解密操作，创建的实例赋值给cipher变量。
+            cipher = Cipher.getInstance(transformation);
+        } else {
+            // 如果转换字符串为空，表示没有明确指定具体的转换信息，那么只根据算法名称（algorithm.getName()）来创建Cipher实例，
+            // 此时会使用默认的模式和填充方式（根据具体加密框架的默认设置，如SunJCE的默认情况）来创建Cipher对象，同样将创建的实例赋值给cipher变量。
+            cipher = Cipher.getInstance(algorithm.getName());
+        }
+
+        // 返回创建好的Cipher实例，供调用者在后续的加密、解密等操作中使用，例如在transform方法中会利用这个Cipher实例来执行具体的字节数据转换操作。
+        return cipher;
+    }
+
+    /**
+     * 算法分为加密算法和签名算法，更多算法实现见：<br/>
+     * <a href="https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html#impl">jdk8中的标准算法</a>
+     * 这里定义了一个内部静态类Algorithm，用于封装和管理加密、签名相关的算法信息，包括算法名称、转换字符串（用于指定算法模式和填充等）以及密钥长度等属性，方便在整个加密工具类中统一使用和管理各种算法相关配置。
+     */
+    public static class Algorithm {
+
+        // 定义一个内部接口Encryption，用于列举各种加密算法相关的常量配置，这些常量都是Algorithm类型的实例，每个实例代表一种具体的加密算法及其相关属性。
+        public interface Encryption {
+            // 创建一个Algorithm实例表示AES算法在ECB模式下使用PKCS5Padding填充的配置，算法名称为 "AES"，转换字符串为 "AES/ECB/PKCS5Padding"，密钥长度为128位，
+            // 通过这种方式定义了一种具体的加密算法配置，方便在代码中直接引用这个常量来表示该加密算法，后续在加密操作等场景中可以基于此配置来创建对应的加密对象等。
+            Algorithm AES_ECB_PKCS5 = new Algorithm("AES", "AES/ECB/PKCS5Padding", 128);
+            Algorithm AES_CBC_PKCS5 = new Algorithm("AES", "AES/CBC/PKCS5Padding", 128);
+            Algorithm DES_ECB_PKCS5 = new Algorithm("DES", "DES/ECB/PKCS5Padding", 56);
+            Algorithm DES_CBC_PKCS5 = new Algorithm("DES", "DES/CBC/PKCS5Padding", 56);
+            Algorithm RSA_ECB_PKCS1 = new Algorithm("RSA", "RSA/ECB/PKCS1Padding", 1024);
+            Algorithm DSA = new Algorithm("DSA", 1024);
+        }
+
+        // 定义一个内部接口Signing，用于列举各种签名算法相关的常量配置，同样每个常量都是Algorithm类型的实例，代表一种具体的签名算法及其相关属性。
+        public interface Signing {
+            Algorithm SHA1WithDSA = new Algorithm("SHA1withDSA", 1024);
+            Algorithm SHA1WithRSA = new Algorithm("SHA1WithRSA", 2048);
+            Algorithm SHA256WithRSA = new Algorithm("SHA256WithRSA", 2048);
+        }
+
+        // 使用Lombok的@Getter注解，自动生成获取name属性的getter方法，name属性用于存储算法的名称，例如 "AES"、"RSA" 等，方便外部获取该算法的名称信息。
+        @Getter
+        private String name;
+        // 使用Lombok的@Getter注解，自动生成获取transformation属性的getter方法，transformation属性用于存储算法对应的转换字符串，包含算法、模式和填充等相关信息，便于外部获取该算法的具体转换配置。
+        @Getter
+        private String transformation;
+        // 使用Lombok的@Getter注解，自动生成获取keySize属性的getter方法，keySize属性用于存储算法对应的密钥长度（以位为单位），例如128、1024等，方便外部获取该算法的密钥长度信息。
+        @Getter
+        private int keySize;
+
+        // 构造函数，用于创建Algorithm实例，接收算法名称（name）和密钥长度（keySize）两个参数，调用另一个构造函数（this(name, null, keySize)）并传递相应参数，
+        // 主要用于在创建算法实例时只明确算法名称和密钥长度，而不指定具体转换字符串（使用默认的转换配置情况）的场景，比如某些算法只需要名称和密钥长度就能确定基本配置的情况。
+        public Algorithm(String name, int keySize) {
+            this(name, null, keySize);
+        }
+
+        // 完整的构造函数，用于创建Algorithm实例，接收算法名称（name）、转换字符串（transformation）和密钥长度（keySize）三个参数，
+        // 分别将这些参数赋值给对应的实例属性（this.name、this.transformation、this.keySize），用于初始化一个完整的算法配置对象，在定义各种具体算法常量时会调用此构造函数来明确算法的各项属性。
+        public Algorithm(String name, String transformation, int keySize) {
+            this.name = name;
+            this.transformation = transformation;
+            this.keySize = keySize;
+        }
+
+    }
+
+    // 使用Lombok的@Data注解，自动生成该类的常用方法，如getter、setter、toString、hashCode和equals等方法，方便对类的属性进行操作和对象间的比较等操作。
+// 使用Lombok的@NoArgsConstructor注解，自动生成无参构造函数，方便在某些场景下创建该类的默认实例，例如在一些框架进行对象实例化时如果需要无参构造函数的情况。
+// 使用Lombok的@AllArgsConstructor注解，自动生成全参构造函数，接收两个参数publicKey和privateKey，用于初始化类的属性，方便在创建对象时一次性传入所有必要属性值进行初始化。
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class AsymmetricKeyPair {
+
+        // 定义一个字符串类型的属性publicKey，用于存储非对称加密中的公钥信息，通常是以Base64编码的字符串形式存储公钥内容，方便在加密、验证等操作中传递和使用公钥。
+        private String publicKey;
+        // 定义一个字符串类型的属性privateKey，用于存储非对称加密中的私钥信息，同样一般是以Base64编码的字符串形式存储私钥内容，用于在解密、签名等操作中传递和使用私钥。
+        private String privateKey;
+    }
+
+}
\ No newline at end of file
-- 
2.34.1