diff --git a/src-源文件/main/resources/mapper/exam/ExamDepartMapper.xml b/src-源文件/main/resources/mapper/exam/ExamDepartMapper.xml
index 7a9a90b..57e67e0 100644
--- a/src-源文件/main/resources/mapper/exam/ExamDepartMapper.xml
+++ b/src-源文件/main/resources/mapper/exam/ExamDepartMapper.xml
@@ -1,17 +1,27 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 这是XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，用于告诉解析器如何正确解析该XML文件 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 这是文档类型定义（DOCTYPE）声明，用于指定该XML文档遵循的文档类型定义。这里表明该Mapper XML遵循MyBatis的Mapper 3.0的DTD规范，并且指定了DTD文件的URL地址，以便解析器可以根据该DTD来验证XML文档的结构是否正确 -->
+
 <mapper namespace="com.yf.exam.modules.exam.mapper.ExamDepartMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，通常是对应Mapper接口的全限定名。这里表示与com.yf.exam.modules.exam.mapper.ExamDepartMapper接口相关联 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.exam.entity.ExamDepart">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果映射到指定的Java对象（这里是ExamDepart类型）。id属性是该结果映射的唯一标识 -->
         <id column="id" property="id" />
+        <!-- 定义了主键的映射关系，column属性指定了数据库表中的列名（这里是id列），property属性指定了要映射到的Java对象中的属性名（这里也是id属性），即将数据库表中的id列的值赋给Java对象的id属性 -->
         <result column="exam_id" property="examId" />
+        <!-- 定义了普通列的映射关系，将数据库表中的exam_id列的值赋给Java对象的examId属性 -->
         <result column="depart_id" property="departId" />
+        <!-- 同样是定义普通列的映射关系，把数据库表中的depart_id列的值赋给Java对象的departId属性 -->
     </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用。这里列出了通用查询时要选择的数据库表列名，用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`exam_id`,`depart_id`
     </sql>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/exam/ExamMapper.xml b/src-源文件/main/resources/mapper/exam/ExamMapper.xml
index 8203a3b..20b2c7b 100644
--- a/src-源文件/main/resources/mapper/exam/ExamMapper.xml
+++ b/src-源文件/main/resources/mapper/exam/ExamMapper.xml
@@ -1,26 +1,46 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0，字符编码采用UTF-8，这是告诉解析器如何正确解析该XML文件的基本信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.exam.mapper.ExamMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.exam.mapper.ExamMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.exam.entity.Exam">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是Exam类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="title" property="title" />
+        <!-- 把数据库表中的title列的值映射到Java对象的title属性 -->
         <result column="content" property="content" />
+        <!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
         <result column="open_type" property="openType" />
+        <!-- 映射数据库表中的open_type列到Java对象的openType属性，注意这里在Java对象中属性名采用了驼峰命名法，与数据库列名可能存在格式差异 -->
         <result column="state" property="state" />
+        <!-- 把数据库表中的state列的值映射到Java对象的state属性 -->
         <result column="time_limit" property="timeLimit" />
+        <!-- 映射数据库表中的time_limit列到Java对象的timeLimit属性 -->
         <result column="start_time" property="startTime" />
+        <!-- 将数据库表中的start_time列的值映射到Java对象的startTime属性 -->
         <result column="end_time" property="endTime" />
+        <!-- 把数据库表中的end_time列的值映射到Java对象的endTime属性 -->
         <result column="create_time" property="createTime" />
+        <!-- 映射数据库表中的create_time列到Java对象的createTime属性 -->
         <result column="update_time" property="updateTime" />
+        <!-- 将数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
         <result column="total_score" property="totalScore" />
+        <!-- 把数据库表中的total_score列的值映射到Java对象的totalScore属性 -->
         <result column="total_time" property="totalTime" />
+        <!-- 映射数据库表中的total_time列到Java对象的totalTime属性 -->
         <result column="qualify_score" property="qualifyScore" />
-    </resultMap>
+        <!-- 将数据库表中的qualify_score列的值映射到Java对象的qualifyScore属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`title`,`content`,`open_type`,`join_type`,`level`,`state`,`time_limit`,`start_time`,`end_time`,`create_time`,`update_time`,`total_score`,`total_time`,`qualify_score`
     </sql>
 
@@ -28,69 +48,97 @@
     <resultMap id="ReviewResultMap"
                type="com.yf.exam.modules.exam.dto.response.ExamReviewRespDTO"
                extends="BaseResultMap">
+        <!-- 定义一个名为ReviewResultMap的结果映射，它的类型是ExamReviewRespDTO，并且通过extends属性继承了BaseResultMap，意味着它会包含BaseResultMap中定义的所有映射关系，在此基础上还可以添加新的映射关系 -->
         <result column="examUser" property="examUser" />
+        <!-- 新增的映射关系，将数据库表中的examUser列的值映射到Java对象的examUser属性 -->
         <result column="unreadPaper" property="unreadPaper" />
+        <!-- 将数据库表中的unreadPaper列的值映射到Java对象的unreadPaper属性 -->
     </resultMap>
 
 
     <resultMap id="ListResultMap"
                type="com.yf.exam.modules.exam.dto.ExamDTO"
-    extends="BaseResultMap">
-
+               extends="BaseResultMap">
+        <!-- 定义名为ListResultMap的结果映射，类型为ExamDTO，同样继承了BaseResultMap，可在其基础上进行扩展，但这里暂时没有添加新的映射关系 -->
     </resultMap>
 
     <select id="paging" resultMap="ListResultMap">
+        <!-- 定义一个名为paging的查询语句，其结果将按照ListResultMap定义的映射关系进行映射 -->
         SELECT * FROM el_exam
         <where>
+            <!-- <where>标签用于动态生成WHERE子句，根据条件判断是否添加相应的条件语句 -->
             <if test="query!=null">
+                <!-- <if>标签用于条件判断，这里判断传入的参数query是否不为空 -->
                 <if test="query.title!=null and query.title!=''">
+                    <!-- 进一步判断query对象中的title属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                     AND title LIKE CONCAT('%',#{query.title},'%')
+                    <!-- 使用LIKE关键字进行模糊查询，将查询条件中的title值与数据库表中的title列进行模糊匹配，#{query.title}是MyBatis的参数占位符，会被实际传入的参数值替换 -->
                 </if>
                 <if test="query.openType!=null">
+                    <!-- 判断query对象中的openType属性是否不为空，如果是则添加以下WHERE子句条件 -->
                     AND open_type = #{query.openType}
+                    <!-- 将数据库表中的open_type列与传入的query.openType参数值进行精确匹配 -->
                 </if>
                 <if test="query.startTime!=null">
+                    <!-- 判断query对象中的startTime属性是否不为空，如果是则添加以下WHERE子句条件 -->
                     AND start_time >= #{query.startTime}
+                    <!-- 将数据库表中的start_time列与传入的query.startTime参数值进行比较，筛选出大于等于该值的数据 -->
                 </if>
                 <if test="query.endTime!=null">
+                    <!-- 判断query对象中的endTime属性是否不为空，如果是则添加以下WHERE子句条件 -->
                     AND end_time &lt;= #{query.endTime}
+                    <!-- 将数据库表中的end_time列与传入的query.endTime参数值进行比较，筛选出小于等于该值的数据，注意这里的&lt;是XML中表示小于号（<）的转义字符，因为在XML中<有特殊含义，需要转义 -->
                 </if>
             </if>
         </where>
     </select>
 
     <select id="reviewPaging" resultMap="ReviewResultMap">
+        <!-- 定义一个名为reviewPaging的查询语句，其结果将按照ReviewResultMap定义的映射关系进行映射 -->
         SELECT ex.*,
         (SELECT COUNT(DISTINCT user_id) FROM el_paper WHERE exam_id=ex.id) as examUser,
+        <!-- 通过子查询计算出与当前考试（ex.id）相关的不同用户ID的数量，并将其命名为examUser，这个值将根据ReviewResultMap的映射关系映射到对应的Java对象属性上 -->
         (SELECT COUNT(0) FROM el_paper WHERE exam_id=ex.id AND state=1) as unreadPaper
+        <!-- 通过子查询计算出与当前考试（ex.id）相关且状态为1的记录数量，并将其命名为unreadPaper，同样会根据映射关系映射到Java对象属性上 -->
         FROM el_exam ex
         WHERE ex.has_saq=1
+        <!-- 添加WHERE子句条件，筛选出el_exam表中has_saq列值为1的记录 -->
     </select>
 
 
     <resultMap id="OnlineResultMap"
                type="com.yf.exam.modules.exam.dto.response.ExamOnlineRespDTO"
                extends="BaseResultMap">
+        <!-- 定义名为OnlineResultMap的结果映射，类型为ExamOnlineRespDTO，继承了BaseResultMap，可在此基础上扩展但这里暂未添加新映射关系 -->
     </resultMap>
 
     <select id="online" resultMap="OnlineResultMap">
+        <!-- 定义一个名为online的查询语句，其结果将按照OnlineResultMap定义的映射关系进行映射 -->
         SELECT ex.*
         FROM el_exam ex
         LEFT JOIN el_exam_depart dept ON ex.id=dept.exam_id AND ex.open_type=2
+        <!-- 使用LEFT JOIN连接el_exam表和el_exam_depart表，连接条件是ex.id等于dept.exam_id且ex.open_type等于2 -->
         LEFT JOIN sys_user uc ON uc.depart_id=dept.depart_id
+        <!-- 再使用LEFT JOIN连接上一步的结果和sys_user表，连接条件是uc.depart_id等于dept.depart_id -->
         WHERE ex.state=0 AND (ex.open_type=1 OR ex.open_type=3 OR uc.id='{{userId}}')
+        <!-- 添加WHERE子句条件，筛选出el_exam表中state列值为0且满足（open_type等于1或open_type等于3或uc.id等于传入的{{userId}}参数值）的记录 -->
 
         <if test="query!=null">
+            <!-- 判断传入的参数query是否不为空 -->
             <if test="query.title!=null and query.title!=''">
+                <!-- 进一步判断query对象中的title属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                 AND ex.title LIKE CONCAT('%',#{query.title},'%')
+                <!-- 使用LIKE关键字进行模糊查询，将查询条件中的title值与数据库表中的ex.title列进行模糊匹配，#{query.title}是MyBatis的参数占位符，会被实际传入的参数值替换 -->
             </if>
 
             <if test="query.openType!=null">
+                <!-- 判断query对象中的openType属性是否不为空，如果是则添加以下WHERE子句条件 -->
                 AND ex.open_type=#{query.openType}
+                <!-- 将数据库表中的ex.open_type列与传入的query.openType参数值进行精确匹配 -->
             </if>
         </if>
 
 
     </select>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/exam/ExamRepoMapper.xml b/src-源文件/main/resources/mapper/exam/ExamRepoMapper.xml
index bc06691..399dd6b 100644
--- a/src-源文件/main/resources/mapper/exam/ExamRepoMapper.xml
+++ b/src-源文件/main/resources/mapper/exam/ExamRepoMapper.xml
@@ -1,38 +1,63 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.exam.mapper.ExamRepoMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.exam.mapper.ExamRepoMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.exam.entity.ExamRepo">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是ExamRepo类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="exam_id" property="examId" />
+        <!-- 把数据库表中的exam_id列的值映射到Java对象的examId属性 -->
         <result column="repo_id" property="repoId" />
+        <!-- 将数据库表中的repo_id列的值映射到Java对象的repoId属性 -->
         <result column="radio_count" property="radioCount" />
+        <!-- 映射数据库表中的radio_count列到Java对象的radioCount属性 -->
         <result column="radio_score" property="radioScore" />
+        <!-- 把数据库表中的radio_score列的值映射到Java对象的radioScore属性 -->
         <result column="multi_count" property="multiCount" />
+        <!-- 将数据库表中的multi_count列的值映射到Java对象的multiCount属性 -->
         <result column="multi_score" property="multiScore" />
+        <!-- 把数据库表中的multi_score列的值映射到Java对象的multiScore属性 -->
         <result column="judge_count" property="judgeCount" />
+        <!-- 将数据库表中的judge_count列的值映射到Java对象的judgeCount属性 -->
         <result column="judge_score" property="judgeScore" />
+        <!-- 把数据库表中的judge_score列的值映射到Java对象的judgeScore属性 -->
     </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`exam_id`,`repo_id`,`radio_count`,`radio_score`,`multi_count`,`multi_score`,`judge_count`,`judge_score`
     </sql>
 
     <resultMap id="ExtResultMap" type="com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO" extends="BaseResultMap">
+        <!-- 定义一个名为ExtResultMap的结果映射，它的类型是ExamRepoExtDTO，并且通过extends属性继承了BaseResultMap，意味着它会包含BaseResultMap中定义的所有映射关系，在此基础上还可以添加新的映射关系 -->
         <result column="totalRadio" property="totalRadio" />
+        <!-- 新增的映射关系，将数据库表中的totalRadio列的值映射到Java对象的totalRadio属性 -->
         <result column="totalMulti" property="totalMulti" />
+        <!-- 将数据库表中的totalMulti列的值映射到Java对象的totalMulti属性 -->
         <result column="totalJudge" property="totalJudge" />
+        <!-- 把数据库表中的totalJudge列的值映射到Java对象的totalJudge属性 -->
     </resultMap>
 
     <select id="listByExam" resultMap="ExtResultMap">
+        <!-- 定义一个名为listByExam的查询语句，其结果将按照ExtResultMap定义的映射关系进行映射 -->
         SELECT ep.*,
                (SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=ep.repo_id AND qu_type=1) AS totalRadio,
+               <!-- 通过子查询计算出在el_qu_repo表中，repo_id等于当前查询结果中的ep.repo_id且qu_type为1的记录数量，并将其命名为totalRadio，这个值将根据ExtResultMap的映射关系映射到对应的Java对象属性上 -->
                (SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=ep.repo_id AND qu_type=2) AS totalMulti,
+               <!-- 同样通过子查询计算出在el_qu_repo表中，repo_id等于当前查询结果中的ep.repo_id且qu_type为2的记录数量，并将其命名为totalMulti，会根据映射关系映射到Java对象属性上 -->
                (SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=ep.repo_id AND qu_type=3) AS totalJudge
+               <!-- 再次通过子查询计算出在el_qu_repo表中，repo_id等于当前查询结果中的ep.repo_id且qu_type为3的记录数量，并将其命名为totalJudge，也会按照映射关系映射到Java对象属性上 -->
         FROM el_exam_repo ep
         WHERE ep.exam_id=#{examId}
+        <!-- 添加WHERE子句条件，筛选出在el_exam_repo表中，exam_id等于传入的#{examId}参数值的记录 -->
     </select>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/paper/PaperMapper.xml b/src-源文件/main/resources/mapper/paper/PaperMapper.xml
index 8653ab1..a9e0417 100644
--- a/src-源文件/main/resources/mapper/paper/PaperMapper.xml
+++ b/src-源文件/main/resources/mapper/paper/PaperMapper.xml
@@ -27,7 +27,113 @@
     <sql id="Base_Column_List">
         `id`,`user_id`,`depart_id`,`exam_id`,`title`,`total_time`,`user_time`,`total_score`,`qualify_score`,`obj_score`,`subj_score`,`user_score`,`has_saq`,`state`,`create_time`,`update_time`,`limit_time`
     </sql>
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
+<mapper namespace="com.yf.exam.modules.paper.mapper.PaperMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.paper.mapper.PaperMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.yf.exalModule paper.entity.Paper">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是Paper类型）。id属性为该结果映射的唯一标识符 -->
+        <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
+        <result column="user_id" property="userId" />
+        <!-- 把数据库表中的user_id列的值映射到Java对象的userId属性 -->
+        <result column="depart_id" property="departId" />
+        <!-- 将数据库表中的depart_id列的值映射到Java对象的departId属性 -->
+        <result column="exam_id" property="examId" />
+        <!-- 把数据库表中的exam_id列的值映射到Java对象的examId属性 -->
+        <result column="title" property="title" />
+        <!-- 将数据库表中的title列的值映射到Java对象的title属性 -->
+        <result column="total_time" property="totalTime" />
+        <!-- 把数据库表中的total_time列的值映射到Java对象的totalTime属性 -->
+        <result column="user_time" property="userTime" />
+        <!-- 将数据库表中的user_time列的值映射到Java对象的userTime属性 -->
+        <result column="total_score" property="totalScore" />
+        <!-- 把数据库表中的total_score列的值映射到Java对象的totalScore属性 -->
+        <result column="qualify_score" type="com.yf.exam.modules.paper.entity.Paper">
+            <!-- 将数据库表中的qualify_score列的值映射到Java对象的qualifyScore属性 -->
+            <id column="id" property="id" />
+            <result column="user_id" property="userId" />
+            <result column="depart_id" property="departId" />
+            <result column="exam_id" property="examId" />
+            <result column="title" property="title" />
+            <result column="total_time" property="totalTime" />
+            <result column="user_time" property="userTime" />
+            <result column="total_score" property="totalScore" />
+            <result column="qualify_score" property="qualifyScore" />
+            <result column="obj_score" property="objScore" />
+            <result column="subj_score" property="subjScore" />
+            <result column="user_score" property="userScore" />
+            <result column="has_saq" property="hasSaq" />
+            <result column="state" property="state" />
+            <result column="create_time" property="createTime" />
+            <result column="update_time" property="updateTime" />
+            <result column="limit_time" property="limitTime" />
+        </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
+        `id`,`user_id`,`depart_id`,`exam_id`,`title`,`total_time`,`user_time`,`total_score`,`qualify_score`,`obj_score`,`subj_score`,`user_score`,`has_saq`,`state`,`create_time`,`update_time`,`limit_time`
+    </sql>
+
+
+    <resultMap id="ListResultMap"
+               extends="BaseResultMap"
+               type="com.yf.exam.modules.paper.dto.response.PaperListRespDTO">
+        <!-- 定义一个名为ListResultMap的结果映射，它通过extends属性继承了BaseResultMap，意味着它会包含BaseResultMap中定义的所有映射关系，在此基础上还可以添加新的映射关系。其类型是PaperListRespDTO -->
+        <result column="real_name" property="realName" />
+        <!-- 新增的映射关系，将数据库表中的real_name列的值映射到Java对象的realName属性 -->
+    </resultMap>
 
+    <select id="paging" resultMap="ListResultMap">
+        <!-- 定义一个名为paging的查询语句，其结果将按照ListResultMap定义的映射关系进行映射 -->
+        SELECT pp.*,uc.real_name FROM el_paper pp
+        LEFT JOIN sys_user uc ON pp.user_id=uc.id
+        <!-- 使用LEFT JOIN连接el_paper表和sys_user表，连接条件是pp.user_id等于uc.id，这样可以在查询结果中获取到与试卷相关用户的真实姓名 -->
+        <where>
+            <!-- <where>标签用于动态生成WHERE子句，根据条件判断是否添加相应的条件语句 -->
+            <if test="query!=null">
+                <!-- <if>标签用于条件判断，这里判断传入的参数query是否不为空 -->
+                <if test="query.examId!=null and query.examId!=''">
+                    <!-- 进一步判断query对象中的examId属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
+                    AND pp.exam_id=#{query.examId}
+                    <!-- 将数据库表中的pp.exam_id列与传入的query.examId参数值进行精确匹配 -->
+                </if>
+
+                <if test="query.userId!=null and query.userId!=''">
+                    <!-- 进一步判断query对象中的userId属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
+                    AND pp.user_id=#{query.userId}
+                    <!-- 将数据库表中的pp.user_id列与传入的query.userId参数值进行精确匹配 -->
+                </if>
+                <if test="query.departId!=null and query.departId!=''">
+                    <!-- 进一步判断query对象中的departId属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
+                    AND pp.departId=?
+                    <!-- 将数据库表中的pp.depart_id列与传入的query.departId参数值进行精确匹配 -->
+                </if>
+                <if test="query.state!=null">
+                    <!-- 进一步判断query对象中的state属性是否不为空，如果满足条件则添加以下WHERE子句条件 -->
+                    AND pp.state=#{query.state}
+                    <!-- 将数据库表中的pp.state列与传入的query.state参数值进行精确匹配 -->
+                </if>
+                <if test="query.realName!=null and query.realName!=''">
+                    <!-- 进一步判断query对象中的realName属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
+                    AND uc.real_name  LIKE CONCAT('%',#{query.realName},'%')
+                    <!-- 使用LIKE关键字进行模糊查询，将查询条件中的realName值与数据库表中的uc.real_name列进行模糊匹配，#{query.realName}是MyBatis的参数占位符，会被实际传入的参数值替换 -->
+                </if>
+            </if>
+        </where>
+
+        ORDER BY create_time DESC
+        <!-- 按照create_time列的值进行降序排序，以便获取最新创建的记录排在前面 -->
+    </select>
+
+</mapper>
 
     <resultMap id="ListResultMap"
                extends="BaseResultMap"
diff --git a/src-源文件/main/resources/mapper/paper/PaperQuAnswerMapper.xml b/src-源文件/main/resources/mapper/paper/PaperQuAnswerMapper.xml
index bd4f89b..a3c69c6 100644
--- a/src-源文件/main/resources/mapper/paper/PaperQuAnswerMapper.xml
+++ b/src-源文件/main/resources/mapper/paper/PaperQuAnswerMapper.xml
@@ -1,46 +1,74 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.paper.entity.PaperQuAnswer">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是PaperQuAnswer类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="paper_id" property="paperId" />
+        <!-- 把数据库表中的paper_id列的值映射到Java对象的paperId属性 -->
         <result column="answer_id" property="answerId" />
+        <!-- 将数据库表中的answer_id列的值映射到Java对象的answerId属性 -->
         <result column="qu_id" property="quId" />
+        <!-- 把数据库表中的qu_id列的值映射到Java对象的quId属性 -->
         <result column="is_right" property="isRight" />
+        <!-- 将数据库表中的is_right列的值映射到Java对象的isRight属性 -->
         <result column="checked" property="checked" />
+        <!-- 把数据库表中的checked列的值映射到Java对象的checked属性 -->
         <result column="sort" property="sort" />
+        <!-- 将数据库表中的sort列的值映射到Java对象的sort属性 -->
         <result column="abc" property="abc" />
+        <!-- 把数据库表中的abc列的值映射到Java对象的abc属性 -->
     </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`paper_id`,`answer_id`,`qu_id`,`is_right`,`checked`,`sort`,`abc`
     </sql>
 
     <resultMap id="ListResultMap"
                type="com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO"
                extends="BaseResultMap">
+        <!-- 定义一个名为ListResultMap的结果映射，它的类型是PaperQuAnswerExtDTO，并且通过extends属性继承了BaseResultMap，意味着它会包含BaseResultMap中定义的所有映射关系，在此基础上还可以添加新的映射关系 -->
         <result column="image" property="image" />
+        <!-- 新增的映射关系，将数据库表中的image列的值映射到Java对象的image属性 -->
         <result column="content" property="content" />
+        <!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
     </resultMap>
 
 
     <select id="list" resultMap="ListResultMap">
+        <!-- 定义一个名为list的查询语句，其结果将按照ListResultMap定义的映射关系进行映射 -->
         SELECT pa.`id`,pa.`paper_id`,pa.`answer_id`,pa.`qu_id`,pa.`checked`,pa.`sort`,pa.`abc`,qa.content,qa.image
+        <!-- 从el_paper_qu_answer表（pa）中选择指定列以及通过LEFT JOIN连接el_qu_answer表（qa）获取相关列的数据，以便在查询结果中包含答案内容和图片等相关信息 -->
         FROM el_paper_qu_answer pa
         LEFT JOIN el_qu_answer qa ON pa.answer_id=qa.id
+        <!-- 使用LEFT JOIN连接el_paper_qu_answer表和el_qu_answer表，连接条件是pa.answer_id等于qa.id，这样可以获取到与试卷问题答案相关的完整信息 -->
         WHERE pa.paper_id=#{paperId} AND pa.qu_id=#{quId}
+        <!-- 添加WHERE子句条件，筛选出在el_paper_qu_answer表中paper_id等于传入的#{paperId}参数值且qu_id等于传入的#{quId}参数值的记录 -->
         ORDER BY pa.sort ASC
+        <!-- 按照pa.sort列的值进行升序排序，以便以特定顺序展示查询结果 -->
     </select>
 
     <select id="listForShow" resultMap="ListResultMap">
-        SELECT pa.`id`,pa.`paper_id`,pa.`answer_id`,pa.`qu_id`,pa.`checked`,pa.`sort`,pa.`abc`,qa.content,qa.is_right,qa.image
+        <!-- 定义一个名为listForShow的查询语句，其结果将按照ListResultMap定义的映射关系进行映射 -->
+        SELECT pa.`id`,pa.`paper_id`,pa.`answer_id`,pa.`qu_id`,pa.`checked`,pa.`clock`,pa.`abc`,qa.content,qa.is_right,qa.image
+        <!-- 从el_paper_qu_answer表（pa）中选择指定列以及通过LEFT JOIN连接el_qu_answer表（qa）获取相关列的数据，这里比上面的list查询多选择了qa.is_right列，以便在查询结果中包含答案是否正确等相关信息 -->
         FROM el_paper_qu_answer pa
         LEFT JOIN el_qu_answer qa ON pa.answer_id=qa.id
+        <!-- 使用LEFT JOIN连接el_paper_qu_answer表和el_qu_answer表，连接条件是pa.answer_id等于qa.id，这样可以获取到与试卷问题答案相关的完整信息 -->
         WHERE pa.paper_id=#{paperId} AND pa.qu_id=#{quId}
+        <!-- 添加WHERE子句条件，筛选出在el_paper_qu_answer表中paper_id等于传入的#{paperId}参数值且qu_id等于传入的#{quId}参数值的记录 -->
         ORDER BY pa.sort ASC
+        <!-- 按照pa.sort列的值进行升序排序，以便以特定顺序展示查询结果 -->
     </select>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/paper/PaperQuMapper.xml b/src-源文件/main/resources/mapper/paper/PaperQuMapper.xml
index 0498b71..85b9c3f 100644
--- a/src-源文件/main/resources/mapper/paper/PaperQuMapper.xml
+++ b/src-源文件/main/resources/mapper/paper/PaperQuMapper.xml
@@ -1,58 +1,93 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.paper.mapper.PaperQuMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.paper.mapper.PaperQuMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.paper.entity.PaperQu">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是PaperQu类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="paper_id" property="paperId" />
+        <!-- 把数据库表中的paper_id列的值映射到Java对象的paperId属性 -->
         <result column="qu_id" property="quId" />
+        <!-- 将数据库表中的qu_id列的值映射到Java对象的quId属性 -->
         <result column="qu_type" property="quType" />
+        <!-- 把数据库表中的qu_type列的值映射到Java对象的quType属性 -->
         <result column="answered" property="answered" />
+        <!-- 将数据库表中的answered列的值映射到Java对象的answered属性 -->
         <result column="answer" property="answer" />
+        <!-- 把数据库表中的answer列的值映射到Java对象的answer属性 -->
         <result column="sort" property="sort" />
+        <!-- 将数据库表中的sort列的值映射到Java对象的sort属性 -->
         <result column="score" property="score" />
+        <!-- 把数据库表中的score列的值映射到Java对象的score属性 -->
         <result column="actual_score" property="actualScore" />
+        <!-- 将数据库表中的actual_score列的值映射到Java对象的actualScore属性 -->
         <result column="is_right" property="isRight" />
+        <!-- 把数据库表中的is_right列的值映射到Java对象的isRight属性 -->
     </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`paper_id`,`qu_id`,`qu_type`,`answered`,`answer`,`sort`,`score`,`actual_score`,`is_right`
     </sql>
 
 
     <!-- 计算总分 -->
     <select id="sumObjective" resultType="int">
-		SELECT IFNULL(SUM(actual_score),0) as total
-		FROM el_paper_qu
-		WHERE paper_id=#{paperId}
-		AND is_right=true
-		AND qu_type &lt; 4
-	</select>
+        <!-- 定义一个名为sumObjective的查询语句，用于计算客观题的总分，其结果类型为整数（int） -->
+        SELECT IFNULL(SUM(actual_score),0) as total
+        <!-- 使用IFNULL函数对SUM(actual_score)的结果进行处理，如果SUM(actual_score)为NULL，则返回0，将结果命名为total -->
+        FROM el_paper_qu
+        <!-- 指定从el_paper_qu表中进行查询 -->
+        WHERE paper_id=#{paperId}
+        <!-- 添加WHERE子句条件，筛选出在el_paper_qu表中paper_id等于传入的#{paperId}参数值的记录 -->
+        AND is_right=true
+        <!-- 进一步筛选出is_right列值为true的记录，即只计算回答正确的客观题分数 -->
+        AND qu_type &lt; 4
+        <!-- 再筛选出qu_type列值小于4的记录，通常用于区分客观题类型（假设小于4代表客观题类型） -->
+    </select>
 
     <select id="sumSubjective" resultType="int">
-		SELECT IFNULL(SUM(actual_score),0) as total
-		FROM el_paper_qu
-		WHERE paper_id=#{paperId}
-		AND qu_type=4
-	</select>
+        <!-- 定义一个名为sumSubjective的查询语句，用于计算主观题的总分，其结果类型为整数（int） -->
+        SELECT IFNULL(SUM(actual_score),0) as total
+        <!-- 使用IFNULL函数对SUM(actual_score)的结果进行处理，如果SUM(actual_score)为NULL，则返回0，将结果命名为total -->
+        FROM el_paper_qu
+        <!-- 指定从el_paper_qu表中进行查询 -->
+        WHERE paper_id=#{paperId}
+        <!-- 添加WHERE子句条件，筛选出在el_paper_qu表中paper_id等于传入的#{paperId}参数值的记录 -->
+        AND qu_type=4
+        <!-- 筛选出qu_type列值等于4的记录，通常用于区分主观题类型（假设等于4代表主观题类型） -->
+    </select>
 
     <resultMap id="ListResultMap" extends="BaseResultMap" type="com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO">
-
+        <!-- 定义一个名为ListResultMap的结果映射，它通过extends属性继承了BaseResultMap，意味着它会包含BaseResultMap中定义的所有映射关系，在此基础上还可以添加新的映射关系。其类型是PaperQuDetailDTO -->
         <result column="image" property="image" />
+        <!-- 新增的映射关系，将数据库表中的image列的值映射到Java对象的image属性 -->
         <result column="content" property="content" />
+        <!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
         <collection property="answerList" column="{paperId=paper_id,quId=qu_id}"
                     select="com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper.listForShow" />
-
+        <!-- 使用<collection>标签来处理一对多的关系，这里表示将根据指定的条件（paperId和quId）从PaperQuAnswerMapper.listForShow查询中获取多条记录，并将这些记录映射到Java对象的answerList属性上。column属性用于指定传递给子查询的参数，select属性指定了要调用的子查询的Mapper方法 -->
     </resultMap>
 
     <select id="listByPaper" resultMap="ListResultMap">
+        <!-- 定义一个名为listByPaper的查询语句，其结果将按照ListResultMap定义的映射关系进行映射 -->
         SELECT pq.*,eq.content,eq.image
+        <!-- 从el_paper_qu表（pq）中选择所有列，并通过LEFT JOIN连接el_qu表（eq）获取相关列（content和image）的数据，以便在查询结果中包含题目内容和图片等相关信息 -->
         FROM el_paper_qu pq
         LEFT JOIN el_qu eq ON pq.qu_id = eq.id
+        <!-- 使用LEFT JOIN连接el_paper_qu表和el_qu表，连接条件是pq.qu_id等于eq.id，这样可以获取到与试卷题目相关的完整信息 -->
         WHERE pq.paper_id=#{paperId}
+        <!-- 添加WHERE子句条件，筛选出在el_paper_qu表中paper_id等于传入的#{paperId}参数值的记录 -->
         ORDER BY pq.sort ASC
+        <!-- 按照pq.sort列的值进行升序排序，以便以特定顺序展示查询结果 -->
     </select>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/qu/QuAnswerMapper.xml b/src-源文件/main/resources/mapper/qu/QuAnswerMapper.xml
index a5cfd35..1709538 100644
--- a/src-源文件/main/resources/mapper/qu/QuAnswerMapper.xml
+++ b/src-源文件/main/resources/mapper/qu/QuAnswerMapper.xml
@@ -1,20 +1,33 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.qu.mapper.QuAnswerMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.qu.mapper.QuAnswerMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.qu.entity.QuAnswer">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地快照到指定的Java对象（这里是QuAnswer类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="qu_id" property="quId" />
+        <!-- 把数据库表中的qu_id列的值映射到Java对象的quId属性 -->
         <result column="is_right" property="isRight" />
+        <!-- 将数据库表中的is_right列的值映射到Java对象的isRight属性 -->
         <result column="image" property="image" />
+        <!-- 把数据库表中的image列的值映射到Java对象的image属性 -->
         <result column="content" property="content" />
+        <!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
         <result column="analysis" property="analysis" />
+        <!-- 把数据库表中的analysis列的值映射到Java对象的analysis属性 -->
     </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`qu_id`,`is_right`,`image`,`content`,`analysis`
     </sql>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/qu/QuMapper.xml b/src-源文件/main/resources/mapper/qu/QuMapper.xml
index 20ed746..f9aad13 100644
--- a/src-源文件/main/resources/mapper/qu/QuMapper.xml
+++ b/src-源文件/main/resources/mapper/qu/QuMapper.xml
@@ -1,90 +1,145 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.qu.mapper.QuMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.qu.mapper.QuMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.qu.entity.Qu">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是Qu类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="qu_type" property="quType" />
+        <!-- 把数据库表中的qu_type列的值映射到Java对象的quType属性 -->
         <result column="level" property="level" />
+        <!-- 将数据库表中的level列的值映射到Java对象的level属性 -->
         <result column="image" property="image" />
+        <!-- 把数据库表中的image列的值映射到Java对象的image属性 -->
         <result column="content" property="content" />
+        <!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
         <result column="create_time" property="createTime" />
+        <!-- 把数据库表中的create_time列的值映射到Java对象的createTime属性 -->
         <result column="update_time" property="updateTime" />
+        <!-- 将数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
         <result column="remark" property="remark" />
+        <!-- 把数据库表中的remark列的值映射到Java对象的remark属性 -->
         <result column="analysis" property="analysis" />
-    </resultMap>
+        <!-- 将数据库表中的analysis列的值映射到Java对象的analysis属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`qu_type`,`level`,`image`,`content`,`create_time`,`update_time`,`remark`,`analysis`
     </sql>
 
 
     <!-- 随机取数据 -->
     <select id="listByRandom" resultMap="BaseResultMap">
+        <!-- 定义一个名为listByRandom的查询语句，其结果将按照BaseResultMap定义的映射关系进行映射 -->
         SELECT a.*
+        <!-- 选择el_qu表（a）中的所有列数据 -->
         FROM el_qu a
         LEFT JOIN el_qu_repo b ON a.id=b.qu_id
+        <!-- 使用LEFT JOIN连接el_qu表（a）和el_qu_repo表（b），连接条件是a.id等于b.qu_id，这样可以关联题目（el_qu表）和题目资源库（el_qu_repo表）的相关信息 -->
         WHERE b.repo_id=#{repoId} AND a.qu_type=#{quType}
+        <!-- 添加WHERE子句条件，筛选出在el_qu_repo表中repo_id等于传入的#{repoId}参数值且在el_qu表中qu_type等于传入的#{quType}参数值的记录 -->
         <if test="excludes!=null">
+            <!-- <if>标签用于条件判断，这里判断传入的参数excludes是否不为空 -->
             AND a.id NOT IN
+            <!-- 当excludes不为空时，添加条件使得查询结果中的a.id不在excludes所包含的列表值中 -->
             <foreach item="item" collection="excludes" separator="," open="(" close=")" index="">'${item}'</foreach>
+            <!-- 使用<foreach>标签遍历excludes集合，将集合中的每个元素（这里用'${item}'表示，注意这里是使用$符号进行字符串拼接，可能存在SQL注入风险，要确保数据来源可靠）作为一个值放在IN子句中，open、close、separator分别指定了括号的开头、结尾和元素之间的分隔符 -->
         </if>
         ORDER BY RAND()
+        <!-- 按照随机顺序对查询结果进行排序，使得每次查询结果的顺序是随机的 -->
         LIMIT ${size}
+        <!-- 限制查询结果的数量为传入的${size}参数值，同样这里使用$符号进行参数替换，要注意数据来源的安全性 -->
     </select>
 
 
     <resultMap id="ExportResultMap" type="com.yf.exam.modules.qu.dto.export.QuExportDTO">
+        <!-- 定义一个名为ExportResultMap的结果映射，它的类型是QuExportDTO，用于将数据库查询结果映射到特定的用于导出的DTO对象 -->
         <id column="q_id" property="qId"  />
+        <!-- 定义主键的映射关系，将数据库表中的q_id列的值映射到Java对象的qId属性上 -->
         <result column="qu_type" property="quType"  />
+        <!-- 把数据库表中的qu_type列的值映射到Java对象的quType属性 -->
         <result column="q_content" property="qContent"  />
+        <!-- 将数据库表中的q_content列的值映射到Java对象的qContent属性 -->
         <result column="q_analysis" property="qAnalysis"  />
+        <!-- 把数据库表中的q_analysis列的值映射到Java对象的qAnalysis属性 -->
         <result column="a_is_right" property="aIsRight"  />
+        <!-- 将数据库表中的a_is_right列的值映射到Java对象的aIsRight属性 -->
         <result column="a_content" property="aContent"  />
+        <!-- 把数据库表中的a_content列的值映射到Java对象的aContent属性 -->
         <result column="a_analysis" property="aAnalysis"  />
+        <!-- 将数据库表中的a_analysis列的值映射到Java对象的aAnalysis属性 -->
         <collection property="repoList" column="q_id" select="selectRepos"/>
+        <!-- 使用<collection>标签来处理一对多的关系，这里表示将根据q_id列的值从selectRepos查询中获取多条记录，并将这些记录映射到Java对象的repoList属性上。column属性用于指定传递给子查询的参数，select属性指定了要调用的子查询的方法名（这里对应下面定义的selectRepos查询） -->
     </resultMap>
 
     <select id="selectRepos" resultType="String">
-		SELECT repo_id FROM el_qu_repo po WHERE po.qu_id=#{qId}
-	</select>
+        <!-- 定义一个名为selectRepos的查询语句，其结果类型为字符串（String），用于查询与特定题目（由qId指定）相关的资源库ID -->
+        SELECT repo_id FROM el_qu_repo po WHERE po.qu_id=#{qId}
+        <!-- 从el_qu_repo表（po）中选择repo_id列，筛选条件是po.qu_id等于传入的#{qId}参数值 -->
+    </select>
 
 
     <sql id="query">
+        <!-- 定义一个名为query的SQL片段，可在其他SQL语句中引用，用于构建动态查询条件 -->
         <where>
+            <!-- <where>标签用于动态生成WHERE子句，根据条件判断是否添加相应的条件语句 -->
             <if test="query!=null">
+                <!-- <if>标签用于条件判断，这里判断传入的参数query是否不为空 -->
                 <if test="query.quType!=null">
+                    <!-- 进一步判断query对象中的quType属性是否不为空，如果满足条件则添加以下WHERE子句条件 -->
                     AND q.qu_type = #{query.quType}
+                    <!-- 将数据库表中的q.qu_type列与传入的query.quType参数值进行精确匹配 -->
                 </if>
                 <if test="query.repoIds!=null and query.repoIds.size()>0">
+                    <!-- 进一步判断query对象中的repoIds属性是否不为空且集合大小大于0，如果满足条件则添加以下WHERE子句条件 -->
                     AND po.repo_id IN
+                    <!-- 使用IN子句，将po.repo_id列的值与query.repoIds集合中的元素进行匹配 -->
                     <foreach collection="query.repoIds" open="(" close=")" separator="," item="repoId">#{repoId}</foreach>
+                    <!-- 使用<foreach>标签遍历query.repoIds集合，将集合中的每个元素（这里用#{repoId}表示，通过#符号进行参数替换，相对安全）作为一个值放在IN子句中，open、close、separator分别指定了括号的开头、结尾和元素之间的分隔符 -->
                 </if>
                 <if test="query.content!=null and query.content!=''">
+                    <!-- 进一步判断query对象中的content属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                     AND q.content LIKE CONCAT('%',#{query.content},'%')
+                    <!-- 使用LIKE关键字进行模糊查询，将查询条件中的content值与数据库表中的q.content列进行模糊匹配，#{query.content}是MyBatis的参数占位符，会被实际传入的参数值替换 -->
                 </if>
                 <if test="query.excludes!=null and query.excludes.size()>0">
+                    <!-- 进一步判断query对象中的excludes属性是否不为空且集合大小大于0，如果满足条件则添加以下WHERE子句条件 -->
                     AND q.id NOT IN
+                    <!-- 添加条件使得查询结果中的q.id不在query.excludes所包含的列表值中 -->
                     <foreach collection="query.excludes" open="(" close=")" separator="," item="quId">
                     #{quId}
                     </foreach>
+                    <!-- 使用<foreach>标签遍历query.excludes集合，将集合中的每个元素（这里用#{quId}表示，通过#符号进行参数替换，相对安全）作为一个值放在NOT IN子句中，open、close、separator分别指定了括号的开头、结尾和元素之间的分隔符 -->
                 </if>
             </if>
         </where>
     </sql>
 
     <select id="paging" resultMap="BaseResultMap">
+        <!-- 定义一个名为paging的查询语句，其结果将按照BaseResultMap定义的映射关系进行映射 -->
         SELECT q.*
+        <!-- 选择el_qu表（q）中的所有列数据 -->
         FROM el_qu q
         LEFT JOIN el_qu_repo po ON q.id=po.qu_id
+        <!-- 使用LEFT JOIN连接el_qu表（q）和el_qu_repo表（po），连接条件是q.id等于po.qu_id，这样可以关联题目（el_qu表）和题目资源库（el_qu_repo表）的相关信息 -->
         <include refid="query" />
+        <!-- 引用上面定义的query SQL片段，将其包含的动态查询条件添加到当前查询语句中 -->
         GROUP BY q.id ORDER BY q.update_time DESC
+        <!-- 按照q.id进行分组，然后按照q.update_time列的值进行降序排序，以便获取最新更新的记录排在前面 -->
     </select>
 
 
     <select id="listForExport" resultMap="ExportResultMap">
+        <!-- 定义一个名为listForExport的查询语句，其结果将按照ExportResultMap定义的映射关系进行映射 -->
         SELECT
         q.id as q_id,
         q.qu_type,
@@ -93,12 +148,17 @@
         a.content as a_content,
         a.is_right as a_is_right,
         a.analysis as a_analysis
+        <!-- 从el_qu表（q）和el_qu_answer表（a）中选择指定列的数据，同时对某些列进行别名设置，以便在结果映射时能准确对应到ExportResultMap中定义的属性 -->
         FROM el_qu q
         LEFT JOIN el_qu_answer a ON q.id=a.qu_id
         LEFT JOIN el_qu_repo po ON q.id=po.qu_id
+        <!-- 使用LEFT JOIN连接el_qu表（q）、el_qu_answer表（a）和el_qu_repo表（po），连接条件分别是q.id等于a.qu_id和q.id等于po.qu_id，这样可以关联题目、题目答案以及题目资源库的相关信息 -->
         <include refid="query" />
+        <!-- 引用上面定义的query SQL片段，将其包含的动态查询条件添加到当前查询语句中 -->
         GROUP BY a.id ORDER BY q.id
+        <!-- 按照a.id进行分组，然后按照q.id列的值进行排序，以便以特定顺序展示查询结果 -->
         LIMIT 10000
+        <!-- 限制查询结果的数量为10000条 -->
     </select>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/qu/QuRepoMapper.xml b/src-源文件/main/resources/mapper/qu/QuRepoMapper.xml
index 3353d6c..9ff607b 100644
--- a/src-源文件/main/resources/mapper/qu/QuRepoMapper.xml
+++ b/src-源文件/main/resources/mapper/qu/QuRepoMapper.xml
@@ -1,20 +1,32 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.qu.mapper.QuRepoMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.qu.mapper.QuRepoMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.qu.entity.QuRepo">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是QuRepo类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="qu_id" property="quId" />
+        <!-- 把数据库表中的qu_id列的值映射到Java对象的quId属性 -->
         <result column="repo_id" property="repoId" />
+        <!-- 将数据库表中的repo_id列的值映射到Java对象的repoId属性 -->
         <result column="qu_type" property="quType" />
+        <!-- 把数据库表中的qu_type列的值映射到Java对象的quType属性 -->
         <result column="sort" property="sort" />
-    </resultMap>
+        <!-- 将数据库表中的sort列的值映射到Java对象的sort属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`qu_id`,`repo_id`,`qu_type`,`sort`
     </sql>
 
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/repo/RepoMapper.xml b/src-源文件/main/resources/mapper/repo/RepoMapper.xml
index d026b31..fb8573e 100644
--- a/src-源文件/main/resources/mapper/repo/RepoMapper.xml
+++ b/src-源文件/main/resources/mapper/repo/RepoMapper.xml
@@ -1,19 +1,32 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.repo.mapper.RepoMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.repo.mapper.RepoMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.repo.entity.Repo">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是Repo类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="code" property="code" />
+        <!-- 把数据库表中的code列的值映射到Java对象的code属性 -->
         <result column="title" property="title" />
+        <!-- 将数据库表中的title列的值映射到Java对象的title属性 -->
         <result column="remark" property="remark" />
+        <!-- 把数据库表中的remark列的值映射到Java对象的remark属性 -->
         <result column="create_time" property="createTime" />
+        <!-- 将数据库表中的create_time列的值映射到Java对象的createTime属性 -->
         <result column="update_time" property="updateTime" />
-    </resultMap>
+        <!-- 把数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`code`,`title`,`radio_count`,`multi_count`,`judge_count`,`remark`,`create_time`,`update_time`
     </sql>
 
@@ -21,25 +34,40 @@
     <resultMap id="ListResultMap"
                type="com.yf.exam.modules.repo.dto.response.RepoRespDTO"
                extends="BaseResultMap">
+        <!-- 定义一个名为ListResultMap的结果映射，它的类型是RepoRespDTO，并且通过extends属性继承了BaseResultMap，意味着它会包含BaseResultMap中定义的所有映射关系，在此基础上还可以添加新的映射关系 -->
         <result column="radio_count" property="radioCount" />
+        <!-- 新增的映射关系，将数据库表中的radio_count列的值映射到Java对象的radioCount属性 -->
         <result column="multi_count" property="multiCount" />
+        <!-- 将数据库表中的multi_count列的值映射到Java对象的multiCount属性 -->
         <result column="judge_count" property="judgeCount" />
-    </resultMap>
+        <!-- 把数据库表中的judge_count列的值映射到Java对象的judgeCount属性 -->
+        </resultMap>
 
     <select id="paging" resultMap="ListResultMap">
+        <!-- 定义一个名为paging的查询语句，其结果将按照ListResultMap定义的映射关系进行映射 -->
         SELECT `id`, `code`, `title`, `remark`, `create_time`, `update_time`,
         (SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=repo.id AND qu_type=1) AS radio_count,
+        <!-- 通过子查询计算出在el_qu_repo表中，repo_id等于当前查询结果中的repo.id且qu_type为1的记录数量，并将其命名为radio_count，这个值将根据ListResultMap的映射关系映射到对应的Java对象属性上 -->
         (SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=repo.id AND qu_type=2) AS multi_count,
+        <!-- 同样通过子查询计算出在el_qu_repo表中，repo_id等于当前查询结果中的repo.id且qu_type为2的记录数量，并将其命名为multi_count，会根据映射关系映射到Java对象属性上 -->
         (SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=repo.id AND qu_type=3) AS judge_count
+        <!-- 再次通过子查询计算出在el_qu_repo表中，repo_id等于当前查询结果中的repo.id且qu_type为3的记录数量，并将其命名为judge_count，也会按照映射关系映射到Java对象属性上 -->
         FROM el_repo repo
         <where>
+            <!-- <where>标签用于动态生成WHERE子句，根据条件判断是否添加相应的条件语句 -->
             <if test="query!=null">
+                <!-- <if>标签用于条件判断，这里判断传入的参数query是否不为空 -->
                 <if test="query.title!=null and query.title!=''">
+                    <!-- 进一步判断query对象中的title属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                     AND repo.title LIKE CONCAT('%',#{query.title}, '%')
+                    <!-- 使用LIKE关键字进行模糊查询，将查询条件中的title值与数据库表中的repo.title列进行模糊匹配，#{query.title}是MyBatis的参数占位符，会被实际传入的参数值替换 -->
                 </if>
                 <if test="query.excludes!=null and query.excludes.size()>0">
+                    <!-- 进一步判断query对象中的excludes属性是否不为空且集合大小大于0，如果满足条件则添加以下WHERE子句条件 -->
                     AND repo.id NOT IN
+                    <!-- 添加条件使得查询结果中的repo.id不在query.excludes所包含的列表值中 -->
                     <foreach collection="query.excludes" open="(" close=")" separator="," item="id">
+                        <!-- 使用<foreach>标签遍历query.excludes集合，将集合中的每个元素（这里用#{id}表示，通过#符号进行参数替换，相对安全）作为一个值放在NOT IN子句中，open、close、separator分别指定了括号的开头、结尾和元素之间的分隔符 -->
                         #{id}
                     </foreach>
                 </if>
@@ -48,4 +76,4 @@
     </select>
 
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/sys/depart/SysDepartMapper.xml b/src-源文件/main/resources/mapper/sys/depart/SysDepartMapper.xml
index 2bae742..3135548 100644
--- a/src-源文件/main/resources/mapper/sys/depart/SysDepartMapper.xml
+++ b/src-源文件/main/resources/mapper/sys/depart/SysDepartMapper.xml
@@ -1,19 +1,32 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.sys.depart.mapper.SysDepartMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.sys.depart.mapper.SysDepartMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.sys.depart.entity.SysDepart">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是SysDepart类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="dept_type" property="deptType" />
+        <!-- 把数据库表中的dept_type列的值映射到Java对象的deptType属性 -->
         <result column="parent_id" property="parentId" />
+        <!-- 将数据库表中的parent_id列的值映射到Java对象的parentId属性 -->
         <result column="dept_name" property="deptName" />
+        <!-- 把数据库表中的dept_name列的值映射到Java对象的deptName属性 -->
         <result column="dept_code" property="deptCode" />
+        <!-- 将数据库表中的dept_code列的值映射到Java对象的deptCode属性 -->
         <result column="sort" property="sort" />
-    </resultMap>
+        <!-- 把数据库表中的sort列的值映射到Java对象的sort属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`dept_type`,`parent_id`,`dept_name`,`dept_code`,`sort`
     </sql>
 
@@ -21,20 +34,29 @@
     <resultMap id="TreeResultMap"
                type="com.yf.exam.modules.sys.depart.dto.response.SysDepartTreeDTO"
                extends="BaseResultMap">
+        <!-- 定义一个名为TreeResultMap的结果映射，它的类型是SysDepartTreeDTO，并且通过extends属性继承了BaseResultMap，意味着它会包含BaseResultMap中定义的所有映射关系，在此基础上还可以添加新的映射关系 -->
         <collection property="children" column="id" select="findChildren"></collection>
+        <!-- 使用<collection>标签来处理一对多的关系，这里表示将根据id列的值从findChildren查询中获取多条记录，并将这些记录映射到Java对象的children属性上。column属性用于指定传递给子查询的参数，select属性指定了要调用的子查询的方法名（这里对应下面定义的findChildren查询） -->
     </resultMap>
 
     <select id="findChildren" resultMap="TreeResultMap">
+        <!-- 定义一个名为findChildren的查询语句，其结果将按照TreeResultMap定义的映射关系进行映射 -->
         SELECT * FROM sys_depart WHERE parent_id=#{id}
+        <!-- 从sys_depart表中选择所有列的数据，筛选条件是parent_id等于传入的#{id}参数值，用于获取指定父节点（由#{id}确定）下的所有子部门信息 -->
     </select>
 
     <select id="paging" resultMap="TreeResultMap">
+        <!-- 定义一个名为paging的查询语句，其结果将按照TreeResultMap定义的映射关系进行映射 -->
         SELECT * FROM sys_depart WHERE parent_id='0'
+        <!-- 从sys_depart表中选择所有列的数据，筛选条件是parent_id等于'0'，通常用于获取顶级部门（假设parent_id为'0'表示顶级部门）的信息 -->
         <if test="query!=null">
+            <!-- <if>标签用于条件判断，这里判断传入的参数query是否不为空 -->
             <if test="query.deptName!=null and query.deptName!=''">
+                <!-- 进一步判断query对象中的deptName属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                 AND dept_name LIKE CONCAT('%',#{query.deptName},'%')
+                <!-- 使用LIKE关键字进行模糊查询，将查询条件中的deptName值与数据库表中的dept_name列进行模糊匹配，#{query.deptName}是MyBatis的参数占位符，会被实际传入的参数值替换 -->
             </if>
         </if>
     </select>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/sys/system/SysDictMapper.xml b/src-源文件/main/resources/mapper/sys/system/SysDictMapper.xml
index 194ff86..372e9e6 100644
--- a/src-源文件/main/resources/mapper/sys/system/SysDictMapper.xml
+++ b/src-源文件/main/resources/mapper/sys/system/SysDictMapper.xml
@@ -1,9 +1,22 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.sys.system.mapper.SysDictMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一的标识，这里对应着com.yf.exam.modules.sys.system.mapper.SysDictMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <select id="findDict" resultType="String">
+        <!-- 定义一个名为findDict的查询语句，其结果类型为字符串（String），意味着该查询将返回一个字符串类型的结果 -->
         SELECT ${text} FROM ${table} WHERE ${key}=${value} LIMIT 1
+        <!-- 这是一个简单的SQL查询语句，其中使用了动态参数（${text}、${table}、${key}、${value}）。
+        SELECT后面跟着的${text}表示要从数据库表中选择的列名，这个列名是通过外部传入的参数动态确定的。
+        FROM后面跟着的${table}表示要查询的数据库表名，同样是通过外部传入的参数来指定。
+        WHERE后面跟着的${key}=${value}表示查询的条件，即根据传入的键（${key}）和对应的值（${value}）来筛选符合条件的记录。
+        LIMIT 1表示只获取满足条件的第一条记录，用于获取特定条件下的单个结果。
+
+        需要注意的是，这里使用${}来引用参数的方式存在一定的SQL注入风险，因为外部传入的参数如果被恶意构造，可能会改变原本预期的SQL语句结构，导致安全问题。在实际应用中，应尽量使用#{}来引用参数，它会对传入的参数进行预编译处理，能有效防止SQL注入攻击。 -->
     </select>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/sys/user/SysRoleMapper.xml b/src-源文件/main/resources/mapper/sys/user/SysRoleMapper.xml
index f79fbf6..151ec24 100644
--- a/src-源文件/main/resources/mapper/sys/user/SysRoleMapper.xml
+++ b/src-源文件/main/resources/mapper/sys/user/SysRoleMapper.xml
@@ -1,16 +1,25 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.sys.user.mapper.SysRoleMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.sys.user.mapper.SysRoleMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.sys.user.entity.SysRole">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是SysRole类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="role_name" property="roleName" />
-    </resultMap>
+        <!-- 把数据库表中的role_name列的值映射到Java对象的roleName属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`role_name`
     </sql>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/sys/user/SysUserMapper.xml b/src-源文件/main/resources/mapper/sys/user/SysUserMapper.xml
index 7d9c81f..cb212de 100644
--- a/src-源文件/main/resources/mapper/sys/user/SysUserMapper.xml
+++ b/src-源文件/main/resources/mapper/sys/user/SysUserMapper.xml
@@ -1,24 +1,41 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.sys.user.mapper.SysUserMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.sys.user.mapper.SysUserMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.sys.user.entity.SysUser">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是SysUser类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="user_name" property="userName" />
+        <!-- 把数据库表中的user_name列的值映射到Java对象的userName属性 -->
         <result column="real_name" property="realName" />
+        <!-- 将数据库表中的real_name列的值映射到Java对象的realName属性 -->
         <result column="password" property="password" />
+        <!-- 把数据库表中的password列的值映射到Java对象的password属性 -->
         <result column="salt" property="salt" />
+        <!-- 将数据库表中的salt列的值映射到Java对象的salt属性 -->
         <result column="role_ids" property="roleIds" />
+        <!-- 把数据库表中的role_ids列的值映射到Java对象的roleIds属性 -->
         <result column="depart_id" property="departId" />
+        <!-- 将数据库表中的depart_id列的值映射到Java对象的departId属性 -->
         <result column="create_time" property="createTime" />
+        <!-- 把数据库表中的create_time列的值映射到Java对象的createTime属性 -->
         <result column="update_time" property="updateTime" />
+        <!-- 将数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
         <result column="state" property="state" />
-    </resultMap>
+        <!-- 把数据库表中的state列的值映射到Java对象的state属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`user_name`,`real_name`,`password`,`salt`,`role_ids`,`depart_id`,`create_time`,`update_time`,`state`
     </sql>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/sys/user/SysUserRoleMapper.xml b/src-源文件/main/resources/mapper/sys/user/SysUserRoleMapper.xml
index f2ea833..4c70916 100644
--- a/src-源文件/main/resources/mapper/sys/user/SysUserRoleMapper.xml
+++ b/src-源文件/main/resources/mapper/sys/user/SysUserRoleMapper.xml
@@ -1,17 +1,27 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.sys.user.mapper.SysUserRoleMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.sys.user.mapper.SysUserRoleMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.sys.user.entity.SysUserRole">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是SysUserRole类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="user_id" property="userId" />
+        <!-- 把数据库表中的user_id列的值映射到Java对象的userId属性 -->
         <result column="role_id" property="roleId" />
-    </resultMap>
+        <!-- 将数据库表中的role_id列的值映射到Java对象的roleId属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`user_id`,`role_id`
     </sql>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/user/UserBookMapper.xml b/src-源文件/main/resources/mapper/user/UserBookMapper.xml
index 17d6775..2489cad 100644
--- a/src-源文件/main/resources/mapper/user/UserBookMapper.xml
+++ b/src-源文件/main/resources/mapper/user/UserBookMapper.xml
@@ -1,23 +1,39 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.user.book.mapper.UserBookMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.user.book.mapper.UserBookMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.user.book.entity.UserBook">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是UserBook类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="exam_id" property="examId" />
+        <!-- 把数据库表中的exam_id列的值映射到Java对象的examId属性 -->
         <result column="user_id" property="userId" />
+        <!-- 将数据库表中的user_id列的值映射到Java对象的userId属性 -->
         <result column="qu_id" property="quId" />
+        <!-- 把数据库表中的qu_id列的值映射到Java对象的quId属性 -->
         <result column="create_time" property="createTime" />
+        <!-- 将数据库表中的create_time列的值映射到Java对象的createTime属性 -->
         <result column="update_time" property="updateTime" />
+        <!-- 把数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
         <result column="wrong_count" property="wrongCount" />
+        <!-- 将数据库表中的wrong_count列的值映射到Java对象的wrongCount属性 -->
         <result column="title" property="title" />
+        <!-- 把数据库表中的title列的值映射到Java对象的title属性 -->
         <result column="sort" property="sort" />
-    </resultMap>
+        <!-- 将数据库表中的sort列的值映射到Java对象的sort属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`exam_id`,`user_id`,`qu_id`,`create_time`,`update_time`,`wrong_count`,`title`,`sort`
     </sql>
 
-</mapper>
+</mapper>
\ No newline at end of file
diff --git a/src-源文件/main/resources/mapper/user/UserExamMapper.xml b/src-源文件/main/resources/mapper/user/UserExamMapper.xml
index d123ee7..470fc6b 100644
--- a/src-源文件/main/resources/mapper/user/UserExamMapper.xml
+++ b/src-源文件/main/resources/mapper/user/UserExamMapper.xml
@@ -1,21 +1,36 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- XML声明，指定了XML的版本为1.0以及字符编码为UTF-8，这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
+
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 文档类型定义（DOCTYPE）声明，表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义（DTD）规范，同时给出了DTD文件的网络地址，以便解析器能依据该DTD验证XML文档结构的正确性 -->
+
 <mapper namespace="com.yf.exam.modules.user.exam.mapper.UserExamMapper">
+<!-- 定义了一个MyBatis的Mapper，namespace属性指定了该Mapper在整个项目中的唯一标识，这里对应着com.yf.exam.modules.user.exam.mapper.UserExamMapper接口，用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
 
     <!-- 通用查询映射结果 -->
     <resultMap id="BaseResultMap" type="com.yf.exam.modules.user.exam.entity.UserExam">
+        <!-- 开始定义一个名为BaseResultMap的结果映射，用于将数据库查询结果准确地映射到指定的Java对象（这里是UserExam类型）。id属性为该结果映射的唯一标识符 -->
         <id column="id" property="id" />
+        <!-- 定义主键的映射关系，将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名，property属性指定要映射到的Java对象中的属性名 -->
         <result column="user_id" property="userId" />
+        <!-- 把数据库表中的user_id列的值映射到Java对象的userId属性 -->
         <result column="exam_id" property="examId" />
+        <!-- 将数据库表中的exam_id列的值映射到Java对象的examId属性 -->
         <result column="try_count" property="tryCount" />
+        <!-- 把数据库表中的try_count列的值映射到Java对象的tryCount属性 -->
         <result column="max_score" property="maxScore" />
+        <!-- 将数据库表中的max_score列的值映射到Java对象的maxScore属性 -->
         <result column="passed" property="passed" />
+        <!-- 把数据库表中的passed列的值映射到Java对象的passed属性 -->
         <result column="create_time" property="createTime" />
+        <!-- 将数据库表中的create_time列的值映射到Java对象的createTime属性 -->
         <result column="update_time" property="updateTime" />
-    </resultMap>
+        <!-- 把数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
+        </resultMap>
 
     <!-- 通用查询结果列 -->
     <sql id="Base_Column_List">
+        <!-- 定义了一个名为Base_Column_List的SQL片段，可在其他SQL语句中引用，这里列出了通用查询时要从数据库表中选择的列名，使用反引号（`）括起来是为了防止列名是SQL关键字时出现语法错误 -->
         `id`,`user_id`,`exam_id`,`try_count`,`max_score`,`passed`,`create_time`,`update_time`
     </sql>
 
@@ -23,32 +38,46 @@
     <resultMap id="ListResultMap"
                type="com.yf.exam.modules.user.exam.dto.response.UserExamRespDTO"
                extends="BaseResultMap">
+        <!-- 定义一个名为ListResultMap的结果映射，它的类型是UserExamRespDTO，并且通过extends属性继承了BaseResultMap，意味着它会包含BaseResultMap中定义的所有映射关系，在此基础上还可以添加新的映射关系 -->
         <result column="title" property="title" />
+        <!-- 新增的映射关系，将数据库表中的title列的值映射到Java对象的title属性 -->
         <result column="real_name" property="realName" />
-    </resultMap>
+        <!-- 将数据库表中的real_name列的值映射到Java对象的realName属性 -->
+        </resultMap>
 
 
     <select id="paging" resultMap="ListResultMap">
+        <!-- 定义一个名为paging的查询语句，其结果将按照ListResultMap定义的映射关系进行映射 -->
         SELECT ue.*,ee.title,uc.real_name FROM el_user_exam ue
         LEFT JOIN el_exam ee ON ue.exam_id=ee.id
         LEFT JOIN sys_user uc ON ue.user_id=uc.id
+        <!-- 使用LEFT JOIN连接el_user_exam表（ue）、el_exam表（ee）和sys_user表（uc），分别通过ue.exam_id=ee.id和ue.user_id=uc.id建立连接条件，以便在查询结果中获取到与用户考试相关的考试信息（如考试标题）以及用户的真实姓名等信息 -->
         WHERE ee.id IS NOT NULL AND uc.id IS NOT NULL
+        <!-- 添加WHERE子句条件，筛选出在el_exam表和sys_user表中对应的id不为空的记录，确保连接后的数据是有效的 -->
 
         <if test="query!=null">
-
+            <!-- <if>标签用于条件判断，这里判断传入的参数query是否不为空 -->
             <if test="query.userId!=null and query.userId!=''">
+                <!-- 进一步判断query对象中的userId属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                 AND ue.user_id='{{userId}}'
+                <!-- 将数据库表中的ue.user_id列与传入的query.userId参数值（这里使用{{userId}}这种格式可能不太常见，通常应该是#{query.userId}这种MyBatis的参数占位符格式，需要确认一下是否正确）进行精确匹配 -->
             </if>
             <if test="query.examId!=null and query.examId!=''">
+                <!-- 进一步判断query对象中的examId属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                 AND ue.exam_id = #{query.examId}
+                <!-- 将数据库表中的ue.exam_id列与传入的query.examId参数值进行精确匹配，这里使用了正确的MyBatis参数占位符格式 -->
             </if>
             <if test="query.title!=null and query.title!=''">
+                <!-- 进一步判断query对象中的title属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                 AND ee.title LIKE CONCAT('%',#{query.title},'%')
+                <!-- 使用LIKE关键字进行模糊查询，将查询条件中的title值与数据库表中的ee.title列进行模糊匹配，#{query.title}是MyBatis的参数占位符，会被实际传入的参数值替换 -->
             </if>
             <if test="query.realName!=null and query.realName!=''">
+                <!-- 进一步判断query对象中的realName属性是否不为空且不为空字符串，如果满足条件则添加以下WHERE子句条件 -->
                 AND uc.real_name LIKE CONCAT('%',#{query.realName},'%')
+                <!-- 使用LIKE关键字进行模糊查询，将查询条件中的realName值与数据库表中的uc.real_name列进行模糊匹配，#{query.realName}是MyBatis的参数占位符，会被实际传入的参数值替换 -->
             </if>
         </if>
 
     </select>
-</mapper>
+</mapper>
\ No newline at end of file