注释了全部前端文件包

.gitignore

@@ -21,3 +21,5 @@
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
+
+**/.idea

.idea/compiler.xml

@@ -1,18 +1,30 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义XML文档的版本和编码 -->
 <project version="4">
+  <!-- 定义项目版本 -->
   <component name="CompilerConfiguration">
+    <!-- 定义编译器配置 -->
     <annotationProcessing>
+      <!-- 定义注解处理 -->
       <profile name="Maven default annotation processors profile" enabled="true">
+        <!-- 定义Maven默认注解处理器配置 -->
         <sourceOutputDir name="target/generated-sources/annotations" />
+        <!-- 定义源代码输出目录 -->
         <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
+        <!-- 定义测试代码输出目录 -->
         <outputRelativeToContentRoot value="true" />
+        <!-- 定义输出目录相对于内容根目录 -->
         <module name="exam" />
+        <!-- 定义模块名称 -->
       </profile>
     </annotationProcessing>
   </component>
   <component name="JavacSettings">
+    <!-- 定义Javac设置 -->
     <option name="ADDITIONAL_OPTIONS_OVERRIDE">
+      <!-- 定义附加选项覆盖 -->
       <module name="exam" options="-parameters" />
+      <!-- 定义模块名称和选项 -->
     </option>
   </component>
 </project>

.idea/encodings.xml

@@ -1,6 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义XML文档的版本和编码 -->
 <project version="4">
+  <!-- 定义项目版本 -->
   <component name="Encoding">
+    <!-- 定义组件名称 -->
     <file url="file://$PROJECT_DIR$/backend/src/main/java" charset="UTF-8" />
+    <!-- 定义文件路径和字符编码 -->
   </component>
 </project>

.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +1,68 @@
 <component name="InspectionProjectProfileManager">
   <profile version="1.0">
     <option name="myName" value="Project Default" />
+    <inspection_tool class="AliAccessStaticViaInstance" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AliArrayNamingShouldHaveBracket" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AliControlFlowStatementWithoutBraces" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AliDeprecation" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AliEqualsAvoidNull" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AliLongLiteralsEndingWithLowercaseL" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AliMissingOverrideAnnotation" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AliWrapperTypeEquality" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAbstractClassShouldStartWithAbstractNaming" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAbstractMethodOrInterfaceMethodMustUseJavadoc" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidApacheBeanUtilsCopy" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidCallStaticSimpleDateFormat" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidCommentBehindStatement" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidComplexCondition" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidConcurrentCompetitionRandom" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidDoubleOrFloatEqualCompare" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidManuallyCreateThread" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidMissUseOfMathRandom" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidNegationOperator" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidNewDateGetTime" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidPatternCompileInMethod" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidReturnInFinally" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidStartWithDollarAndUnderLineNaming" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaAvoidUseTimer" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaBigDecimalAvoidDoubleConstructor" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaBooleanPropertyShouldNotStartWithIs" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaClassCastExceptionWithSubListToArrayList" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaClassCastExceptionWithToArray" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaClassMustHaveAuthor" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaClassNamingShouldBeCamel" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaCollectionInitShouldAssignCapacity" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaCommentsMustBeJavadocFormat" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaConcurrentExceptionWithModifyOriginSubList" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaConstantFieldShouldBeUpperCase" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaCountDownShouldInFinally" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaDontModifyInForeachCircle" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaEnumConstantsMustHaveComment" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaExceptionClassShouldEndWithException" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaIbatisMethodQueryForList" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaLockShouldWithTryFinally" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaLowerCamelCaseVariableNaming" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaMethodReturnWrapperType" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaMethodTooLong" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaPackageNaming" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaPojoMustOverrideToString" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaPojoMustUsePrimitiveField" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaPojoNoDefaultValue" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaRemoveCommentedCode" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaServiceOrDaoClassShouldEndWithImpl" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaSneakyThrowsWithoutExceptionType" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaStringConcat" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaSwitchExpression" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaSwitchStatement" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaTestClassShouldEndWithTestNaming" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaThreadLocalShouldRemove" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaThreadPoolCreation" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaThreadShouldSetName" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaTransactionMustHaveRollback" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaUndefineMagicConstant" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaUnsupportedExceptionWithModifyAsList" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaUseQuietReferenceNotation" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="AlibabaUseRightCaseForDateFormat" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="MapOrSetKeyShouldOverrideHashCodeEquals" enabled="true" level="WARNING" enabled_by_default="true" />
   </profile>

.idea/jarRepositories.xml

@@ -1,19 +1,33 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义项目版本 -->
 <project version="4">
+  <!-- 定义远程仓库配置 -->
   <component name="RemoteRepositoriesConfiguration">
+    <!-- 定义第一个远程仓库 -->
     <remote-repository>
+      <!-- 定义远程仓库ID -->
       <option name="id" value="central" />
+      <!-- 定义远程仓库名称 -->
       <option name="name" value="Central Repository" />
+      <!-- 定义远程仓库URL -->
       <option name="url" value="https://repo.maven.apache.org/maven2" />
     </remote-repository>
+    <!-- 定义第二个远程仓库 -->
     <remote-repository>
+      <!-- 定义远程仓库ID -->
       <option name="id" value="central" />
+      <!-- 定义远程仓库名称 -->
       <option name="name" value="Maven Central repository" />
+      <!-- 定义远程仓库URL -->
       <option name="url" value="https://repo1.maven.org/maven2" />
     </remote-repository>
+    <!-- 定义第三个远程仓库 -->
     <remote-repository>
+      <!-- 定义远程仓库ID -->
       <option name="id" value="jboss.community" />
+      <!-- 定义远程仓库名称 -->
       <option name="name" value="JBoss Community repository" />
+      <!-- 定义远程仓库URL -->
       <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
     </remote-repository>
   </component>

.idea/misc.xml

@@ -1,14 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 项目版本 -->
 <project version="4">
+  <!-- 外部存储配置管理器 -->
   <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <!-- Maven项目管理器 -->
   <component name="MavenProjectsManager">
+    <!-- 原始文件列表 -->
     <option name="originalFiles">
       <list>
+        <!-- 后端项目的pom.xml文件 -->
         <option value="$PROJECT_DIR$/backend/pom.xml" />
       </list>
     </option>
   </component>
+  <!-- 项目根管理器 -->
   <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8 (2)" project-jdk-type="JavaSDK">
+    <!-- 输出目录 -->
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

.idea/modules.xml

@@ -1,8 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义XML文档的版本和编码 -->
 <project version="4">
+  <!-- 定义项目的版本 -->
   <component name="ProjectModuleManager">
+    <!-- 定义项目的模块管理器 -->
     <modules>
+      <!-- 定义项目的模块 -->
       <module fileurl="file://$PROJECT_DIR$/.idea/spring-boot-online-exam-master.iml" filepath="$PROJECT_DIR$/.idea/spring-boot-online-exam-master.iml" />
+      <!-- 定义项目的模块文件路径 -->
     </modules>
   </component>
-</project>
+</project>
+<!-- 定义项目的根元素 -->

.idea/sqlDataSources.xml

@@ -1,8 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义XML文档的版本和编码 -->
 <project version="4">
+  <!-- 定义一个项目，版本为4 -->
   <component name="DdlMappings">
+    <!-- 定义一个组件，名称为DdlMappings -->
     <mapping uuid="3f2269d9-40c7-4022-bc5b-913dfbbc6cdc" name="@localhost Mapping">
+      <!-- 定义一个映射，uuid为3f2269d9-40c7-4022-bc5b-913dfbbc6cdc，名称为@localhost Mapping -->
       <data-sources db="52ce0e2c-1ca8-4087-a535-1632d84f6e81" ddl="7ee42c98-c0b3-46e7-9153-4802360edee6" />
+      <!-- 定义数据源，数据库为52ce0e2c-1ca8-4087-a535-1632d84f6e81，DDL为7ee42c98-c0b3-46e7-9153-4802360edee6 -->
     </mapping>
   </component>
 </project>

.idea/sqldialects.xml

@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义一个项目，版本号为4 -->
 <project version="4">
+  <!-- 定义一个组件，名称为SqlDialectMappings -->
   <component name="SqlDialectMappings">
+    <!-- 定义一个文件，URL为PROJECT，方言为MySQL -->
     <file url="PROJECT" dialect="MySQL" />
   </component>
 </project>

.idea/uiDesigner.xml

@@ -1,123 +1,200 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <!-- 定义项目版本 -->
   <component name="Palette2">
+    <!-- 定义调色板组件 -->
     <group name="Swing">
+      <!-- 定义Swing组件组 -->
       <item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.svg" removable="false" auto-create-binding="false" can-attach-label="false">
+        <!-- 定义水平间距组件 -->
         <default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.svg" removable="false" auto-create-binding="false" can-attach-label="false">
+        <!-- 定义垂直间距组件 -->
         <default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.svg" removable="false" auto-create-binding="false" can-attach-label="false">
+        <!-- 定义面板组件 -->
         <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.svg" removable="false" auto-create-binding="false" can-attach-label="true">
+        <!-- 定义滚动面板组件 -->
         <default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义按钮组件 -->
         <default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
+        <!-- 定义默认约束 -->
         <initial-values>
+          <!-- 定义初始值 -->
           <property name="text" value="Button" />
+          <!-- 定义按钮文本 -->
         </initial-values>
       </item>
       <item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义单选按钮组件 -->
         <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
+        <!-- 定义默认约束 -->
         <initial-values>
+          <!-- 定义初始值 -->
           <property name="text" value="RadioButton" />
+          <!-- 定义单选按钮文本 -->
         </initial-values>
       </item>
       <item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义复选框组件 -->
         <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
+        <!-- 定义默认约束 -->
         <initial-values>
+          <!-- 定义初始值 -->
           <property name="text" value="CheckBox" />
+          <!-- 定义复选框文本 -->
         </initial-values>
       </item>
       <item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.svg" removable="false" auto-create-binding="false" can-attach-label="false">
+        <!-- 定义标签组件 -->
         <default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
+        <!-- 定义默认约束 -->
         <initial-values>
+          <!-- 定义初始值 -->
           <property name="text" value="Label" />
+          <!-- 定义标签文本 -->
         </initial-values>
       </item>
       <item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
+        <!-- 定义文本框组件 -->
         <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="-1" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
+        <!-- 定义密码框组件 -->
         <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="-1" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
+        <!-- 定义格式化文本框组件 -->
         <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="-1" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.svg" removable="false" auto-create-binding="true" can-attach-label="true">
+        <!-- 定义文本区域组件 -->
         <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="50" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.svg" removable="false" auto-create-binding="true" can-attach-label="true">
+        <!-- 定义文本面板组件 -->
         <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="50" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.svg" removable="false" auto-create-binding="true" can-attach-label="true">
+        <!-- 定义编辑面板组件 -->
         <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="50" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.svg" removable="false" auto-create-binding="true" can-attach-label="true">
+        <!-- 定义组合框组件 -->
         <default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义表格组件 -->
         <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="50" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义列表组件 -->
         <default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="50" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义树组件 -->
         <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <!-- 定义默认约束 -->
           <preferred-size width="150" height="50" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义选项卡面板组件 -->
         <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
+          <!-- 定义默认约束 -->
           <preferred-size width="200" height="200" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.svg" removable="false" auto-create-binding="false" can-attach-label="false">
+        <!-- 定义分割面板组件 -->
         <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
+          <!-- 定义默认约束 -->
           <preferred-size width="200" height="200" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.svg" removable="false" auto-create-binding="true" can-attach-label="true">
+        <!-- 定义微调器组件 -->
         <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义滑块组件 -->
         <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.svg" removable="false" auto-create-binding="false" can-attach-label="false">
+        <!-- 定义分隔符组件 -->
         <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义进度条组件 -->
         <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.svg" removable="false" auto-create-binding="false" can-attach-label="false">
+        <!-- 定义工具栏组件 -->
         <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
+          <!-- 定义默认约束 -->
           <preferred-size width="-1" height="20" />
+          <!-- 定义首选大小 -->
         </default-constraints>
       </item>
       <item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.svg" removable="false" auto-create-binding="false" can-attach-label="false">
+        <!-- 定义工具栏分隔符组件 -->
         <default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
+        <!-- 定义默认约束 -->
       </item>
       <item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.svg" removable="false" auto-create-binding="true" can-attach-label="false">
+        <!-- 定义滚动条组件 -->
         <default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
+        <!-- 定义默认约束 -->
       </item>
     </group>
   </component>

.idea/vcs.xml

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

README.md

@@ -1,108 +1,18 @@
-# spring-boot-online-exam
+ ResultVO<RecordDetailVo> getExamRecordDetail(@PathVariable String recordId) {
-
+        // 定义返回结果
-> 在线Demo预览，http://129.211.88.191 ，账户分别是admin、teacher、student，密码是admin123。视频讲解代码：https://www.bilibili.com/video/BV1FP4y1L7xt/
+        ResultVO<RecordDetailVo> resultVO;
-
+        try {
-> 好消息！！！一个小伙伴做了Python实现，欢迎大家star：https://github.com/xingxingzaixian/django-drf-online-exam
+            // 调用examService获取考试记录详情
-
+            RecordDetailVo recordDetailVo = examService.getRecordDetail(recordId);
-## 1.快速体验
+            // 返回成功结果
-### 1.1 事先准备
+            resultVO = new ResultVO<>(0, "获取考试记录详情成功", recordDetailVo);
-> clone代码并进入代码路径
+        } catch (Exception e) {
-
+            // 打印异常信息
-```shell
+            e.printStackTrace();
-git clone git@github.com:lsgwr/spring-boot-online-exam.git
+            // 返回失败结果
-cd spring-boot-online-exam
+            resultVO = new ResultVO<>(-1, "获取考试记录详情失败", null);
-```
+        }
-
+        // 返回结果
-下面按照Linux和windows说明快速搭建的方法
+        return resultVO;
-### 1.2 Linux
+    }
-执行代码下的脚本start.sh即可
+}
-
-然后访问 http://ip:80 即可访问自己搭建的考试系统
-
-### 1.3 windows
-+ 1.安装JDK，推荐JDK8
-+ 2.从官方仓库下载发布的jar包，建议选择最新版：https://github.com/lsgwr/spring-boot-online-exam/releases
-+ 3.安装MySQL，创建数据库exam，并初始化密码为aA111111，导入doc/sql/exam.sql文件来创建数据库
-+ 4.启动jar包：`java -jar exam.jar`
-+ 5.访问：http://ip:9527 即可访问自己搭建的考试系统
-
-## 2.介绍
-基于springboot的在线考试系统
-
-### 2.1 功能简介
-
-+ 支持单选题、多选题、判断题
-+ 支持学生(student)、教师(teacher)、管理员(admin)三种角色
-    + 学生：参加考试和查看我的考试
-    + 教师：学生的所有权限+创建/编辑题目+创建/编辑考试
-    + 管理员：教师的所有权限+管理用户
-
-### 2.3 软件架构
-
-> 前后端分离，前段组件化，方便二次开发；后端
-
-+ 后端采用SpringBoot+JPA++Swagger2+JWT校验,根据不同用户的权限返回给用户不同的数据
-+ 后端采用Vue+AntDesign,组件化拆分，封装了很多年公共组件，方便维护和二次开发
-
-### 2.3 使用教程
-
-+ 1.下载代码
-  ```shell
-  git clone https://github.com/19920625lsg/spring-boot-online-exam.git
-  ```
-+ 2.初始化数据库
-  > 安装mysql的步骤这里省略，网上的教程很多。安装好mysql后，新建exam数据库，密码和`spring-boot-online-exam/backend/exam/src/main/resources/application.yml`的`password: xxxxxx`保持一致，然后导入`spring-boot-online-exam/doc/sql/exam.sql`
-+ 3.启动后端
-  > 打开`spring-boot-online-exam/backend/exam`这个Maven项目，可以在IDE里启动或者执行`mvn install`生成jar包启动
-+ 4.启动前端
-    + 进入到前端代码路径 `cd spring-boot-online-exam/frontend/exam/`
-    + 安装依赖 `npm install`
-    + 启动前端 `npm run serve`
-+ 5.部署完毕，查看效果
-  > 打开 http://localhost:8000 或者 http://本机ip:8000 即可查看演示效果
-
-## 3.功能图示
-
-+ 1.管理题目
-    + 1.1 题目列表
-      > ![题目查看](doc/images/question_list.png)
-    + 1.2 题目创建
-      > ![题目创建](doc/images/question_create.png)
-    + 1.3 题目更新
-      > ![题目更新](doc/images/question_update.png)
-+ 2.考试管理
-    + 2.1 考试列表
-      > ![考试查看](doc/images/exam_list.png)
-    + 2.2 考试创建
-      > ![考试创建](doc/images/exam_create.png)
-    + 2.3 考试更新(`还有点小bug，开发中`)
-      > ![考试更新](doc/images/exam_update.png)
-+ 3.我的考试
-    + 3.1 参加考试
-      > 在"考试列表"模块点击自己想参加的考试卡片即可
-      > ![参加考试1](doc/images/exam_join.png)
-      > ![参加考试2](doc/images/exam_join2.png)
-    + 3.2 考试记录查看
-      > ![考试记录查看](doc/images/exam_detail.png)
-
-## 4.参与贡献
-
-1.  Fork 本仓库
-2.  新建 exam_xxx 分支
-3.  提交代码
-4.  新建 Pull Request
-
-## 5.Todo
-+ `√`0.修复issue提地bug：题目创建失败
-+ `√`1.考试详情编辑
-+ 2.支持题目和考试的删除`删除的话比较麻烦，先不做了，最好是弄个visible字段，不实际删除，要不后面有些关联数据找不到就不好了`
-  > 如果题目有关联的考试则必须先删除对应的考试，反过来删除考试则不用删除题目
-+ 3.图片改成base64存到数据库中
-+ 4.题干和选项支持富文本
-+ 5.支持批量导入题目
-+ 6.新增用户管理、学科管理功能
-+ 7.老师能考到所有学生的成绩以及考试的统计信息
-+ 8.更多的数据分析功能
-+ 9.支持容器化一键式部署(编好Dockerfile)
-+ 10.支持移动端，最好用uniapp做
-+ ......抓紧做吧，争取每周末做一点......

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

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

backend/src/main/java/lsgwr/exam/config/CORSConf.java

@@ -16,15 +16,22 @@ import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 @Slf4j
 public class CORSConf {
 
+    // 创建一个 WebMvcConfigurer Bean
     @Bean
     public WebMvcConfigurer corsConfigurer() {
         return new WebMvcConfigurer() {
+            // 重写 addCorsMappings 方法
             @Override
             public void addCorsMappings(CorsRegistry registry) {
+                // 记录初始化 CORSConfiguration 配置
                 log.info("初始化 CORSConfiguration 配置");
+                // 添加映射
                 registry.addMapping("/**")
+                        // 允许所有请求头
                         .allowedHeaders("*")
+                        // 允许所有请求方法
                         .allowedMethods("*")
+                        // 允许所有请求来源
                         .allowedOrigins("*");
             }
         };

backend/src/main/java/lsgwr/exam/config/IntercepterConfig.java

@@ -12,25 +12,18 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
-/**
- * 拦截器配置类
- */
 @Configuration
 public class IntercepterConfig implements WebMvcConfigurer {
 
-    /**
+    // 注入LoginInterceptor
-     * 注入LoginInterceptor
-     */
     @Autowired
     private LoginInterceptor loginInterceptor;
 
-    /**
+    // 添加拦截器
-     * 添加拦截器
-     */
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         // 拦截user下的api
         registry.addInterceptor(loginInterceptor).addPathPatterns("/api/**");
     }
 
-}
+}

backend/src/main/java/lsgwr/exam/config/ServletConfig.java

@@ -7,22 +7,16 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpStatus;
 
-/**
- * Servlet配置类
- */
 @Configuration
 public class ServletConfig {
-    /**
+    // 创建一个WebServerFactoryCustomizer bean，用于自定义WebServerFactory
-     * 创建一个WebServerFactoryCustomizer bean，用于自定义Web服务器的工厂
-     * @return WebServerFactoryCustomizer<ConfigurableWebServerFactory>
-     */
     @Bean
     public WebServerFactoryCustomizer<ConfigurableWebServerFactory> webServerFactoryCustomizer() {
-        // 返回一个lambda表达式，用于自定义Web服务器的工厂
+        // 返回一个lambda表达式，用于自定义WebServerFactory
         return factory -> {
             // 创建一个ErrorPage对象，用于处理404错误
             ErrorPage error404Page = new ErrorPage(HttpStatus.NOT_FOUND, "/");
-            // 将ErrorPage对象添加到Web服务器的工厂中
+            // 将ErrorPage对象添加到WebServerFactory中
             factory.addErrorPages(error404Page);
         };
     }

backend/src/main/java/lsgwr/exam/config/Swagger2Config.java

@@ -23,48 +23,54 @@ import springfox.documentation.swagger2.annotations.EnableSwagger2;
 import java.util.ArrayList;
 import java.util.List;
 
-/**
- * Swagger2配置类
- */
 @Configuration
 @EnableSwagger2
 public class Swagger2Config {
-    /**
-     * 创建Docket bean
-     * @return Docket
-     */
     @Bean
     public Docket api() {
+
+        // 创建一个参数构建器
         ParameterBuilder ticketPar = new ParameterBuilder();
+        // 创建一个参数集合
         List<Parameter> pars = new ArrayList<>();
+        // 设置参数名
         ticketPar.name("Access-Token").description("Rest接口权限认证token,无需鉴权可为空")
+                // 设置参数类型
                 .modelRef(new ModelRef("string")).parameterType("header")
-                //header中的ticket参数非必填，传空也可以
+                // header中的ticket参数非必填，传空也可以
                 .required(false).build();
-        //根据每个方法名也知道当前方法在设置什么参数
+        // 根据每个方法名也知道当前方法在设置什么参数
         pars.add(ticketPar.build());
 
         return new Docket(DocumentationType.SWAGGER_2)
+                // 设置文档信息
                 .apiInfo(apiInfo())
+                // 选择要扫描的接口
                 .select()
                 // 自行修改为自己的包路径
                 .apis(RequestHandlerSelectors.basePackage("lsgwr"))
+                // 选择所有的路径
                 .paths(PathSelectors.any())
+                // 构建Docket
                 .build()
+                // 设置全局参数
                 .globalOperationParameters(pars);
     }
 
-    /**
-     * 创建ApiInfo对象
-     * @return ApiInfo
-     */
     private ApiInfo apiInfo() {
+        // 创建ApiInfo对象
         return new ApiInfoBuilder()
+                // 设置API标题
                 .title("online exam by springboot")
+                // 设置API描述
                 .description("在线考试系统 by 梁山广 at 2021")
+                // 设置API服务条款URL
                 .termsOfServiceUrl("https://github.com/19920625lsg/spring-boot-online-exam")
+                // 设置API版本
                 .version("2.0")
+                // 设置API联系人信息
                 .contact(new Contact("liangshanguang", "https://github.com/lsgwr/spring-boot-online-exam", "liangshanguang2@gmail.com"))
+                // 构建ApiInfo对象
                 .build();
     }
-}
+}

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

@@ -1,6 +1,9 @@
-/**
+/***********************************************************
- * @Description : 这是一个REST控制器,处理与考试、问题和考试记录相关的HTTP请求,它包括创建、更新和检索考试和问题的方法,以及处理用户提交和评分。
+ * @Description : 考试服务
- */
+ * @author      : 梁山广(Laing Shan Guang)
+ * @date        : 2019-05-28 08:04
+ * @email       : liangshanguang2@gmail.com
+ ***********************************************************/
 package lsgwr.exam.controller;
 
 import lsgwr.exam.entity.Exam;
@@ -26,7 +29,10 @@ public class ExamController {
     private ExamService examService;
 
     /**
-     * @Description: 使用examService.getQuestionAll()获取数据,并将其包装在ResultVO对象中,用于获取所有考试列表
+     * @Description: 使用examService.getQuestionAll()获取数据,
+     *
+     * 并将其包装在ResultVO对象中,用于获取所有考试列表
+     *
      * @ApiOperation注解用于描述API操作,它将显示在SwaggerUI中
      */
     @GetMapping("/question/all")
@@ -70,10 +76,20 @@ ResultVO<List<QuestionVo>> getQuestionAll() {
 
     /**
      * 创建问题
-     * @Description: 从请求体中获取一个QuestionCreateSimplifyVo对象，将其属性复制到QuestionCreateVo，设置创建者的ID，并使用examService.questionCreate()创建问题。
+     * @Description: 从请求体中获取一个QuestionCreateSimplifyVo对象，
-     * @param questionCreateSimplifyVo 从请求体中获取的QuestionCreateSimplifyVo对象
+     * 将其属性复制到QuestionCreateVo，设置创建者的ID，
+     *
+     * 并使用examService.questionCreate()创建问题。
+     *
+     * @param questionCreateSimplifyVo
+     *
+     * 从请求体中获取的QuestionCreateSimplifyVo对象
+     *
      * @param request HttpServletRequest对象，用于获取当前用户的ID
+     *
      * @return ResultVO<String> 对象，包含操作结果信息
+     *
+     *
      */
     @PostMapping("/question/create")
     @ApiOperation("创建问题")
@@ -100,7 +116,10 @@ ResultVO<List<QuestionVo>> getQuestionAll() {
     }
 
     /**
-     * @Description: 获取全部问题列表,使用examService.getSelections()获取数据，并将其包装在ResultVO对象中
+     * @Description: 获取全部问题列表,
+     *
+     * 使用examService.getSelections()获取数据，并将其包装在ResultVO对象中
+     *
      * @return ResultVO<QuestionAllVo> 对象，包含问题列表
      */
     @GetMapping("/question/selection")
@@ -118,12 +137,6 @@ ResultVO<QuestionSelectionVo> getSelections() {
             return new ResultVO<>(-1, "获取问题分类选项失败", null);
         }
     }
-
-    /**
-     * @Description: 使用examService.getQuestionDetail(id)获取数据,并将其包装在ResultVO对象中,用于获取全部问题列表
-     * @param id 问题id
-     * @return ResultVO<QuestionDetailVo> 对象，包含问题详情
-     */
     @GetMapping("/question/detail/{id}")
     @ApiOperation("根据问题的id获取问题的详细信息")
     ResultVO<QuestionDetailVo> getQuestionDetail(@PathVariable String id) {
@@ -138,17 +151,11 @@ ResultVO<QuestionSelectionVo> getSelections() {
         } catch (Exception e) {
             // 如果获取失败，则打印异常信息，并返回ResultVO对象，状态码为-1，提示信息为"获取问题详情失败"，数据为null。
             e.printStackTrace();
-            // 创建一个表示获取失败的ResultVO对象，状态码设置为 -1，表示获取操作失败，消息设置为"获取问题详情失败"，数据部分设置为null
             resultVO = new ResultVO<>(-1, "获取问题详情失败", null);
         }
         // 返回ResultVO对象。
         return resultVO;
     }
-
-    /**
-     * @Description: 使用examService.getExamAll()获取数据,并将其包装在ResultVO对象中,用于获取全部考试列表
-     * @return ResultVO<QuestionDetailVo> 对象，包含考试列表详情
-     */
     @GetMapping("/all")
     @ApiOperation("获取全部考试的列表")
     ResultVO<List<ExamVo>> getExamAll() {
@@ -167,11 +174,6 @@ ResultVO<QuestionSelectionVo> getSelections() {
         }
         return resultVO;
     }
-
-    /**
-     * @Description: 使用examService.getExamQuestionTypeList()获取数据,并将其包装在ResultVO对象中,用于获取问题列表
-     * @return ResultVO<ExamQuestionTypeVo> 对象，包含问题列表
-     */
     @GetMapping("/question/type/list")
     @ApiOperation("获取问题列表，按照单选、多选和判断题分类返回")
     ResultVO<ExamQuestionTypeVo> getExamQuestionTypeList() {
@@ -191,37 +193,27 @@ ResultVO<QuestionSelectionVo> getSelections() {
         return resultVO;
     }
 
-    /**
-     * @Description: 使用examService.createExam()获取数据,并将其包装在ResultVO对象中,用于获取问题列表
-     * @param examCreateVo 前端传过来的参数
-     * @param request 获取用户id
-     * @return ResultVO<Exam> 对象，包含考试信息
-     */
     @PostMapping("/create")
     @ApiOperation("创建考试")
     ResultVO<Exam> createExam(@RequestBody ExamCreateVo examCreateVo, HttpServletRequest request) {
-        // 定义一个ResultVO类型的变量，用于存放最终要返回给客户端的结果对象，其泛型参数指定为Exam，表示包含新创建考试相关信息的结果封装
+        // 从前端传参数过来，在这里完成考试的入库。
         ResultVO<Exam> resultVO;
-        // 从HttpServletRequest对象中获取用户ID信息，通常这个用户ID是在请求处理的前置环节（比如拦截器中）设置到请求属性中的，用于标识创建这个考试的用户是谁
+        // 获取当前用户的id。
         String userId = (String) request.getAttribute("user_id");
         try {
-            // 调用ExamService的create方法，将创建考试的视图对象（examCreateVo）和获取到的用户ID传递进去，由服务层实现将考试记录数据保存到数据库等具体的创建逻辑操作，返回创建好的Exam对象代表新创建的考试信息
+            // 调用examService的create方法，将examCreateVo和userId作为参数传入，创建考试。
             Exam exam = examService.create(examCreateVo, userId);
-            // 如果创建成功，创建一个表示成功的ResultVO对象，状态码设置为0，表示创建操作成功，消息设置为"创建考试成功"，并将创建好的考试对象放入ResultVO对象中返回给客户端
+            // 创建一个ResultVO对象，将创建成功的考试信息返回。
             resultVO = new ResultVO<>(0, "创建考试成功", exam);
         } catch (Exception e) {
+            // 捕获异常，打印异常信息，并创建一个ResultVO对象，将创建失败的考试信息返回。
             e.printStackTrace();
-            // 如果在创建过程中出现异常，创建一个表示创建失败的ResultVO对象，状态码设置为 -1，表示创建操作失败，消息设置为"创建考试失败"，数据部分设置为null
             resultVO = new ResultVO<>(-1, "创建考试失败", null);
         }
+        // 返回ResultVO对象。
         return resultVO;
     }
-    /**
+
-     * @Description: 使用examService.updateExam()获取数据,并将其包装在ResultVO对象中,用于更新考试
-     * @param examVo 前端传过来的参数
-     * @param request 获取用户id
-     * @return
-     */
     @PostMapping("/update")
     @ApiOperation("更新考试")
     ResultVO<Exam> updateExam(@RequestBody ExamVo examVo, HttpServletRequest request) {
@@ -242,9 +234,13 @@ ResultVO<QuestionSelectionVo> getSelections() {
         }
         return resultVO;
     }
+
     /**
      * @Description: 获取考试列表，适配前端卡片列表
-     * @return ResultVO<List<ExamCardVo>> 对象，包含考试列表卡片信息
+     *
+     * @return ResultVO<List<ExamCardVo>> 对象，
+     *
+     * 包含考试列表卡片信息
      */
     @GetMapping("/card/list")
     @ApiOperation("获取考试列表，适配前端卡片列表")
@@ -254,115 +250,127 @@ ResultVO<QuestionSelectionVo> getSelections() {
         try {
             // 调用examService的getExamCardList方法获取考试列表卡片。
             List<ExamCardVo> examCardVoList = examService.getExamCardList();
-            // 如果获取数据成功，创建一个表示成功的ResultVO对象，状态码设置为0，表示获取考试列表卡片成功，消息设置为"获取考试列表卡片成功"，并将获取到的考试卡片列表数据放入ResultVO对象中，以便返回给客户端进行展示。
+            // 如果获取成功，则返回成功的结果。
             resultVO = new ResultVO<>(0, "获取考试列表卡片成功", examCardVoList);
         } catch (Exception e) {
             // 如果获取失败，则打印异常信息，并返回失败的结果。
             e.printStackTrace();
-            // 创建一个表示获取失败的ResultVO对象，状态码设置为 -1，表示获取考试列表卡片失败，消息可根据业务实际情况设置为相应的提示语，数据部分设置为null，因为没有成功获取到有效的考试卡片列表数据。
             resultVO = new ResultVO<>(-1, "获取考试列表卡片失败", null);
         }
+        // 返回结果
         return resultVO;
     }
+
     /**
      * @Description: 根据考试的id，获取考试详情
+     *
      * @param id 考试id
+     *
      * @return ResultVO<ExamDetailVo> 对象，包含考试详情信息
      */
     @GetMapping("/detail/{id}")
     @ApiOperation("根据考试的id，获取考试详情")
     ResultVO<ExamDetailVo> getExamDetail(@PathVariable String id) {
-        // 根据id获取考试详情，先定义一个用于存放最终要返回给客户端的ResultVO<ExamDetailVo>类型的结果对象，后续根据查询数据的情况进行赋值操作。
+        // 根据id获取考试详情。
         ResultVO<ExamDetailVo> resultVO;
         try {
-            // 调用ExamService的getExamDetail方法，将接收到的考卷唯一标识符（id）传递进去，由服务层实现从数据库或者其他数据源根据该ID查询对应考卷详细信息的逻辑，返回一个ExamDetailVo对象代表该考卷的所有详细信息。
             ExamDetailVo examDetail = examService.getExamDetail(id);
-            // 如果获取详细信息成功，创建一个表示成功的ResultVO对象，状态码设置为0，表示获取考试详情成功，消息设置为"获取考试详情成功"，并将获取到的考卷详细信息对象放入ResultVO对象中，以便返回给客户端进行展示。
             resultVO = new ResultVO<>(0, "获取考试详情成功", examDetail);
         } catch (Exception e) {
-            // 如果在获取考卷详细信息的过程中出现异常，创建一个表示获取失败的ResultVO对象，状态码设置为 -1，表示获取考试详情失败，消息可根据业务实际情况设置为相应的提示语，数据部分设置为null，因为没有成功获取到有效的考卷详细信息。
             resultVO = new ResultVO<>(-1, "获取考试详情失败", null);
         }
         return resultVO;
     }
+
     /**
-     * @Description: 使用examService.finishExam获取数据,并将其包装在ResultVO对象中,用于考试判分
+     * @Description: 使用examService.finishExam获取数据,
+     *
+     * 并将其包装在ResultVO对象中,用于考试判分
      * @param examId 考试id
+     *
      * @param answersMap 用户提交的答案
+     *
      * @param request 获取用户id
      * @return
      */
     @PostMapping("/finish/{examId}")
     @ApiOperation("根据用户提交的答案对指定id的考试判分")
+    // 完成考试
     ResultVO<ExamRecord> finishExam(@PathVariable String examId, @RequestBody HashMap<String, List<String>> answersMap, HttpServletRequest request) {
-        // 定义一个用于存放结果的ResultVO<ExamRecord>类型的数据结构，后续根据评分操作的成功与否以及获取到的相关数据进行赋值，用于最终返回给客户端展示评分结果。
+        // 定义返回结果。
         ResultVO<ExamRecord> resultVO;
         try {
-            // 拦截器里设置上的用户id，从HttpServletRequest对象中获取用户ID属性值，该用户ID用于标识当前提交答案并进行评分的用户，是后续业务逻辑处理（如记录答题记录归属、判断是否有权限答题等）的重要依据。
+            // 拦截器里设置上的用户id。
             String userId = (String) request.getAttribute("user_id");
-            // 下面根据用户提交的信息进行判分，返回用户的得分情况，调用ExamService的judge方法，传入获取到的用户ID、考试唯一标识符（examId）以及用户提交的答案集合（answersMap），由服务层实现具体的评分逻辑，比如对比答案、计算得分等操作，并返回一个ExamRecord对象，包含了评分后的成绩记录等详细信息。
+            // 下面根据用户提交的信息进行判分,返回用户的得分情况。
             ExamRecord examRecord = examService.judge(userId, examId, answersMap);
-            // 封装成绩记录到最终结果中，创建一个表示评分成功的ResultVO对象，状态码设置为0，表示考卷提交（评分）成功，消息设置为"考卷提交成功"，并将包含成绩记录的ExamRecord对象放入ResultVO对象中，以便返回给客户端展示评分结果。
+            // 返回结果。
-            resultVO = new ResultVO<>(0, "考卷提交成功", examRecord);// 封装成绩记录到最终结果中
+            resultVO = new ResultVO<>(0, "考卷提交成功", examRecord);
         } catch (Exception e) {
-            // 如果在评分过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，查看是答案解析出错还是其他业务逻辑环节出现的错误导致评分失败。
             e.printStackTrace();
-            // 创建一个表示评分失败的ResultVO对象，状态码设置为 -1，表示考卷提交（评分）失败，消息可根据业务实际情况设置为相应的提示语，数据部分设置为null，因为没有成功获取到有效的评分成绩记录。
+            // 返回错误结果。
             resultVO = new ResultVO<>(-1, "考卷提交失败", null);
         }
         return resultVO;
     }
+
     /**
-     * @Description: 使用examService.getExamRecordList获取数据,并将其包装在ResultVO对象中,用于获取当前用户的考试记录
+     * @Description: 使用examService.getExamRecordList获取数据,
+     * 并将其包装在ResultVO对象中,用于获取当前用户的考试记录
+     *
      * @param request 获取用户id
-     * @return ResultVO<List<ExamRecordVo>> 返回一个包含考试记录列表的ResultVO对象，如果发生异常，则返回一个包含错误信息的ResultVO对象。
+     *
+     * @return ResultVO<List<ExamRecordVo>>
+     *
+     *     返回一个包含考试记录列表的ResultVO对象，如果发生异常，则返回一个包含错误信息的ResultVO对象。
      */
     @GetMapping("/record/list")
     @ApiOperation("获取当前用户的考试记录")
+    // 获取考试记录列表。
     ResultVO<List<ExamRecordVo>> getExamRecordList(HttpServletRequest request) {
-        // 定义一个用于存放结果的ResultVO<List<ExamRecordVo>>类型的数据结构，后续根据查询用户考试记录操作的成功与否以及获取到的相关数据进行赋值，用于最终返回给客户端展示查询结果。
         ResultVO<List<ExamRecordVo>> resultVO;
         try {
-            // 拦截器里设置上的用户id，从HttpServletRequest对象中获取用户ID属性值，该用户ID用于明确要查询其考试记录的目标用户，是服务层准确获取对应数据的关键依据。
+            // 拦截器里设置上的用户id。
             String userId = (String) request.getAttribute("user_id");
-            // 下面根据用户账号拿到他（她）所有的考试信息，注意要用VO封装下，调用ExamService的getExamRecordList方法，传入获取到的用户ID，由服务层实现从数据库或者其他数据源获取该用户所有历史考试记录数据的逻辑，并将其整理封装成List<ExamRecordVo>类型的列表返回，每个ExamRecordVo对象包含了如时间、得分等详细信息。
+            // 下面根据用户账号拿到他(她所有的考试信息)，注意要用VO封装下。
             List<ExamRecordVo> examRecordVoList = examService.getExamRecordList(userId);
-            // 封装查询得到的信息到最终结果中，创建一个表示获取成功的ResultVO对象，状态码设置为0，表示获取考试记录成功，消息设置为"获取考试记录成功"，并将获取到的用户考试记录列表数据放入ResultVO对象中，以便返回给客户端展示历史考试记录情况。
+            resultVO = new ResultVO<>(0, "获取考试记录成功", examRecordVoList);
-            resultVO = new ResultVO<>(0, "获取考试记录成功", examRecordVoList);//封装查询得到的信息到最终结果中；
         } catch (Exception e) {
-            // 如果在获取用户考试记录数据的过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，查看是数据源查询出错还是数据封装等环节出现的错误导致获取失败。
             e.printStackTrace();
-            // 创建一个表示获取失败的ResultVO对象，状态码设置为 -1，表示获取考试记录失败，消息可根据业务实际情况设置为相应的提示语，数据部分设置为null，因为没有成功获取到有效的用户考试记录数据。
             resultVO = new ResultVO<>(-1, "获取考试记录失败", null);
         }
-        return resultVO;//返回封装好的 数据结构
+        return resultVO;
     }
+
     /**
-     * @Description: 使用examService.getExamRecordDetail获取数据,并将其包装在ResultVO对象中,用于获取指定id的考试记录详情
+     * @Description: 使用examService.getExamRecordDetail获取数据,
+     *
+     * 并将其包装在ResultVO对象中,用于获取指定id的考试记录详情
+     *
      * @param recordId 考试记录id
-     * @return ResultVO<RecordDetailVo> 返回一个包含考试记录详情的ResultVO对象，如果发生异常，则返回一个包含错误信息的ResultVO对象。
+     *
+     * @return ResultVO<RecordDetailVo>
+     *     返回一个包含考试记录详情的ResultVO对象，
+     *
+     *     如果发生异常，则返回一个包含错误信息的ResultVO对象。
      */
     @GetMapping("/record/detail/{recordId}")
     @ApiOperation("根据考试记录id获取考试记录详情")
     ResultVO<RecordDetailVo> getExamRecordDetail(@PathVariable String recordId) {
-        // 定义一个用于存放结果的ResultVO<RecordDetailVo>类型的数据结构，后续根据查询测验详细情况操作的成功与否以及获取到的相关数据进行赋值，用于最终返回给客户端展示查询结果。
+        // 定义返回结果。
         ResultVO<RecordDetailVo> resultVO;
         try {
-            // 调用ExamService的getRecordDetail方法，将接收到的测验记录唯一标识符（recordId）传递进去，由服务层实现从数据库或者其他数据源根据该ID查询对应测验详细信息的逻辑，返回一个RecordDetailVo对象代表该次测验的所有详细信息。
+            // 调用examService获取考试记录详情。
             RecordDetailVo recordDetailVo = examService.getRecordDetail(recordId);
-            // 封装查询得到的信息到最终结果中，创建一个表示获取成功的ResultVO对象，状态码设置为0，表示获取考试记录详情成功，消息设置为"获取考试记录详情成功"，并将获取到的测验详细信息对象放入ResultVO对象中，以便返回给客户端展示该次测验的详细情况。
+            // 返回成功结果。
-            resultVO = new ResultVO<>(0, "获取考试记录详情成功", recordDetailVo);//封装查询得到的信息到最终结果中；
+            resultVO = new ResultVO<>(0, "获取考试记录详情成功", recordDetailVo);
         } catch (Exception e) {
-            // 如果在获取测验详细信息的过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，查看是数据源查询出错还是数据解析等环节出现的错误导致获取失败。
+            // 打印异常信息。
             e.printStackTrace();
-            // 创建一个ResultVO对象，表示操作失败
+            // 返回失败结果。
-            // 状态码设置为-1，表示获取考试记录详情失败
-            // 消息设置为"获取考试记录详情失败"
-            // 由于查询失败，详细信息对象设置为null
             resultVO = new ResultVO<>(-1, "获取考试记录详情失败", null);
         }
-        // 返回封装好的ResultVO对象给客户端
+        // 返回结果。
-        // 客户端可以根据状态码和消息判断操作是否成功，并根据详细信息对象获取测验的详细记录信息
         return resultVO;
     }
 }

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

@@ -15,13 +15,22 @@ import org.springframework.web.multipart.MultipartFile;
 import java.io.IOException;
 
 /***********************************************************
+ *
  * @note      : 文件上传下载的接口,由于Swagger的问题导致在SwaggerUI
- *              里测试不成功，实际上前端是完全没有问题的
+ *
+ *              里测试不成功，
+ *              实际上前端是完全没有问题的
  * @author    :  梁山广
- *  * 为了支持Ajax请求和响应，最简单的解决方案返回一个ResponseEntity。
+ *
- *  * 以下示例演示了上传文件的三种可能方式：
+ *  * 为了支持Ajax请求和响应，
- *  * 1. 单文件上传 - `MultipartFile`
+ *
- *  * 2. 多文件上传 - `MultipartFile []`
+ *  最简单的解决方案返回一个ResponseEntity。
+ *  * 以下示例演示了上传文件
+ *  的三种可能方式：
+ *  * 1. 单文件上传
+ *  - `MultipartFile`
+ *  * 2. 多文件上传
+ *  - `MultipartFile []`
  *  * 3. 将文件上传到模型 - `@ModelAttribute`
  * @version   : V1.0 at 2018/7/16 20:43
  ***********************************************************/
@@ -32,87 +41,63 @@ import java.io.IOException;
 public class UploadDownloadController {
 
 //    @Autowired
+
 //    AITestConfig aiTestConfig;
+
 //
 //    @PostMapping("/upload/single")
+
 //    @ApiOperation("单文件上传")
+
 //    public String uploadFile(@RequestParam("file") MultipartFile uploadfile) {
 //        return FileTransUtil.uploadFile(uploadfile, "/root/" + File.separator + uploadfile.getOriginalFilename());
 //    }
 
-    /**
-     * 单文件上传
-     *
-     * @param dir 目录
-     * @param uploadfile 文件
-     * @return String
-     */
     @ApiOperation("单文件上传,支持同时传入参数")
     @PostMapping("/api/upload/singleAndparas")
-    public String uploadFileSingle(@RequestParam("dir") String dir, @RequestParam("file") MultipartFile uploadfile) {
+    // 单文件上传。
+  public String uploadFileSingle(@RequestParam("dir") String dir, @RequestParam("file") MultipartFile uploadfile) {
+        // 调用FileTransUtil工具类中的uploadFile方法，将上传的文件和目录作为参数传入。
         return FileTransUtil.uploadFile(uploadfile, dir);
     }
 
-    /**
+    // 单文件上传，支持同时传入参数，Model。
-     * 单文件上传，支持同时传入参数，Model
-     *
-     * @param model UploadModel2对象
-     * @return String
-     */
     @ApiOperation("单文件上传,支持同时传入参数,Model")
     @PostMapping("/upload/single/model")
     public String singleUploadFileModel(@ModelAttribute("model") UploadModel2 model) {
+        // 调用FileTransUtil工具类中的uploadFile方法，将上传的文件和目录作为参数传入。
         return FileTransUtil.uploadFile(model.getFile(), model.getDir());
     }
 
-    /**
+    // 多文件上传，支持同时传入参数。
-     * 多文件上传，支持同时传入参数
-     *
-     * @param dir 目录
-     * @param uploadfiles 文件数组
-     * @return String
-     */
     @ApiOperation("多文件上传,支持同时传入参数")
     @PostMapping("upload/multiAndparas")
     public String uploadFileMulti(@RequestParam("dir") String dir, @RequestParam("files") MultipartFile[] uploadfiles) {
+        // 调用FileTransUtil工具类中的uploadFiles方法，将上传的文件数组和目录作为参数传入。
         return FileTransUtil.uploadFiles(uploadfiles, dir);
     }
 
-    /**
+    // 多文件上传，支持同时传入参数。
-     * 多文件上传，支持同时传入参数
-     *
-     * @param model UploadModel对象
-     * @return String
-     */
     @ApiOperation("多文件上传,支持同时传入参数")
     @PostMapping(value = "/upload/multi/model")
     public String multiUploadFileModel(@ModelAttribute(("model")) UploadModel model) {
+        // 调用FileTransUtil工具类中的uploadFiles方法，将上传的文件数组和目录作为参数传入。
         return FileTransUtil.uploadFiles(model.getFiles(), model.getDir());
     }
 
-    /**
+    // Get下载文件
-     * Get下载文件
-     *
-     * @param filePath 文件路径
-     * @return ResponseEntity<InputStreamResource>
-     * @throws IOException 异常
-     */
     @ApiOperation("Get下载文件")
     @GetMapping(value = "/download/get")
     public ResponseEntity<InputStreamResource> downloadFileGet(@RequestParam String filePath) throws IOException {
+        // 调用FileTransUtil工具类中的downloadFile方法，将文件路径作为参数传入。
         return FileTransUtil.downloadFile(filePath);
     }
 
-    /**
+    // Post下载文件
-     * Post下载文件
-     *
-     * @param downloadQo DownloadQo对象
-     * @return ResponseEntity<InputStreamResource>
-     * @throws IOException 异常
-     */
     @ApiOperation("Post下载文件")
     @PostMapping(value = "/download/post")
     public ResponseEntity<InputStreamResource> downloadFilePost(@RequestBody DownloadQo downloadQo) throws IOException {
+        // 调用FileTransUtil工具类中的downloadFile方法，将文件路径作为参数传入。
         return FileTransUtil.downloadFile(downloadQo.getPath());
     }
 }

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

@@ -29,12 +29,6 @@ public class UserController {
     @Autowired
     private UserService userService;
 
-    /**
-     * 注册
-     *
-     * @param registerDTO RegisterDTO对象
-     * @return ResultVO<User>
-     */
     @PostMapping("/register")
     @ApiOperation("注册")
     ResultVO<User> register(@RequestBody RegisterDTO registerDTO) {
@@ -50,12 +44,6 @@ public class UserController {
         return resultVO;
     }
 
-    /**
-     * 根据用户名或邮箱登录,登录成功返回token
-     *
-     * @param loginQo LoginQo对象
-     * @return ResultVO<String>
-     */
     @PostMapping("/login")
     @ApiOperation("根据用户名或邮箱登录,登录成功返回token")
     ResultVO<String> login(@RequestBody LoginQo loginQo) { // 这里不用手机号是因为手机号和用户名难以进行格式区分，而用户名和
@@ -72,12 +60,6 @@ public class UserController {
         return resultVO;
     }
 
-    /**
-     * 获取用户信息
-     *
-     * @param request HttpServletRequest对象
-     * @return ResultVO<UserVo>
-     */
     @GetMapping("/user-info")
     @ApiOperation("获取用户信息")
     // 根据请求获取用户信息
@@ -90,12 +72,6 @@ public class UserController {
         return new ResultVO<>(ResultEnum.GET_INFO_SUCCESS.getCode(), ResultEnum.GET_INFO_SUCCESS.getMessage(), userVo);
     }
 
-    /**
-     * 获取用户的详细信息，包括个人信息页面和操作权限
-     *
-     * @param request HttpServletRequest对象
-     * @return ResultVO<UserInfoVo>
-     */
     @GetMapping("/info")
     @ApiOperation("获取用户的详细信息，包括个人信息页面和操作权限")
         // 获取用户信息的接口
@@ -110,12 +86,6 @@ public class UserController {
         return new ResultVO<>(ResultEnum.GET_INFO_SUCCESS.getCode(), ResultEnum.GET_INFO_SUCCESS.getMessage(), userInfoVo);
     }
 
-    /**
-     * 测试接口
-     *
-     * @param request HttpServletRequest对象
-     * @return String
-     */
     @GetMapping("/test")
     @ApiOperation("测试接口")
     String test(HttpServletRequest request) {
@@ -126,4 +96,4 @@ public class UserController {
         System.out.println("用户名：" + username);
         return "用户id：" + userId + "\n用户名：" + username;
     }
-}
+}

backend/src/main/java/lsgwr/exam/dto/RegisterDTO.java

@@ -8,9 +8,6 @@ package lsgwr.exam.dto;
 
 import lombok.Data;
 
-/**
- * 注册接口参数
- */
 @Data
 public class RegisterDTO {
     /**

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

@@ -11,29 +11,22 @@ import lombok.Data;
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.Id;
-/**
+
- * 动作实体类
- * 它记录了操作的相关信息，包括操作ID、操作名称、操作描述以及是否默认选中
- */
 @Data
 @Entity
 public class Action {
-    /**
+    // 定义一个主键
-     * 动作ID
-     */
     @Id
+    // 自动生成主键
     @GeneratedValue
     private Integer actionId;
-    /**
+
-     * 动作名称
+    // 定义一个动作名称
-     */
     private String actionName;
-    /**
+
-     * 动作描述
+    // 定义一个动作描述
-     */
     private String actionDescription;
-    /**
+
-     * 是否默认选中
+    // 定义一个默认选中状态
-     */
     private Boolean defaultCheck;
 }

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

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

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

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

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

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

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

@@ -12,28 +12,20 @@ import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.Id;
 
-/**
- * 前端页面实体类
- */
 @Data
 @Entity
 public class Page {
-    /**
+    // 定义一个页面ID，使用@Id注解表示该字段为主键，使用@GeneratedValue注解表示该字段自动生成
-     * 页面ID，是主键，通过@Id注解标识，并通过@GeneratedValue注解指定主键生成策略
-     */
     @Id
     @GeneratedValue
     private Integer pageId;
-    /**
+
-     * 页面名称
+    // 定义一个页面名称
-     */
     private String pageName;
-    /**
+
-     * 页面描述
+    // 定义一个页面描述
-     */
     private String pageDescription;
-    /**
+
-     * 页面关联的操作ID列表，以逗号分隔
+    // 定义一个动作ID，用于存储页面上的动作
-     */
     private String actionIds;
 }

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

@@ -14,59 +14,37 @@ import org.hibernate.annotations.DynamicUpdate;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import java.util.Date;
-/**
+
- * 题目实体类，用于存储题目信息
- * 利用注解生成getter/setter方法
- */
 @Data
 @Entity
 @DynamicUpdate
 public class Question {
-    /**
+    // 问题ID
-     * 题目id
-     */
     @Id
     private String questionId;
-    /**
+    // 问题名称
-     * 题目名称
-     */
     private String questionName;
-    /**
+    // 问题分数
-     * 题目分数
-     */
     private Integer questionScore;
-    /**
+    // 问题创建者ID
-     * 题目创建人id
-     */
     private String questionCreatorId;
-    /**
+    // 问题等级ID
-     * 题目难度id
-     */
     private Integer questionLevelId;
-    /**
+    // 问题类型ID
-     * 题目类型id
-     */
     private Integer questionTypeId;
-    /**
+    // 问题分类ID
-     * 题目分类id
-     */
     private Integer questionCategoryId;
-    /**
+    // 问题描述
-     * 题目描述
-     */
     private String questionDescription;
-    /**
+    // 问题选项ID
-     * 题目选项id，用逗号隔开，例如：A,B,C,D
-     */
     private String questionOptionIds;
-    /**
+    // 问题答案选项ID
-     * 题目正确答案选项id，用逗号隔开，例如：A
-     */
     private String questionAnswerOptionIds;
     /**
      * 创建时间, 设计表时设置了自动插入当前时间，无需在Java代码中设置了
      */
 
+    // 创建时间格式化
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date createTime;
 
@@ -74,6 +52,7 @@ public class Question {
      * 更新时间，设计表时设置了自动插入当前时间，无需在Java代码中设置了。
      * 同时@DynamicUpdate注解可以时间当数据库数据变化时自动更新，无需人工维护
      */
+    // 更新时间格式化
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date updateTime;
 }

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

@@ -13,27 +13,24 @@ import lombok.Data;
 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.Id;
-/**
+
- * 题目的类别表，从内容角度划分，比如数学、语文、英语等
- */
 @Data
 @Entity
 public class QuestionCategory {
-    /**
+
-     * 题目类别的id
+    // 主键
-     */
     @Id
+    // 自动生成主键
     @GeneratedValue
+    // 将该字段映射到JSON中的id字段
     @JsonProperty("id")
     private Integer questionCategoryId;
-    /**
+
-     * 题目类别的名称
+    // 将该字段映射到JSON中的name字段
-     */
     @JsonProperty("name")
     private String questionCategoryName;
-    /**
+
-     * 题目类别的描述
+    // 将该字段映射到JSON中的description字段
-     */
     @JsonProperty("description")
     private String questionCategoryDescription;
 }

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

@@ -14,27 +14,19 @@ import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.Id;
 
-/**
- * 题目难度等级实体类，用于表示题目的难度级别信息，如难、中、易等。
- */
 @Entity
 @Data
 public class QuestionLevel {
-    /**
+    // 定义实体类，表示问题等级
-     * 题目难度等级ID，自增
-     */
     @Id
     @GeneratedValue
+    // 定义主键，自动生成
     @JsonProperty("id")
     private Integer questionLevelId;
-    /**
+
-     * 题目难度等级名称，如难、中、易等
-     */
     @JsonProperty("name")
     private String questionLevelName;
-    /**
+
-     * 题目难度等级描述
-     */
     @JsonProperty("description")
     private String questionLevelDescription;
-}
+}

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

@@ -11,23 +11,15 @@ import lombok.Data;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
-/**
+
- * 问题选项实体类
- */
 @Data
 @Entity
 public class QuestionOption {
-    /**
+    // 定义问题选项的ID
-     * 选项的编号，如A、B、C、D
-     */
     @Id
     private String questionOptionId;
-    /**
+    // 定义问题选项的内容
-     * 选项的内容
-     */
     private String questionOptionContent;
-    /**
+    // 定义问题选项的描述
-     * 选项的描述，提供关于选项的额外解释或说明
-     */
     private String questionOptionDescription;
 }

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

@@ -14,28 +14,22 @@ import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.Id;
 
-/**
- * QuestionType类代表了一个实体，用于在数据库中存储问题类型的信息。
- * 它包括问题类型的ID、名称和描述。
- */
 @Data
 @Entity
 public class QuestionType {
-    /**
+    // 主键
-     * 问题类型ID
-     */
     @Id
+    // 自动生成主键
     @GeneratedValue
+    // 将该字段映射到JSON中的id字段
     @JsonProperty("id")
     private Integer questionTypeId;
-    /**
+
-     * 问题类型名称
+    // 将该字段映射到JSON中的name字段
-     */
     @JsonProperty("name")
     private String questionTypeName;
-    /**
+
-     * 问题类型的描述
+    // 将该字段映射到JSON中的description字段
-     */
     @JsonProperty("description")
     private String questionTypeDescription;
-}
+}

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

@@ -13,34 +13,25 @@ import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.Id;
 
-/**
- * 角色实体类
- * 用于表示系统中的角色信息，包括角色的ID、名称、描述和详细信息等
- */
 @Data
 @Entity
 public class Role {
-    /**
+    // 角色ID
-     * 角色ID
-     * @Id标识为主键
-     */
     @Id
     @GeneratedValue
     private Integer roleId;
-    /**
+    // 角色名称
-     * 角色名称
-     */
     private String roleName;
-    /**
+    // 角色描述
-     * 角色描述
-     */
     private String roleDescription;
-    /**
+    // 角色详情
-     * 角色详细信息
-     */
     private String roleDetail;
     /**
+     *
+     *
      * 角色所能访问的页面的主键集合(用-连接起来字符串)
+     *
+     *
      */
     private String rolePageIds;
 }

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

@@ -14,61 +14,52 @@ import org.hibernate.annotations.DynamicUpdate;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import java.util.Date;
-/**
+
- * 用户表，记录用户信息
- */
 @Data
 @Entity
 @DynamicUpdate
 public class User {
-    /**
+    // 用户ID
-     * 用户id，主键
-     */
     @Id
     private String userId;
-    /**
+    // 用户名
-     * 用户名，唯一
-     */
     private String userUsername;
-    /**
+    // 用户昵称
-     * 昵称
-     */
     private String userNickname;
-    /**
+    // 用户密码
-     * 密码
-     */
     private String userPassword;
-    /**
+    // 用户角色ID
-     * 角色id
-     */
     private Integer userRoleId;
-    /**
+    // 用户头像
-     * 头像
-     */
     private String userAvatar;
-    /**
+    // 用户描述
-     * 描述
-     */
     private String userDescription;
-    /**
+    // 用户邮箱
-     * 邮箱
-     */
     private String userEmail;
-    /**
+    // 用户电话
-     * 电话
-     */
     private String userPhone;
     /**
-     * 创建时间, 设计表时设置了自动插入当前时间，无需在Java代码中设置了
+     *
+     *
+     * 创建时间, 设计表时设置了自动插入
+     *
+     * 当前时间，无需在Java代码中设置了
+     *
+     *
      */
 
+    // 创建时间
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date createTime;
 
     /**
-     * 更新时间，设计表时设置了自动插入当前时间，无需在Java代码中设置了。
+     * 更新时间，设计表时设置了自动插入
-     * 同时@DynamicUpdate注解可以时间当数据库数据变化时自动更新，无需人工维护
+     * 当前时间，无需在Java代码中设置了。
+     * 同时@DynamicUpdate注
+     * 解可以时间当数据库数据变化时自动更
+     * 新，无需人工维护
      */
+    // 更新时间
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date updateTime;
-}
+}

backend/src/main/java/lsgwr/exam/enums/LoginTypeEnum.java

@@ -3,18 +3,25 @@ package lsgwr.exam.enums;
 import lombok.Getter;
 
 /**
- * @Description: 用户账号类型的枚举
+ * 用户账号类型的枚举
+ *
+ *
+ * @author liangshanguang
+ *
+ *
  */
 @Getter
 public enum LoginTypeEnum {
     /**
-     * @Description: 用户的账号类型
+     *
-     * 1代表用户名，2代表邮箱
+     * 用户的账号类型，1代表用户名，2代表邮箱
+     *
+     *
      */
     USERNAME(1, "用户名"),
     EMAIL(2, "邮箱");
 
-    // 构造函数用于初始化code和description
+
     LoginTypeEnum(Integer type, String name) {
         this.type = type;
         this.name = name;

backend/src/main/java/lsgwr/exam/enums/QuestionEnum.java

@@ -8,16 +8,17 @@ package lsgwr.exam.enums;
 
 import lombok.Getter;
 
-/**
- * @Description : 问题类型
- */
 @Getter
 public enum QuestionEnum {
+
+    /**
+     * 问题类型
+     */
     RADIO(1, "单选题"),
     CHECK(2, "多选题"),
     JUDGE(3, "判断题");
 
-    // 构造函数用于初始化id和role
+
     QuestionEnum(Integer id, String role) {
         this.id = id;
         this.role = role;

backend/src/main/java/lsgwr/exam/enums/ResultEnum.java

@@ -2,9 +2,6 @@ package lsgwr.exam.enums;
 
 import lombok.Getter;
 
-/**
- * @Description : 错误码枚举
- */
 @Getter
 public enum ResultEnum {
     // 下面是本项目用到的所有错误码
@@ -20,16 +17,14 @@ public enum ResultEnum {
     ORDER_UPDATE_ERR(15, "考试更新异常"),
     ORDER_DETAIL_EMPTY(16, "用户详情为空");
 
-    /**
+    // 构造方法，用于初始化错误码和错误信息
-     * @Description: 构造函数用于初始化错误码code和描述信息message
-     * @param code 错误码
-     * @param message 描述信息
-     */
     ResultEnum(Integer code, String message) {
         this.code = code;
         this.message = message;
     }
 
+    // 错误码
     private Integer code;
+    // 错误信息
     private String message;
 }

backend/src/main/java/lsgwr/exam/enums/RoleEnum.java

@@ -8,24 +8,21 @@ package lsgwr.exam.enums;
 
 import lombok.Getter;
 
-/**
- * @Description: 账户身份枚举
- */
 @Getter
 public enum RoleEnum {
 
     /**
+     *
+     *
      * 用户角色，和数据库里面的role表相对应
+     *
+     *
      */
     ADMIN(1, "管理员"),
     TEACHER(2, "教师"),
     STUDENT(3, "学生");
 
-    /**
+
-     * @Description: 构造函数用于初始化错误码code和描述信息message
-     * @param id 身份id
-     * @param role 身份描述
-     */
     RoleEnum(Integer id, String role) {
         this.id = id;
         this.role = role;

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

@@ -9,34 +9,24 @@ package lsgwr.exam.exception;
 import lsgwr.exam.enums.ResultEnum;
 import lombok.Getter;
 
-/**
- * 考试异常类
- */
 @Getter
 public class ExamException extends RuntimeException {
-    /**
+    // 定义异常代码
-     * 异常码
-     */
     private Integer code;
 
-    /**
+    // 构造函数，传入ResultEnum枚举类型
-     * 构造函数，传入枚举类型
-     *
-     * @param resultEnum ResultEnum对象
-     */
     public ExamException(ResultEnum resultEnum) {
+        // 调用父类构造函数，传入ResultEnum枚举类型的消息
         super(resultEnum.getMessage());
+        // 将ResultEnum枚举类型的代码赋值给异常代码
         this.code = resultEnum.getCode();
     }
 
-    /**
+    // 构造函数，传入异常代码和消息
-     * 构造函数，传入异常码和异常信息
-     *
-     * @param code 异常码
-     * @param message 异常信息
-     */
     public ExamException( Integer code, String message) {
+        // 调用父类构造函数，传入消息
         super(message);
+        // 将传入的异常代码赋值给异常代码
         this.code = code;
     }
 }

backend/src/main/java/lsgwr/exam/interceptor/LoginInterceptor.java

@@ -23,52 +23,71 @@ import java.io.PrintWriter;
  *
  * @author liangshanguang
  */
-
-/**
- * 登录拦截器，主要用于校验Token
- */
 @Component
 public class LoginInterceptor implements HandlerInterceptor {
 
     /**
+     *
      * 有上面的@Component才能使得这个属性能从pplication.yml中取得拦截器的值
+     *
+     *
      */
     @Value("${interceptors.auth-ignore-uris}")
     private String authIgnoreUris;
 
     /**
+     *
+     *
      * 进入controller之前进行拦截
      *
+     *
      * @param request  请求体
+     *
      * @param response 响应体
+     *
      * @param handler  处理者
+     *
      * @return 是否继续往下走
+     *
      * @throws Exception 拦截中出的异常
+     *
      */
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        // 打印进入拦截器
         System.out.println("进入拦截器啦！");
+        // 获取请求的URI
         String uri = request.getRequestURI();
+        // 打印URI
         System.out.println(uri);
+        // 打印无需拦截的接口路径
         System.out.println("无需拦截的接口路径：" + authIgnoreUris);
+        // 将无需拦截的接口路径分割成数组
         String[] authIgnoreUriArr = authIgnoreUris.split(",");
         // 登录和注册接口不需要进行token拦截和校验
         for (String authIgnoreUri : authIgnoreUriArr) {
+            // 如果请求的URI在无需拦截的接口路径中，则直接返回true
             if (authIgnoreUri.equals(uri)) {
                 return true;
             }
         }
         // 注意要和前端适配Access-Token属性，前端会在登陆后的每个接口请求头加Access-Token属性
+        // 获取请求头中的token
         String token = request.getHeader("Access-Token");
+        // 如果token不在header中，则可能在参数中
         if (token == null) {
-            // token不在header中时，也可能在参数中(RequestParam)
+            // 从参数中获取token
             token = request.getParameter("token");
         }
+        // 如果token不为空
         if (token != null) {
             // 请求中是携带参数的
+            // 校验token
             Claims claims = JwtUtils.checkJWT(token);
+            // 如果token校验失败
             if (claims == null) {
                 // 返回null说明用户篡改了token，导致校验失败
+                // 返回错误信息
                 sendJsonMessage(response, JsonData.buildError("token无效，请重新登录"));
                 return false;
             }
@@ -77,10 +96,12 @@ public class LoginInterceptor implements HandlerInterceptor {
             // 用户名
             String username = (String) claims.get("username");
             // 把这两个参数放到请求中，从而可以在controller中获取到，不需要在controller中在用Jwt解密了,request.getAttribute("属性名")即可获取
+            // 将用户id和用户名放到请求中
             request.setAttribute("user_id", id);
             request.setAttribute("username", username);
             return true;
         }
+        // 如果token为空，则返回错误信息
         sendJsonMessage(response, JsonData.buildError("token为null,请先登录！"));
         return false;
     }
@@ -88,16 +109,23 @@ public class LoginInterceptor implements HandlerInterceptor {
     /**
      * 响应数据给前端
      *
-     * @param response    响应
+     * @param response 响应
-     * @param obj         返回的消息体
+     * @param obj      返回的消息体
-     * @throws Exception  处理异常
+     * @throws Exception 处理异常
      */
-    public static void sendJsonMessage(HttpServletResponse response, Object obj) throws Exception {
+    // 发送JSON消息
+  public static void sendJsonMessage(HttpServletResponse response, Object obj) throws Exception {
+        // 创建Gson对象
         Gson g = new Gson();
+        // 设置响应内容类型为JSON
         response.setContentType("application/json; charset=utf-8");
+        // 获取响应的PrintWriter对象
         PrintWriter writer = response.getWriter();
+        // 将对象转换为JSON字符串并写入响应
         writer.print(g.toJson(obj));
+        // 关闭PrintWriter对象
         writer.close();
+        // 刷新响应缓冲区
         response.flushBuffer();
     }
 }

backend/src/main/java/lsgwr/exam/qo/DownloadQo.java

@@ -13,8 +13,6 @@ import lombok.NoArgsConstructor;
 @AllArgsConstructor
 @NoArgsConstructor
 public class DownloadQo {
-    /**
+    // 下载路径
-     * 文件路径
-     */
     String path;
-}
+}

backend/src/main/java/lsgwr/exam/qo/LoginQo.java

@@ -10,23 +10,26 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
-/**
- * 登录的查询参数
- */
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
 public class LoginQo {
     /**
+     *
      * 1表示用户名，2表示邮箱
+     *
      */
     private Integer loginType;
     /**
+     *
      * 用户名/邮箱的字符串
+     *
      */
     private String userInfo;
     /**
+     *
      * 用户密码
+     *
      */
     private String password;
 }

backend/src/main/java/lsgwr/exam/qo/UploadModel.java

@@ -11,20 +11,25 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.springframework.web.multipart.MultipartFile;
-
+ 
-/**
- * 文件传输的实体类
- */
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
 public class UploadModel {
     /**
+     *
+     *
      * 要保存的文件
+     *
+     *
      */
     private MultipartFile[] files;
     /**
+     *
+     *
      * 文件要存储的文件夹
+     *
+     *
      */
     private String dir;
 }

backend/src/main/java/lsgwr/exam/qo/UploadModel2.java

@@ -12,19 +12,24 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.springframework.web.multipart.MultipartFile;
 
-/**
- * 文件传输的实体类，支持单个文件
- */
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
 public class UploadModel2 {
     /**
+     *
+     *
      * 要保存的文件列表
+     *
+     *
      */
     private MultipartFile file;
     /**
+     *
+     *
      * 文件要存储的文件夹
+     *
+     *
      */
     private String dir;
 }

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

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

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

@@ -1,3 +1,9 @@
+/***********************************************************
+ * @Description : 
+ * @author      : 梁山广(Laing Shan Guang)
+ * @date        : 2019-05-14 08:23
+ * @email       : liangshanguang2@gmail.com
+ ***********************************************************/
 package lsgwr.exam.repository;
 
 import lsgwr.exam.entity.ExamRecord;
@@ -5,9 +11,6 @@ import org.springframework.data.jpa.repository.JpaRepository;
 
 import java.util.List;
 
-/**
- * 考试记录仓库接口
- */
 public interface ExamRecordRepository extends JpaRepository<ExamRecord, String> {
     /**
      * 获取指定用户参加过的所有考试
@@ -16,4 +19,4 @@ public interface ExamRecordRepository extends JpaRepository<ExamRecord, String>
      * @return 用户参加过的所有考试
      */
     List<ExamRecord> findByExamJoinerIdOrderByExamJoinDateDesc(String userId);
-}
+}

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

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

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

@@ -8,8 +8,6 @@ package lsgwr.exam.repository;
 
 import lsgwr.exam.entity.Page;
 import org.springframework.data.jpa.repository.JpaRepository;
-/**
+
- * 页面数据库操作类
- */
 public interface PageRepository extends JpaRepository<Page, Integer> {
 }

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

@@ -8,8 +8,6 @@ package lsgwr.exam.repository;
 
 import lsgwr.exam.entity.QuestionCategory;
 import org.springframework.data.jpa.repository.JpaRepository;
-/**
+
- * 题目分类持久层接口
- */
 public interface QuestionCategoryRepository extends JpaRepository<QuestionCategory, Integer> {
 }

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

@@ -8,8 +8,6 @@ package lsgwr.exam.repository;
 
 import lsgwr.exam.entity.QuestionLevel;
 import org.springframework.data.jpa.repository.JpaRepository;
-/**
+
- * 题目难度的持久层接口
- */
 public interface QuestionLevelRepository extends JpaRepository<QuestionLevel, Integer> {
 }

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

@@ -8,8 +8,6 @@ package lsgwr.exam.repository;
 
 import lsgwr.exam.entity.QuestionOption;
 import org.springframework.data.jpa.repository.JpaRepository;
-/**
+
- * 题目选项的持久层接口
- */
 public interface QuestionOptionRepository extends JpaRepository<QuestionOption, String> {
 }

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

@@ -11,22 +11,9 @@ import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 
 import java.util.List;
-/**
+
- * 题目接口
- */
 public interface QuestionRepository extends JpaRepository<Question, String> {
-    /**
-     * 根据题目类型ID查询题目
-     *
-     * @param id 题目类型ID
-     * @return 题目列表
-     */
     List<Question> findByQuestionTypeId(Integer id);
-    /**
-     * 查询所有题目，按更新时间降序排列
-     *
-     * @return 题目列表
-     */
     @Query("select q from Question q order by q.updateTime desc")
     List<Question> findAll();
 }

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

@@ -8,8 +8,6 @@ package lsgwr.exam.repository;
 
 import lsgwr.exam.entity.QuestionType;
 import org.springframework.data.jpa.repository.JpaRepository;
-/**
+
- * 题目类型接口
- */
 public interface QuestionTypeRepository extends JpaRepository<QuestionType, Integer> {
 }

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

@@ -9,8 +9,5 @@ package lsgwr.exam.repository;
 import lsgwr.exam.entity.Role;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-/**
- * 角色的数据库操作类
- */
 public interface RoleRepository extends JpaRepository<Role, Integer> {
 }

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

@@ -8,9 +8,7 @@ package lsgwr.exam.repository;
 
 import lsgwr.exam.entity.User;
 import org.springframework.data.jpa.repository.JpaRepository;
-/**
+
- * 用户表的操作类
- */
 public interface UserRepository extends JpaRepository<User, String> {
     /**
      * 根据用户名查找到合适的用户

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

@@ -4,109 +4,189 @@
  * @date        : 2019-05-28 08:05
  * @email       : liangshanguang2@gmail.com
  ***********************************************************/
-package lsgwr.exam.service;// 定义了接口所属的包名
+package lsgwr.exam.service;
 
-import lsgwr.exam.entity.Exam;// 导入了实体类Exam，可能包含考试的基本信息
+import lsgwr.exam.entity.Exam;
-import lsgwr.exam.entity.ExamRecord;// 导入了实体类ExamRecord，可能包含考试记录的详细信息
+import lsgwr.exam.entity.ExamRecord;
-import lsgwr.exam.vo.*;// 导入了VO对象，VO是值对象，用于在不同层之间传递数据
+import lsgwr.exam.vo.*;
+
+import java.util.HashMap;
+import java.util.List;
 
-import java.util.HashMap;// 导入了HashMap，用于存储键值对
-import java.util.List;// 导入了List，用于存储一系列对象
-// 定义了一个名为ExamService的接口
 public interface ExamService {
     /**
      * 获取所有的问题列表
+     *
+     *
+     *
      */
     List<QuestionVo> getQuestionAll();
 
     /**
      * 根据前端传过来的问题实体更新问题和选项
      *
+     *
+     *
      * @param questionVo 问题实体
+     *
+     *
+     *
      */
     QuestionVo updateQuestion(QuestionVo questionVo);
 
     /**
      * 问题创建
      *
+     *
+     *
+     *
      * @param questionCreateVo 问题创建实体类
+     *
+     *
      */
     void questionCreate(QuestionCreateVo questionCreateVo);
 
     /**
      * 获取问题的选项、分类和难度的下拉列表
      *
+     *
+     *
      * @return 选项、分类和难度的封装对象
+     *
+     *
      */
     QuestionSelectionVo getSelections();
 
     /**
      * 获取问题详情
      *
+     *
+     *
      * @param id 问题的id
+     *
+     *
      * @return 问题详情的封装VO
+     *
+     *
      */
     QuestionDetailVo getQuestionDetail(String id);
 
     /**
+     *
+     *
      * 获取全部考试的列表
+     *
+     *
      */
     List<ExamVo> getExamAll();
 
     /**
      * 获取所有问题的下拉列表，方便前端创建考试时筛选
      *
+     *
+     *
+     *
      * @return 适配前端的问题下拉列表
+     *
+     *
+     *
      */
     ExamQuestionTypeVo getExamQuestionType();
 
     /**
      * 根据前端组装的参数进行考试创建
      *
+     *
+     *
      * @param examCreateVo 前端组装的考试对象
+     *
+     *
+     *
      * @param userId       用户id
+     *
+     *
+     *
      * @return 创建好的考试
+     *
+     *
+     *
      */
     Exam create(ExamCreateVo examCreateVo, String userId);
 
     /**
      * 获取考试卡片列表
      *
+     *
+     *
      * @return 考试卡片列表
+     *
+     *
      */
     List<ExamCardVo> getExamCardList();
 
     /**
      * 根据考试的id获取考试的详情
      *
+     *
+     *
+     *
      * @param id exam表的主键
+     *
+     *
+     *
      * @return 考试详情的封装的VO对象
+     *
+     *
      */
     ExamDetailVo getExamDetail(String id);
 
     /**
      * 根据用户提交的作答信息进行判分
      *
+     *
+     *
      * @param userId     考试人
+     *
+     *
      * @param examId     参与的考试
+     *
+     *
      * @param answersMap 作答情况
+     *
+     *
      * @return 本次考试记录
+     *
+     *
      */
     ExamRecord judge(String userId, String examId, HashMap<String, List<String>> answersMap);
 
     /**
      * 根据用户id获取此用户的所有考试信息
      *
+     *
+     *
      * @param userId 用户id
+     *
+     *
      * @return 该用户的所有考试记录
+     *
+     *
      */
     List<ExamRecordVo> getExamRecordList(String userId);
 
     /**
      * 获取指定某次考试记录的详情
      *
+     *
+     *
      * @param recordId 考试记录的id
+     *
+     *
+     *
      * @return 考试详情
+     *
+     *
+     *
      */
     RecordDetailVo getRecordDetail(String recordId);
 
@@ -115,8 +195,17 @@ public interface ExamService {
      * 更新考试
      *
      * @param examVo 获取所有考试的接口中返回的考试信息结构
+     *
+     *
      * @param userId 当前的用户
+     *
+     *
+     *
      * @return 更新后的考试详情
+     *
+     *
+     *
+     *
      */
     Exam update(ExamVo examVo, String userId);
 }

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

@@ -16,30 +16,54 @@ public interface UserService {
     /**
      * 注册
      *
+     *
+     *
      * @param registerDTO 注册参数
+     *
+     *
+     *
      * @return 注册成功后的用户信息
+     *
+     *
      */
     User register(RegisterDTO registerDTO);
 
     /**
      * 登录接口，登录成功返回token
      *
+     *
+     *
      * @param loginQo 登录参数
+     *
+     *
      * @return 成功返回token，失败返回null
+     *
+     *
      */
     String login(LoginQo loginQo);
 
     /**
      * 根据用户id获取用户信息
      *
+     *
+     *
+     *
      * @return 用户实体
+     *
+     *
      */
     UserVo getUserInfo(String userId);
 
     /**
      * 获取用户详细信息(主要是权限相关的)
+     *
+     *
      * @param userId 用户的id
+     *
+     *
      * @return 用户信息组装的实体
+     *
+     *
      */
     UserInfoVo getInfo(String userId);
 }

backend/src/main/java/lsgwr/exam/service/impl/ExamServiceImpl.java

@@ -19,41 +19,37 @@ import org.springframework.stereotype.Service;
 import javax.transaction.Transactional;
 import java.util.*;
 
-/**
- * 考试服务实现类
- */
 @Service
 @Transactional
 public class ExamServiceImpl implements ExamService {
 
+    // 试卷仓库
     private final ExamRepository examRepository;
 
+    // 考试记录仓库
     private final ExamRecordRepository examRecordRepository;
 
+    // 问题仓库
     private final QuestionRepository questionRepository;
 
+    // 用户仓库
     private final UserRepository userRepository;
 
+    // 问题等级仓库
     private final QuestionLevelRepository questionLevelRepository;
 
+    // 问题类型仓库
     private final QuestionTypeRepository questionTypeRepository;
 
+    // 问题类别仓库
     private final QuestionCategoryRepository questionCategoryRepository;
 
-    private final QuestionOptionRepository questionOptionRepository;
+    // 问题选项仓库
-
+    // 定义一个final类型的QuestionOptionRepository对象
-    /**
+  private final QuestionOptionRepository questionOptionRepository;
-     * 构造函数
+    // 构造函数，传入多个Repository对象
-     * @param questionRepository
-     * @param userRepository
-     * @param questionLevelRepository
-     * @param questionTypeRepository
-     * @param questionCategoryRepository
-     * @param questionOptionRepository
-     * @param examRepository
-     * @param examRecordRepository
-     */
     public ExamServiceImpl(QuestionRepository questionRepository, UserRepository userRepository, QuestionLevelRepository questionLevelRepository, QuestionTypeRepository questionTypeRepository, QuestionCategoryRepository questionCategoryRepository, QuestionOptionRepository questionOptionRepository, ExamRepository examRepository, ExamRecordRepository examRecordRepository) {
+        // 将传入的Repository对象赋值给对应的成员变量
         this.questionRepository = questionRepository;//
         this.userRepository = userRepository;//
         this.questionLevelRepository = questionLevelRepository;//
@@ -63,23 +59,12 @@ public class ExamServiceImpl implements ExamService {
         this.examRepository = examRepository;
         this.examRecordRepository = examRecordRepository;
     }
-
-    /**
-     * @decription : 获取所有考试
-     * return List<QuestionVo>
-     */
     @Override
     public List<QuestionVo> getQuestionAll() {
         List<Question> questionList = questionRepository.findAll();
         return getQuestionVos(questionList);
     }
 
-    /**
-     * 获取问题列表的自定义Vo列表
-     *
-     * @param questionList 问题列表
-     * @return 自定义Vo列表
-     */
     private List<QuestionVo> getQuestionVos(List<Question> questionList) {
         // 需要自定义的question列表，
         List<QuestionVo> questionVoList = new ArrayList<>();
@@ -168,8 +153,10 @@ public class ExamServiceImpl implements ExamService {
         for (int i = 0; i < questionOptionVoList.size(); i++) {
             QuestionOptionVo questionOptionVo = questionOptionVoList.get(i);
             QuestionOption questionOption = new QuestionOption();
+            // 2.把questionOptionVo中的属性值复制到questionOption中。
             BeanUtils.copyProperties(questionOptionVo, questionOption);
             questionOptionList.add(questionOption);
+            // 3.如果questionOptionVo中的answer属性为true，则把questionOptionVo中的questionOptionId属性值添加到questionAnswerOptionIds中。
             if (questionOptionVo.getAnswer()) {
                 if (i != size - 1) {
                     // 把更新后的答案的id加上去,记得用-连到一起。
@@ -182,18 +169,25 @@ public class ExamServiceImpl implements ExamService {
         }
 
         // 1.更新问题。
+        // 根据问题id从数据库中查找问题
         Question question = questionRepository.findById(questionVo.getQuestionId()).orElse(null);
+        // 断言问题不为空
         assert question != null;
+        // 将questionVo中的属性值复制到question中
         BeanUtils.copyProperties(questionVo, question);
+        // 将问题答案选项id转换为字符串并设置到question中
         question.setQuestionAnswerOptionIds(questionAnswerOptionIds.toString());
+        // 保存更新后的question到数据库中
         questionRepository.save(question);
 
         // 2.更新所有的option。
+        // 将questionOptionList中的所有option保存到数据库中
         questionOptionRepository.saveAll(questionOptionList);
 
         // 返回更新后的问题，方便前端局部刷新。
+        // 将更新后的question转换为questionVo并返回
         return getQuestionVo(question);
-    }
+            }
 
     @Override
     public void questionCreate(QuestionCreateVo questionCreateVo) {
@@ -741,3 +735,4 @@ public class ExamServiceImpl implements ExamService {
         return replaceLastSeparator(sb.toString());
     }
 }
+//注释完毕

backend/src/main/java/lsgwr/exam/service/impl/UserServiceImpl.java

@@ -47,12 +47,7 @@ public class UserServiceImpl implements UserService {
     @Autowired
     ActionRepository actionRepository;
 
-    /**
+
-     * 注册用户
-     *
-     * @param registerDTO 前端传来的注册信息
-     * @return 注册成功返回用户信息，失败返回null
-     */
     @Override
     public User register(RegisterDTO registerDTO) {
         try {
@@ -86,12 +81,6 @@ public class UserServiceImpl implements UserService {
         }
     }
 
-    /**
-     * 登陆
-     *
-     * @param loginQo 登陆信息
-     * @return 登陆成功返回token，失败返回null
-     */
     @Override
     public String login(LoginQo loginQo) {
         User user;
@@ -117,36 +106,38 @@ public class UserServiceImpl implements UserService {
         }
         return null;
     }
-    /**
+
-     * 获取用户信息
-     *
-     * @param userId 用户id
-     * @return 用户信息
-     */
     @Override
     public UserVo getUserInfo(String userId) {
+        // 根据用户ID从数据库中查找用户信息
         User user = userRepository.findById(userId).orElse(null);
+        // 创建一个UserVo对象
         UserVo userVo = new UserVo();
+        // 断言user对象不为空
         assert user != null;
+        // 将user对象的属性复制到userVo对象中
         BeanUtils.copyProperties(user, userVo);
+        // 返回userVo对象
         return userVo;
     }
-    /**
+
-     * 获取用户详细信息
-     *
-     * @param userId 用户id
-     * @return 用户详细信息
-     */
     @Override
     public UserInfoVo getInfo(String userId) {
+        // 根据用户ID查询用户信息
         User user = userRepository.findById(userId).orElse(null);
+        // 断言用户信息不为空
         assert user != null;
+        // 创建用户信息视图对象
         UserInfoVo userInfoVo = new UserInfoVo();
         // 1.尽可能的拷贝属性
         BeanUtils.copyProperties(user, userInfoVo);
+        // 获取用户角色ID
         Integer roleId = user.getUserRoleId();
+        // 根据角色ID查询角色信息
         Role role = roleRepository.findById(roleId).orElse(null);
+        // 断言角色信息不为空
         assert role != null;
+        // 获取角色名称
         String roleName = role.getRoleName();
 
         // 2.设置角色名称
@@ -170,17 +161,27 @@ public class UserServiceImpl implements UserService {
             BeanUtils.copyProperties(page, pageVo);
 
             // 4.2 向Page中添加action
-            List<ActionVo> actionVoList = new ArrayList<>();
+           // 创建一个ActionVo类型的列表
-            String actionIdsStr = page.getActionIds();
+             List<ActionVo> actionVoList = new ArrayList<>();
-            String[] actionIdArr = actionIdsStr.split("-");
+            // 获取页面中的actionIds字符串
-            for (String actionIdStr : actionIdArr) {
+             String actionIdsStr = page.getActionIds();
-                Integer actionId = Integer.parseInt(actionIdStr);
+            // 将actionIds字符串按照"-"进行分割，得到一个字符串数组
-                Action action = actionRepository.findById(actionId).orElse(null);
+             String[] actionIdArr = actionIdsStr.split("-");
-                ActionVo actionVo = new ActionVo();
+            // 遍历字符串数组
-                assert action != null;
+             for (String actionIdStr : actionIdArr) {
-                BeanUtils.copyProperties(action, actionVo);
+                 // 将字符串转换为整数
-                actionVoList.add(actionVo);
+                 Integer actionId = Integer.parseInt(actionIdStr);
-            }
+                 // 根据actionId从数据库中查找对应的Action对象
+                 Action action = actionRepository.findById(actionId).orElse(null);
+                 // 创建一个ActionVo对象
+                 ActionVo actionVo = new ActionVo();
+                 // 断言action对象不为空
+                 assert action != null;
+                 // 将action对象的属性值复制到actionVo对象中
+                 BeanUtils.copyProperties(action, actionVo);
+                 // 将actionVo对象添加到列表中
+                 actionVoList.add(actionVo);
+             }
             // 设置actionVoList到pageVo中，然后把pageVo加到pageVoList中
             pageVo.setActionVoList(actionVoList);
             // 设置pageVoList，下面再设置到RoleVo中

backend/src/main/java/lsgwr/exam/utils/FileTransUtil.java

@@ -55,17 +55,24 @@ public class FileTransUtil {
      * @return 成功或者失败消息
      */
     public static String uploadFiles(MultipartFile[] uploadfiles, String dir) {
+        // 打印调试信息
         log.debug("Multiple file upload!");
+        // 将上传的文件名拼接成一个字符串
         String uploadedFileName = Arrays.stream(uploadfiles).map(x -> x.getOriginalFilename()).filter(x -> !StringUtils.isEmpty(x)).collect(Collectors.joining(" , "));
+        // 如果文件名为空，则返回错误信息
         if (StringUtils.isEmpty(uploadedFileName)) {
             return "文件名不能为空";
         }
         try {
+            // 调用工具类保存上传的文件
             FileTransUtil.saveUploadedFiles(Arrays.asList(uploadfiles), dir);
         } catch (IOException e) {
+            // 如果保存文件时发生异常，则返回错误信息
             return "后台服务异常";
         }
+        // 打印上传成功的日志信息
         log.info("file upload successfully! " + uploadedFileName);
+        // 返回上传成功的提示信息
         return "文件上传成功";
     }
 
@@ -75,26 +82,37 @@ public class FileTransUtil {
      * @param files 上传的文件
      * @throws IOException 文件保存异常
      */
+    // 保存上传的文件
     public static void saveUploadedFiles(List<MultipartFile> files, String dir) throws IOException {
+        // 遍历文件列表
         for (MultipartFile file : files) {
+            // 如果文件为空，则跳过
             if (file.isEmpty()) {
                 continue;
             }
+            // 如果文件夹不存在，则创建
             if (!FileUtil.exist(dir)) {
                 // 文件夹不存在就创建
                 FileUtil.mkdir(dir);
             }
+            // 获取文件的字节数组
             byte[] bytes = file.getBytes();
+            // 获取文件的原始文件名，并替换反斜杠为正斜杠
             String fileName = file.getOriginalFilename().replace("\\", "/");
+            // 如果文件名中包含斜杠，则说明是上传文件夹
             if (fileName.lastIndexOf('/')>0){
                 // 上传文件夹的时候会有这种情况
+                // 获取文件夹路径
                 String fileDir = dir + "/" + fileName.substring(0, fileName.lastIndexOf('/'));
+                // 如果文件夹不存在，则创建
                 if (!FileUtil.exist(fileDir)) {
                     // 文件夹不存在就创建,创建文件夹的时候会用到
                     FileUtil.mkdir(fileDir);
                 }
             }
+            // 获取文件的路径
             Path path = Paths.get(dir + "/" + fileName);
+            // 将文件写入路径
             Files.write(path, bytes);
         }
     }
@@ -107,14 +125,23 @@ public class FileTransUtil {
      * @throws IOException 文件流读取异常
      */
     public static ResponseEntity<InputStreamResource> downloadFile(String filePath) throws IOException {
+        // 记录下载文件的信息
         log.info("downloading file : " + filePath);
+        // 创建文件系统资源
         FileSystemResource file = new FileSystemResource(filePath);
+        // 创建响应头
         HttpHeaders headers = new HttpHeaders();
+        // 设置缓存控制
         headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
+        // 设置文件下载时的文件名
         headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", new String(file.getFilename().getBytes("gbk"), "iso-8859-1")));
+        // 设置缓存控制
         headers.add("Pragma", "no-cache");
+        // 设置缓存控制
         headers.add("Expires", "0");
+        // 打印文件名
         System.out.println(file.getFilename());
+        // 返回响应实体
         return ResponseEntity
                 .ok()
                 .headers(headers)

backend/src/main/java/lsgwr/exam/utils/FileUtils.java

@@ -24,12 +24,18 @@ public class FileUtils {
      * @param url    文件读取路径
      * @param suffix 文件后缀名
      */
-    public static File createFileByUrl(String url, String suffix) {
+    // 根据URL创建文件
+ public static File createFileByUrl(String url, String suffix) {
+        // 从URL获取图片字节数组
         byte[] byteFile = getImageFromNetByUrl(url);
+        // 如果字节数组不为空
         if (byteFile != null) {
+            // 从字节数组获取文件
             File file = getFileFromBytes(byteFile, suffix);
+            // 返回文件
             return file;
         } else {
+            // 否则返回null
             return null;
         }
     }
@@ -42,9 +48,13 @@ public class FileUtils {
      */
     private static byte[] getImageFromNetByUrl(String strUrl) {
         try {
+            // 创建URL对象
             URL url = new URL(strUrl);
+            // 打开连接
             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+            // 设置请求方法
             conn.setRequestMethod("GET");
+            // 设置连接超时时间
             conn.setConnectTimeout(5 * 1000);
             // 通过输入流获取图片数据
             InputStream inStream = conn.getInputStream();
@@ -65,41 +75,61 @@ public class FileUtils {
      * @throws Exception
      */
     private static byte[] readInputStream(InputStream inStream) throws Exception {
+        // 创建一个ByteArrayOutputStream对象，用于存储读取的字节数据
         ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+        // 创建一个字节数组，用于存储每次读取的字节数据
         byte[] buffer = new byte[1024];
+        // 定义一个变量，用于存储每次读取的字节数
         int len = 0;
+        // 循环读取输入流中的数据，直到读取完毕
         while ((len = inStream.read(buffer)) != -1) {
+            // 将读取的字节数据写入ByteArrayOutputStream对象中
             outStream.write(buffer, 0, len);
         }
+        // 关闭输入流
         inStream.close();
+        // 将ByteArrayOutputStream对象中的字节数据转换为字节数组并返回
         return outStream.toByteArray();
     }
 
     // 创建临时文件
-    private static File getFileFromBytes(byte[] b, String suffix) {
+    // 根据字节数组和后缀名创建临时文件
+   private static File getFileFromBytes(byte[] b, String suffix) {
+        // 定义输出流
         BufferedOutputStream stream = null;
+        // 定义文件
         File file = null;
         try {
+            // 创建临时文件
             file = File.createTempFile("pattern", "." + suffix);
+            // 输出临时文件位置
             System.out.println("临时文件位置：" + file.getCanonicalPath());
+            // 创建文件输出流
             FileOutputStream fstream = new FileOutputStream(file);
+            // 创建缓冲输出流
             stream = new BufferedOutputStream(fstream);
+            // 将字节数组写入文件
             stream.write(b);
         } catch (Exception e) {
+            // 打印异常信息
             e.printStackTrace();
         } finally {
+            // 关闭输出流
             if (stream != null) {
                 try {
                     stream.close();
                 } catch (IOException e) {
+                    // 打印异常信息
                     e.printStackTrace();
                 }
             }
         }
+        // 返回文件
         return file;
     }
 
-    public static MultipartFile createImg(String url) {
+    // 创建一个MultipartFile对象，根据给定的url
+public static MultipartFile createImg(String url) {
         try {
             // File转换成MutipartFile
             File file = FileUtils.createFileByUrl(url, "jpg");
@@ -131,12 +161,15 @@ public class FileUtils {
     }
 
     public static boolean base64ToFile(String filePath, String base64Data) throws Exception {
+        // 定义变量dataPrix和data，用于存储base64Data中的数据
         String dataPrix = "";
         String data = "";
 
+        // 判断base64Data是否为空
         if (base64Data == null || "".equals(base64Data)) {
             return false;
         } else {
+            // 将base64Data按照"base64,"进行分割，获取dataPrix和data
             String[] d = base64Data.split("base64,");
             if (d != null && d.length == 2) {
                 dataPrix = d[0];

backend/src/main/java/lsgwr/exam/utils/JwtUtils.java

@@ -26,17 +26,21 @@ public class JwtUtils {
     private static final String APP_SECRET = "liangshanguang";
 
     public static String genJsonWebToken(User user) {
+        // 判断用户信息是否为空
         if (user == null || user.getUserId() == null || user.getUserUsername() == null || user.getUserAvatar() == null) {
             return null;
         }
+        // 使用Jwts.builder()创建一个JWT对象
         return Jwts.builder().setSubject(SUBJECT)
                 // 下面3行设置token中间字段，携带用户的信息
                 .claim("id", user.getUserId())
                 .claim("username", user.getUserUsername())
                 .claim("avatar", user.getUserAvatar())
+                // 设置签发时间
                 .setIssuedAt(new Date())
                 // 设置过期时间
                 .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
+                // 使用HS256算法进行签名
                 .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                 // 生成的结果字符串太长，这里压缩下
                 .compact();
@@ -50,6 +54,7 @@ public class JwtUtils {
      */
     public static Claims checkJWT(String token) {
         try {
+            // 使用Jwts解析token，并设置签名密钥为APP_SECRET
             return Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(token).getBody();
         } catch (Exception e) {
             // 篡改token会导致校验失败，走到异常分支，这里返回null

backend/src/main/java/lsgwr/exam/utils/ResultVOUtil.java

@@ -7,32 +7,26 @@
 package lsgwr.exam.utils;
 
 import lsgwr.exam.vo.ResultVO;
-/**
+
- * 封装返回结果
- */
 public class ResultVOUtil {
-    /**
+
-     * 成功返回结果
+    // 返回一个包含code、msg和object的ResultVO对象
-     */
     public static ResultVO success(Integer code, String msg, Object object) {
         return new ResultVO(code, msg, object);
     }
-    /**
+
-     * 成功返回结果
+    // 返回一个包含object的ResultVO对象，默认code为0，msg为"成功"
-     */
     public static ResultVO success(Object object) {
         return new ResultVO(0, "成功", object);
     }
-    /**
+
-     * 成功返回结果
+    // 返回一个默认的ResultVO对象，默认code为0，msg为"成功"，object为null
-     */
     public static ResultVO success() {
         return new ResultVO(0, "成功", null);
     }
 
-    /**
+
-     * 失败返回结果
+    // 返回一个包含code和msg的ResultVO对象，默认object为null
-     */
     public static ResultVO error(Integer code, String msg) {
         return new ResultVO(code, msg, null);
     }

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

@@ -8,24 +8,18 @@ package lsgwr.exam.vo;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
-/**
+
- * Action前端展示类
- */
 @Data
 public class ActionVo {
-    /**
+    // 使用@JsonProperty注解将actionName属性映射到JSON中的action字段
-     * 动作名称
-     */
     @JsonProperty("action")
     private String actionName;
-    /**
+
-     * 动作描述
+    // 使用@JsonProperty注解将actionDescription属性映射到JSON中的describe字段
-     */
     @JsonProperty("describe")
     private String actionDescription;
-    /**
+
-     * 是否默认选中
+    // 使用@JsonProperty注解将defaultCheck属性映射到JSON中的defaultCheck字段
-     */
     @JsonProperty("defaultCheck")
     private Boolean defaultCheck;
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -16,48 +16,39 @@ import java.io.Serializable;
 @AllArgsConstructor
 @NoArgsConstructor
 public class JsonData implements Serializable {
-    /**
+
-     * 序列化id
-     */
     private static final long serialVersionUID = 1L;
 
-    /**
+    //状态码 0 表示成功，1表示处理中，-1表示失败
-     * 状态码 0 表示成功，1表示处理中，-1表示失败
+
-     */
     private Integer code;
-    /**
+    //数据
-     * 数据
+
-     */
     private Object data;
-    /**
+    //描述
-     * 描述
+
-     */
     private String msg;
 
-    /**
+    //成功，传入数据
-     * 成功，传入数据
+
-     */
     public static JsonData buildSuccess() {
         return new JsonData(0, null, null);
     }
 
-    /**
+    //成功，传入数据
-     * 成功，传入数据
+
-     */
     public static JsonData buildSuccess(Object data) {
         return new JsonData(0, data, null);
     }
 
-    /**
+    //失败，传入描述信息
-     * 失败，传入描述信息
+
-     */
     public static JsonData buildError(String msg) {
         return new JsonData(-1, null, msg);
     }
 
-    /**
+    //失败，传入描述信息,状态码
-     * 失败，传入描述信息,状态码
+
-     */
     public static JsonData buildError(String msg, Integer code) {
         return new JsonData(code, null, msg);
     }
@@ -73,9 +64,8 @@ public class JsonData implements Serializable {
         return new JsonData(0, data, msg);
     }
 
-    /**
+    //成功，传入数据,及状态码
-     * 成功，传入数据,及状态码
+
-     */
     public static JsonData buildSuccess(Object data, int code) {
         return new JsonData(code, data, null);
     }

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

@@ -10,24 +10,18 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
 
 import java.util.List;
-/**
+
- * 页面展示类
- */
 @Data
 public class PageVo {
-    /**
+    // 使用@JsonProperty注解将actionEntitySet字段映射到JSON中的actionEntitySet字段
-     * 页面动作集合
-     */
     @JsonProperty("actionEntitySet")
     private List<ActionVo> actionVoList;
-    /**
+
-     * 页面名称，即路由名称
+    // 使用@JsonProperty注解将permissionId字段映射到JSON中的permissionId字段
-     */
     @JsonProperty("permissionId")
     private String pageName;
-    /**
+
-     * 页面描述，即路由描述
+    // 使用@JsonProperty注解将permissionName字段映射到JSON中的permissionName字段
-     */
     @JsonProperty("permissionName")
     private String pageDescription;
 }

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

@@ -10,47 +10,38 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
 
 import java.util.List;
-/**
+
- * 问题创建的实体类,简化了下
- */
 @Data
 public class QuestionCreateSimplifyVo {
-    /**
+    //题目名称
-     * 题目名称
-     */
     @JsonProperty("name")
     private String questionName;
 
     @JsonProperty("desc")
     private String questionDescription;
 
-    /**
+    //问题的难度的id
-     * 问题的难度的id
+
-     */
     @JsonProperty("level")
     private Integer questionLevelId;
 
-    /**
+    //问题的类型(单选、多选、判断等)
-     * 问题的类型(单选、多选、判断等)
+
-     */
     @JsonProperty("type")
     private Integer questionTypeId;
 
-    /**
+    //题目的类别表，从内容角度划分，比如数学、语文、英语等
-     * 题目的类别表，从内容角度划分，比如数学、语文、英语等
+
-     */
     @JsonProperty("category")
     private Integer questionCategoryId;
 
-    /**
+    //创建选项 里添加的内容
-     * 创建选项 里添加的内容
+
-     */
     @JsonProperty("option")
     private String option;
 
-    /**
+    //问题的选项列表，带上了是否是答案的true和false
-     * 问题的选项列表，带上了是否是答案的true和false
+
-     */
     @JsonProperty("options")
     private List<QuestionOptionCreateVo> questionOptionCreateVoList;
 }

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

@@ -10,53 +10,44 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
 
 import java.util.List;
-/**
+
- * 创建问题的实体类
- */
 @Data
 public class QuestionCreateVo {
-    /**
+    //题目名称
-     * 题目名称
+
-     */
     @JsonProperty("name")
     private String questionName;
 
     @JsonProperty("desc")
     private String questionDescription;
 
-    /**
+    //题目的分数,默认值是5
-     * 题目的分数,默认值是5
+
-     */
     @JsonProperty("score")
     private Integer questionScore = 5;
 
-    /**
+    //题目的创建者的id，从token中解析得到
-     * 题目的创建者的id，从token中解析得到
+
-     */
     @JsonProperty("creator")
     private String questionCreatorId;
 
-    /**
+    //问题的难度的id
-     * 问题的难度的id
+
-     */
     @JsonProperty("level")
     private Integer questionLevelId;
 
-    /**
+    //问题的类型(单选、多选、判断等)
-     * 问题的类型(单选、多选、判断等)
+
-     */
     @JsonProperty("type")
     private Integer questionTypeId;
 
-    /**
+    //题目的类别表，从内容角度划分，比如数学、语文、英语等
-     * 题目的类别表，从内容角度划分，比如数学、语文、英语等
+
-     */
     @JsonProperty("category")
     private Integer questionCategoryId;
 
-    /**
+    //问题的选项列表，带上了是否是答案的true和false
-     * 问题的选项列表，带上了是否是答案的true和false
+
-     */
     @JsonProperty("options")
     private List<QuestionOptionCreateVo> questionOptionCreateVoList;
 }

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

@@ -11,35 +11,26 @@ import lombok.Data;
 
 import java.util.ArrayList;
 import java.util.List;
-/**
+
- * 问题详情的实体类
- */
 @Data
 public class QuestionDetailVo {
-    /**
+    //问题的id
-     * 问题的id
+
-     */
     private String id;
 
-    /**
+    //考试题目
-     * 考试题目
-     */
     private String name;
 
-    /**
+    //考试描述
-     * 考试描述
+
-     */
     private String description;
-    /**
+    //问题的类型
-     * 问题的类型
+
-     */
     private String type;
-    /**
+    //问题的选项
-     * 问题的选项
+
-     */
     private List<QuestionOption> options;
-    /**
+    //问题的答案,选项的id组成的数组
-     * 问题的答案,选项的id组成的数组
+
-     */
     private List<String> answers = new ArrayList<>();
 }

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

@@ -8,21 +8,16 @@ package lsgwr.exam.vo;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
-/**
+
- * 问题选项的外层对象
- */
 @Data
 public class QuestionOptionCreateVo {
 
-    /**
+    //问题的内容
-     * 问题的内容
-     */
     @JsonProperty("content")
     private String questionOptionContent;
 
-    /**
+    //当前的选项是否是问题大答案
-     * 当前的选项是否是问题大答案
+
-     */
     @JsonProperty("answer")
     private Boolean answer = false;
 

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

@@ -8,29 +8,22 @@ package lsgwr.exam.vo;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
-/**
+
- * 问题选项的自定义实体类
- */
 @Data
 public class QuestionOptionVo {
-    /**
+    // 题目选项ID
-     * 问题选项的id
-     */
     @JsonProperty("id")
     private String questionOptionId;
-    /**
+
-     * 问题选项的内容
+    // 题目选项内容
-     */
     @JsonProperty("content")
     private String questionOptionContent;
-    /**
+
-     * 问题选项是否是答案
+    // 是否为答案
-     */
     @JsonProperty("answer")
     private Boolean answer = false;
-    /**
+
-     * 问题选项的描述
+    // 题目选项描述
-     */
     @JsonProperty("description")
     private String questionOptionDescription;
 }

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

@@ -10,35 +10,28 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
 
 import java.util.List;
-/**
+
- * 问题列表反馈给前端的对象
- */
 @Data
 public class QuestionPageVo {
 
-    /**
+    //分页时每个分页的大小
-     * 分页时每个分页的大小
+
-     */
     private Integer pageSize;
 
-    /**
+    //当前是在第几页，注意要比前端传过来地小1
-     * 当前是在第几页，注意要比前端传过来地小1
+
-     */
     private Integer pageNo;
 
-    /**
+    //一共有多少条符合条件的记录
-     * 一共有多少条符合条件的记录
+
-     */
     private Long totalCount;
 
-    /**
+    //一共有多少页
-     * 一共有多少页
+
-     */
     private Integer totalPage;
 
-    /**
+    //当前页的详细数据
-     * 当前页的详细数据
+
-     */
     @JsonProperty("data")
     private List<QuestionVo> questionVoList;
 }

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

@@ -13,24 +13,18 @@ import lsgwr.exam.entity.QuestionType;
 import lombok.Data;
 
 import java.util.List;
-/**
+
- * 前端创建问题时的下拉列表选择
- */
 @Data
 public class QuestionSelectionVo {
-    /**
+    // 问题类型列表
-     * 问题类型
-     */
     @JsonProperty("types")
     private List<QuestionType> questionTypeList;
-    /**
+
-     * 问题分类
+    // 问题类别列表
-     */
     @JsonProperty("categories")
     private List<QuestionCategory> questionCategoryList;
-    /**
+
-     * 问题难度
+    // 问题等级列表
-     */
     @JsonProperty("levels")
     private List<QuestionLevel> questionLevelList;
 }

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

@@ -12,66 +12,53 @@ import lombok.Data;
 
 import java.util.Date;
 import java.util.List;
-/**
+
- * 问题的VO类，用于返回给前端
- */
 @Data
 public class QuestionVo {
-    /**
+    // 使用@JsonProperty注解将属性映射到JSON对象的属性
-     * 问题id，从数据库表question中获取
-     */
     @JsonProperty("id")
     private String questionId;
-    /**
+
-     * 问题名称，从数据库表question中获取
+    // 使用@JsonProperty注解将属性映射到JSON对象的属性
-     */
     @JsonProperty("name")
     private String questionName;
-    /**
+
-     * 问题分值，从数据库表question中获取
+    // 使用@JsonProperty注解将属性映射到JSON对象的属性
-     */
     @JsonProperty("score")
     private Integer questionScore;
 
-    /**
+    //根据questionCreatorId查询创建人
-     * 根据questionCreatorId查询创建人
+
-     */
     @JsonProperty("creator")
     private String questionCreator;
 
-    /**
+    //根据questionLevelId查询问题难度
-     * 根据questionLevelId查询问题难度
+
-     */
     @JsonProperty("level")
     private String questionLevel;
 
-    /**
+    //问题难度级别在数据库表question_level中的id
-     * 问题难度级别在数据库表question_level中的id
+
-     */
     @JsonProperty("levelId")
     private int questionLevelId;
 
-    /**
+    //问题类型，根据questionTypeId获取
-     * 问题类型，根据questionTypeId获取
+
-     */
     @JsonProperty("type")
     private String questionType;
 
-    /**
+    //问题类型在数据库表question_type中的id
-     * 问题类型在数据库表question_type中的id
+
-     */
     @JsonProperty("typeId")
     private int questionTypeId;
 
-    /**
+    //问题分类，根据questionCategoryId获得
-     * 问题分类，根据questionCategoryId获得
+
-     */
     @JsonProperty("category")
     private String questionCategory;
 
-    /**
+    //问题分类在数据库表question_category中的id
-     * 问题分类在数据库表question_category中的id
+
-     */
     @JsonProperty("categoryId")
     private int questionCategoryId;
 
@@ -79,17 +66,15 @@ public class QuestionVo {
     @JsonProperty("description")
     private String questionDescription;
 
-    /**
+    //问题选项列表，从questionOptionIds获得,需要自己额外给isAnswer赋值
-     * 问题选项列表，从questionOptionIds获得,需要自己额外给isAnswer赋值
+
-     */
     @JsonProperty("options")
     private List<QuestionOptionVo> questionOptionVoList;
 
 
-    /**
+     //更新时间，设计表时设置了自动插入当前时间，无需在Java代码中设置了。
-     * 更新时间，设计表时设置了自动插入当前时间，无需在Java代码中设置了。
+     //同时@DynamicUpdate注解可以时间当数据库数据变化时自动更新，无需人工维护
-     * 同时@DynamicUpdate注解可以时间当数据库数据变化时自动更新，无需人工维护
+
-     */
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date updateTime;
 }

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

@@ -11,27 +11,21 @@ import lombok.Data;
 
 import java.util.HashMap;
 import java.util.List;
-/**
+
- * 考试记录详情的VO
- */
 @Data
 public class RecordDetailVo {
-    /**
+    //含有考试记录原始信息的对象
-     * 含有考试记录原始信息的对象
+
-     */
     private ExamRecord examRecord;
-    /**
+    //用户此次考试的作答信息, 键是题目的id，值是选项id的列表
-     * 用户此次考试的作答信息, 键是题目的id，值是选项id的列表
+
-     */
     private HashMap<String, List<String>> answersMap;
 
-    /**
+    //用户每题作答结果的Map，键是问题的id，值是用户这题是否回答正确，True or False
-     * 用户每题作答结果的Map，键是问题的id，值是用户这题是否回答正确，True or False
+
-     */
     private HashMap<String, String> resultsMap;
 
-    /**
+    //正确答案，键是题目的id，值是正确答案的id组成的列表
-     * 正确答案，键是题目的id，值是正确答案的id组成的列表
+
-     */
     private HashMap<String, List<String>> answersRightMap;
 }

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

@@ -13,33 +13,29 @@ import lombok.Data;
 @JsonInclude(JsonInclude.Include.NON_NULL) // 避免返回NULL的字段
 public class ResultVO<T> {
 
-    /**
+
-     * 构造函数
+    // 构造函数，用于初始化ResultVO对象
-     * @param code 错误码
-     * @param msg 提示信息
-     * @param data 具体内容
-     */
     public ResultVO(Integer code, String msg, T data) {
+        // 初始化code属性
         this.code = code;
+        // 初始化msg属性
         this.msg = msg;
+        // 初始化data属性
         this.data = data;
     }
 
     public ResultVO() {
     }
 
-    /**
+    //错误码
-     * 错误码
+
-     */
     private Integer code;
 
-    /**
+    //提示信息
-     * 提示信息
+
-     */
     private String msg = "";
 
-    /**
+    //具体内容
-     * 具体内容
+
-     */
     private T data;
 }

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

@@ -10,29 +10,22 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
 
 import java.util.List;
-/**
+
- * 角色的VO类
- */
 @Data
 public class RoleVo {
-    /**
+    // 角色名称
-     * 角色名
-     */
     @JsonProperty("id")
     private String roleName;
-    /**
+
-     * 角色描述
+    // 角色描述
-     */
     @JsonProperty("name")
     private String roleDescription;
-    /**
+
-     * 角色的详细描述
+    // 角色详情
-     */
     @JsonProperty("describe")
     private String roleDetail;
-    /**
+
-     * 角色所拥有的权限
+    // 角色权限
-     */
     @JsonProperty("permissions")
     private List<PageVo> pageVoList;
 }

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

@@ -8,29 +8,23 @@ package lsgwr.exam.vo;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
-/**
+
- * 用户信息展示类
- */
 @Data
 public class UserInfoVo {
-    /**
+
-     * 用户ID，唯一
+    // 用户ID
-     */
     @JsonProperty("id")
     private String userId;
-    /**
+
-     * 头像URL
+    // 用户头像
-     */
     @JsonProperty("avatar")
     private String userAvatar;
-    /**
+
-     * 用户名，唯一
+    // 用户昵称
-     */
     @JsonProperty("name")
     private String userNickname;
-    /**
+
-     * 账号，唯一
+    // 用户名
-     */
     @JsonProperty("username")
     private String userUsername;
 
@@ -39,18 +33,23 @@ public class UserInfoVo {
      */
     private String password = "";
 
+    // 用户邮箱
     @JsonProperty("email")
     private String userEmail;
 
+    // 用户电话
     @JsonProperty("telephone")
     private String userPhone;
 
+    // 角色ID
     @JsonProperty("roleId")
     private String roleName;
 
+    // 用户描述
     @JsonProperty("welcome")
     private String userDescription;
 
+    // 角色信息
     @JsonProperty("role")
     private RoleVo roleVo;
-}
+}

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

@@ -8,49 +8,38 @@ package lsgwr.exam.vo;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
-/**
+
- * 用户信息展示类
- */
 @Data
 public class UserVo {
-    /**
+    // 用户ID
-     * 用户ID
-     */
     @JsonProperty("id")
     private String userId;
-    /**
+
-     * 用户名
+    // 用户名
-     */
     @JsonProperty("username")
     private String userUsername;
-    /**
+
-     * 昵称
+    // 昵称
-     */
     @JsonProperty("nickname")
     private String userNickname;
-    /**
+
-     * 角色ID
+    // 角色ID
-     */
     @JsonProperty("role")
     private Integer userRoleId;
-    /**
+
-     * 头像
+    // 头像
-     */
     @JsonProperty("avatar")
     private String userAvatar;
-    /**
+
-     * 个人简介
+    // 描述
-     */
     @JsonProperty("description")
     private String userDescription;
-    /**
+
-     * 邮箱
+    // 邮箱
-     */
     @JsonProperty("email")
     private String userEmail;
-    /**
+
-     * 电话
+    // 电话
-     */
     @JsonProperty("phone")
     private String userPhone;
 }

backend/src/main/resources/application.yml

@@ -5,7 +5,7 @@ spring:
     driver-class-name: com.mysql.cj.jdbc.Driver
     username: root
     password: aA111111
-    url: jdbc:mysql://localhost:3306/exam?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai&&allowPublicKeyRetrieval=true
+    url: jdbc:mysql://localhost:3306/exam?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
   jpa:
     # 调试的时候用，用于打印完成SQL语句(但是不打印参数),联合下面的logging.level一同打印最完整的SQL信息(语句+参数)
     show-sql: false

doc/deploy/nginx.conf

@@ -1,44 +1,58 @@
 events {
+    # 工作进程的最大连接数
     worker_connections  1024;
 }
- 
+
- 
+
 http {
+    # 包含mime.types文件
     include       mime.types;
+    # 默认文件类型
     default_type  application/octet-stream;
+    # 开启sendfile功能
     sendfile        on;
-   
+
+    # 保持连接超时时间
     keepalive_timeout  65;
- 
+
+    # 定义一个server
     server {
+        # 监听80端口
         listen       80;
+        # 服务器名称
         server_name  localhost;
- 
+
         # 404页面跳转
         location / {
+			# 如果请求的文件不存在，则尝试加载index.html
 			try_files $uri /index.html;
 		}
-		
+
         # 静态资源目录，即vue打包后的dist里的静态资源
         root /usr/share/nginx/html/;
+        # 默认首页
         index  index.html index.htm;
- 
+
         # 后端服务的配置
         location /api/ {
-				proxy_redirect off;
+				# 关闭代理重定向
+                proxy_redirect off;
+                # 设置代理请求头
                 proxy_set_header Host $host;
                 proxy_set_header X-Real-IP $remote_addr;
                 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                 # 后端服务地址
                 proxy_pass http://localhost:9527/api/;
         }
- 
+
-        
+
+        # 错误页面
         error_page   500 502 503 504  /50x.html;
+        # 错误页面路径
         location = /50x.html {
             root   html;
         }
     }
 
 
-}
+}

frontend/.travis.yml

@@ -1,7 +1,13 @@
+# 定义语言为node_js
 language: node_js
+# 定义node_js版本为10.15.0
 node_js:
   - 10.15.0
+# 缓存yarn
 cache: yarn
+# 定义脚本
 script:
+  # 运行yarn
   - yarn
-  - yarn run lint --no-fix && yarn run build
+  # 运行yarn run lint --no-fix && yarn run build
+  - yarn run lint --no-fix && yarn run build

frontend/babel.config.js

@@ -1,6 +1,9 @@
+// 导出一个对象，用于配置Babel
 module.exports = {
+  // 使用@vue/app预设
   presets: [
     '@vue/app',
+    // 使用@babel/preset-env预设，并设置useBuiltIns为entry
     [
       '@babel/preset-env',
       {
@@ -8,9 +11,10 @@ module.exports = {
       }
     ]
   ]
-  // if your use import on Demand, Use this code
+  // 如果你的项目中使用了按需加载，可以使用以下代码
   // ,
   // plugins: [
+  //   // 使用import插件，配置ant-design-vue库的路径和样式
   //   [ 'import', {
   //     'libraryName': 'ant-design-vue',
   //     'libraryDirectory': 'es',

frontend/jest.config.js

@@ -1,23 +1,34 @@
+// 导出配置文件
 module.exports = {
+  // 模块文件扩展名
   moduleFileExtensions: [
     'js',
     'jsx',
     'json',
     'vue'
   ],
+  // 转换规则
   transform: {
+    // 将.vue文件转换为jest可识别的格式
     '^.+\\.vue$': 'vue-jest',
+    // 将.css、.styl、.less、.sass、.scss、.svg、.png、.jpg、.ttf、.woff、.woff2文件转换为stub
     '.+\\.(css|styl|less|sass|scss|svg|png|jpg|ttf|woff|woff2)$': 'jest-transform-stub',
+    // 将.jsx、.js文件转换为babel可识别的格式
     '^.+\\.jsx?$': 'babel-jest'
   },
+  // 模块名称映射
   moduleNameMapper: {
+    // 将../替换为<rootDir>/src/
     '^../(.*)$': '<rootDir>/src/$1'
   },
+  // 快照序列化器
   snapshotSerializers: [
     'jest-serializer-vue'
   ],
+  // 测试匹配规则
   testMatch: [
     '**/tests/unit/**/*.spec.(js|jsx|ts|tsx)|**/__tests__/*.(js|jsx|ts|tsx)'
   ],
+  // 测试URL
   testURL: 'http://localhost/'
-}
+}

frontend/public/index.html

@@ -1,102 +1,35 @@
 <!DOCTYPE html>
 <html lang="zh-cmn-Hans">
   <head>
+    <!-- 设置字符编码为utf-8 -->
     <meta charset="utf-8">
+    <!-- 设置IE浏览器兼容模式 -->
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <!-- 设置视口宽度为设备宽度，初始缩放比例为1.0 -->
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <!-- 设置网站图标 -->
     <link rel="icon" href="<%= BASE_URL %>logo.png">
+    <!-- 设置网站标题 -->
     <title>在线考试系统</title>
-    <!-- 定义加载中的样式   -->
+    <!-- 设置加载动画样式 -->
-    <style>#loading-mask{
+    <style>#loading-mask{position:fixed;left:0;top:0;height:100%;width:100%;background:#fff;user-select:none;z-index:9999;overflow:hidden}.loading-wrapper{position:absolute;top:50%;left:50%;transform:translate(-50%,-100%)}.loading-dot{animation:antRotate 1.2s infinite linear;transform:rotate(45deg);position:relative;display:inline-block;font-size:64px;width:64px;height:64px;box-sizing:border-box}.loading-dot i{width:22px;height:22px;position:absolute;display:block;background-color:#1890ff;border-radius:100%;transform:scale(.75);transform-origin:50% 50%;opacity:.3;animation:antSpinMove 1s infinite linear alternate}.loading-dot i:nth-child(1){top:0;left:0}.loading-dot i:nth-child(2){top:0;right:0;-webkit-animation-delay:.4s;animation-delay:.4s}.loading-dot i:nth-child(3){right:0;bottom:0;-webkit-animation-delay:.8s;animation-delay:.8s}.loading-dot i:nth-child(4){bottom:0;left:0;-webkit-animation-delay:1.2s;animation-delay:1.2s}@keyframes antRotate{to{-webkit-transform:rotate(405deg);transform:rotate(405deg)}}@-webkit-keyframes antRotate{to{-webkit-transform:rotate(405deg);transform:rotate(405deg)}}@keyframes antSpinMove{to{opacity:1}}@-webkit-keyframes antSpinMove{to{opacity:1}}</style>
-      position:fixed;left:0;top:0;height:100%;
-      width:100%;background:#fff;user-select:none;
-      z-index:9999;overflow:hidden}
-    .loading-wrapper{
-      position:absolute;
-      top:50%;
-      left:50%;
-      transform:translate(-50%,-100%)
-    }
-    .loading-dot{
-      animation:antRotate 1.2s infinite linear;
-      transform:rotate(45deg);
-      position:relative;
-      display:inline-block;
-      font-size:64px;
-      width:64px;
-      height:64px;
-      box-sizing:border-box}
-    .loading-dot i{
-      width:22px;
-      height:22px;
-      position:absolute;
-      display:block;
-      background-color:#1890ff;
-      border-radius:100%;
-      transform:scale(.75);
-      transform-origin:50% 50%;
-      opacity:.3;
-      animation:antSpinMove 1s infinite linear alternate
-    }
-    .loading-dot i:nth-child(1){
-      top:0;
-      left:0
-    }
-    .loading-dot i:nth-child(2){
-      top:0;
-      right:0;
-      -webkit-animation-delay:.4s;
-      animation-delay:.4s
-    }
-    .loading-dot i:nth-child(3){
-      right:0;
-      bottom:0;
-      -webkit-animation-delay:.8s;
-      animation-delay:.8s
-    }
-    .loading-dot i:nth-child(4){
-      bottom:0;
-      left:0;
-      -webkit-animation-delay:1.2s;
-      animation-delay:1.2s
-    }
-    @keyframes antRotate{
-      to{
-        -webkit-transform:rotate(405deg);
-        transform:rotate(405deg)
-      }
-    }
-    @-webkit-keyframes antRotate{to{
-      -webkit-transform:rotate(405deg);
-      transform:rotate(405deg)
-    }
-    }
-    @keyframes antSpinMove{
-      to{
-        opacity:1
-      }
-    }
-    @-webkit-keyframes antSpinMove{
-      to{
-        opacity:1
-      }
-    }
-    </style>
   </head>
   <body>
-  <!-- 当JavaScript被禁用时显示提示信息 -->
+    <!-- 如果禁用了JavaScript，则显示以下内容 -->
     <noscript>
       <strong>We're sorry but vue-antd-pro doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
     </noscript>
-  <!-- 应用的主容器 -->
+    <!-- 应用容器 -->
     <div id="app">
-      <!-- 加载中的遮罩层 -->
+      <!-- 加载动画遮罩层 -->
       <div id="loading-mask">
+          <!-- 加载动画容器 -->
           <div class="loading-wrapper">
+            <!-- 加载动画 -->
             <span class="loading-dot loading-dot-spin"><i></i><i></i><i></i><i></i></span>
           </div>
         </div>
     </div>
-    <!-- built files will be auto injected -->
+    <!-- 自动注入构建文件 -->
   </body>
 </html>

frontend/public/loading/loading.css

@@ -1,52 +1 @@
-#preloadingAnimation{
+#preloadingAnimation{position:fixed;left:0;top:0;height:100%;width:100%;background:#ffffff;user-select:none;z-index: 9999;overflow: hidden}.lds-roller{display:inline-block;position:relative;left:50%;top:50%;transform:translate(-50%,-50%);width:64px;height:64px;}.lds-roller div{animation:lds-roller 1.2s cubic-bezier(0.5,0,0.5,1) infinite;transform-origin:32px 32px;}.lds-roller div:after{content:" ";display:block;position:absolute;width:6px;height:6px;border-radius:50%;background:#13c2c2;margin:-3px 0 0 -3px;}.lds-roller div:nth-child(1){animation-delay:-0.036s;}.lds-roller div:nth-child(1):after{top:50px;left:50px;}.lds-roller div:nth-child(2){animation-delay:-0.072s;}.lds-roller div:nth-child(2):after{top:54px;left:45px;}.lds-roller div:nth-child(3){animation-delay:-0.108s;}.lds-roller div:nth-child(3):after{top:57px;left:39px;}.lds-roller div:nth-child(4){animation-delay:-0.144s;}.lds-roller div:nth-child(4):after{top:58px;left:32px;}.lds-roller div:nth-child(5){animation-delay:-0.18s;}.lds-roller div:nth-child(5):after{top:57px;left:25px;}.lds-roller div:nth-child(6){animation-delay:-0.216s;}.lds-roller div:nth-child(6):after{top:54px;left:19px;}.lds-roller div:nth-child(7){animation-delay:-0.252s;}.lds-roller div:nth-child(7):after{top:50px;left:14px;}.lds-roller div:nth-child(8){animation-delay:-0.288s;}.lds-roller div:nth-child(8):after{top:45px;left:10px;}#preloadingAnimation .load-tips{color: #13c2c2;font-size:2rem;position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);margin-top:80px;text-align:center;width:400px;height:64px;}  @keyframes lds-roller{0%{transform:rotate(0deg);} 100%{transform:rotate(360deg);}}
-  position:fixed;left:0;top:0;height:100%;width:100%;background:#ffffff;user-select:none;
-  z-index: 9999;overflow: hidden}
-.lds-roller{
-  display:inline-block;
-  position:relative;
-  left:50%;
-  top:50%;
-  transform:translate(-50%,-50%);
-  width:64px;
-  height:64px;
-}
-.lds-roller div{
-  animation:lds-roller 1.2s cubic-bezier(0.5,0,0.5,1) infinite;
-  transform-origin:32px 32px;
-}
-.lds-roller div:after{
-  content:" ";
-  display:block;
-  position:absolute;
-  width:6px;
-  height:6px;
-  border-radius:50%;
-  background:#13c2c2;
-  margin:-3px 0 0 -3px;
-}
-.lds-roller div:nth-child(1){animation-delay:-0.036s;}
-.lds-roller div:nth-child(1):after{top:50px;left:50px;}
-.lds-roller div:nth-child(2){animation-delay:-0.072s;}
-.lds-roller div:nth-child(2):after{top:54px;left:45px;}
-.lds-roller div:nth-child(3){animation-delay:-0.108s;}
-.lds-roller div:nth-child(3):after{top:57px;left:39px;}
-.lds-roller div:nth-child(4){animation-delay:-0.144s;}
-.lds-roller div:nth-child(4):after{top:58px;left:32px;}
-.lds-roller div:nth-child(5){animation-delay:-0.18s;}
-.lds-roller div:nth-child(5):after{top:57px;left:25px;}
-.lds-roller div:nth-child(6){animation-delay:-0.216s;}
-.lds-roller div:nth-child(6):after{top:54px;left:19px;}
-.lds-roller div:nth-child(7){animation-delay:-0.252s;}
-.lds-roller div:nth-child(7):after{top:50px;left:14px;}
-.lds-roller div:nth-child(8){animation-delay:-0.288s;}
-.lds-roller div:nth-child(8):after{top:45px;left:10px;}
-#preloadingAnimation .load-tips{
-  color: #13c2c2;
-  font-size:2rem;
-  position:absolute;
-  left:50%;
-  top:50%;
-  transform:translate(-50%,-50%);margin-top:80px;
-  text-align:center;width:400px;height:64px;}
-@keyframes lds-roller{0%{transform:rotate(0deg);}
-  100%{transform:rotate(360deg);}}

frontend/public/loading/loading.html

@@ -1,27 +1 @@
-<div id="preloadingAnimation"><div class=lds-roller><div>
+<div id="preloadingAnimation"><div class=lds-roller><div></div><div></div><div></div><div></div><div></div><div></div><div></div><div></div></div><div class=load-tips>Loading</div></div>
-
-</div>
-  <div>
-
-  </div>
-  <div>
-
-  </div>
-  <div>
-
-  </div>
-  <div>
-
-  </div>
-  <div>
-
-  </div>
-  <div>
-
-  </div>
-  <div>
-
-  </div>
-</div>
-  <div class=load-tips>Loading</div>
-</div>

frontend/public/loading/option2/html_code_segment.html

@@ -1,31 +1,5 @@
-/**
- * 预加载动画
- */
 <div class="preloading-animate">
-  <!--预加载的包装容器  -->
   <div class="preloading-wrapper">
-    <svg class="preloading-balls"
+    <svg class="preloading-balls" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" preserveAspectRatio="xMidYMid"><circle cx="67.802" cy="59.907" r="6" fill="#51CACC"><animate attributeName="cx" values="75;57.72542485937369" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="cy" values="50;73.77641290737884" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="fill" values="#51CACC;#9DF871" keyTimes="0;1" dur="1s" repeatCount="indefinite"/></circle><circle cx="46.079" cy="69.992" r="6" fill="#9DF871"><animate attributeName="cx" values="57.72542485937369;29.774575140626318" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="cy" values="73.77641290737884;64.69463130731182" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="fill" values="#9DF871;#E0FF77" keyTimes="0;1" dur="1s" repeatCount="indefinite"/></circle><circle cx="29.775" cy="52.449" r="6" fill="#E0FF77"><animate attributeName="cx" values="29.774575140626318;29.774575140626315" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="cy" values="64.69463130731182;35.30536869268818" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="fill" values="#E0FF77;#DE9DD6" keyTimes="0;1" dur="1s" repeatCount="indefinite"/></circle><circle cx="41.421" cy="31.521" r="6" fill="#DE9DD6"><animate attributeName="cx" values="29.774575140626315;57.72542485937368" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="cy" values="35.30536869268818;26.22358709262116" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="fill" values="#DE9DD6;#FF708E" keyTimes="0;1" dur="1s" repeatCount="indefinite"/></circle><circle cx="64.923" cy="36.13" r="6" fill="#FF708E"><animate attributeName="cx" values="57.72542485937368;75" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="cy" values="26.22358709262116;49.99999999999999" keyTimes="0;1" dur="1s" repeatCount="indefinite"/><animate attributeName="fill" values="#FF708E;#51CACC" keyTimes="0;1" dur="1s" repeatCount="indefinite"/></circle></svg>
-         xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" preserveAspectRatio="xMidYMid">
-      <circle cx="67.802" cy="59.907" r="6" fill="#51CACC">
-        <animate attributeName="cx" values="75;57.72542485937369" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-        <animate attributeName="cy" values="50;73.77641290737884" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-        <animate attributeName="fill" values="#51CACC;#9DF871" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-      </circle>
-      <circle cx="46.079" cy="69.992" r="6" fill="#9DF871"><animate attributeName="cx" values="57.72542485937369;29.774575140626318" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-      <animate attributeName="cy" values="73.77641290737884;64.69463130731182" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-        <animate attributeName="fill" values="#9DF871;#E0FF77" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-      </circle><circle cx="29.775" cy="52.449" r="6" fill="#E0FF77">
-      <animate attributeName="cx" values="29.774575140626318;29.774575140626315" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-      <animate attributeName="cy" values="64.69463130731182;35.30536869268818" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-      <animate attributeName="fill" values="#E0FF77;#DE9DD6" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-    </circle><circle cx="41.421" cy="31.521" r="6" fill="#DE9DD6"><animate attributeName="cx" values="29.774575140626315;57.72542485937368" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-      <animate attributeName="cy" values="35.30536869268818;26.22358709262116" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-      <animate attributeName="fill" values="#DE9DD6;#FF708E" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-    </circle>
-      <circle cx="64.923" cy="36.13" r="6" fill="#FF708E"><animate attributeName="cx" values="57.72542485937368;75" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-        <animate attributeName="cy" values="26.22358709262116;49.99999999999999" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-        <animate attributeName="fill" values="#FF708E;#51CACC" keyTimes="0;1" dur="1s" repeatCount="indefinite"/>
-      </circle>
-    </svg>
   </div>
 </div>

frontend/public/loading/option2/loading.css

@@ -1,20 +1 @@
-.preloading-animate{
+.preloading-animate{background:#ffffff;width:100%;height:100%;position:fixed;left:0;top:0;z-index:299;}.preloading-animate .preloading-wrapper{position:absolute;width:5rem;height:5rem;left:50%;top:50%;transform:translate(-50%,-50%);}.preloading-animate .preloading-wrapper .preloading-balls{font-size:5rem;}
-  background:#ffffff;
-  width:100%;
-  height:100%;
-  position:fixed;
-  left:0;
-  top:0;
-  z-index:299;
-}
-.preloading-animate .preloading-wrapper{
-  position:absolute;
-  width:5rem;
-  height:5rem;
-  left:50%;
-  top:50%;
-  transform:translate(-50%,-50%);
-}
-.preloading-animate .preloading-wrapper .preloading-balls{
-  font-size:5rem;
-}

frontend/src/App.vue

@@ -1,5 +1,7 @@
 <template>
+  <!-- 使用a-locale-provider组件，设置locale属性为locale -->
   <a-locale-provider :locale="locale">
+    <!-- 在div中渲染router-view组件 -->
     <div id="app">
       <router-view />
     </div>
@@ -7,12 +9,16 @@
 </template>
 
 <script>
+// 引入zh_CN语言包
 import zhCN from 'ant-design-vue/lib/locale-provider/zh_CN'
+// 引入AppDeviceEnquire混入
 import { AppDeviceEnquire } from './utils/mixin'
 
 export default {
+  // 使用AppDeviceEnquire混入
   mixins: [AppDeviceEnquire],
   data () {
+    // 返回locale属性，值为zh_CN
     return {
       locale: zhCN
     }
@@ -23,34 +29,41 @@ export default {
 }
 </script>
 <style>
+/* 设置#app的高度为100% */
 #app {
   height: 100%;
 }
 
+/* 设置h1, h2, h3, h4, h5, h6的行高、字体大小和字体粗细为初始值 */
 h1, h2, h3, h4, h5, h6 {
   line-height: inherit !important;
   font-size: initial !important;
   font-weight: initial !important;
 }
 
+/* 设置.page-header .breadcrumb的背景颜色和内边距为初始值 */
 .page-header .breadcrumb {
   background-color: transparent !important;
   padding: inherit !important;
 }
 
+/* 设置.row的左边距为初始值 */
 .row {
   margin-left: inherit !important;
 }
 
+/* 设置a标签的鼠标悬停效果为无下划线，行高为初始值 */
 a:hover {
   text-decoration: none !important;
   line-height: inherit !important;
 }
 
+/* 设置i标签下的svg的垂直对齐方式为初始值 */
 i > svg {
   vertical-align: initial !important;
 }
 
+/* 设置ul标签的下边距为初始值 */
 ul {
   margin-bottom: inherit !important;
 }

frontend/src/api/exam.js

@@ -1,41 +1,32 @@
-/**
+// 考试相关的接口，包括考试、问题、选项和评分等接口
- * @description: 考试模块接口，包括考试、问题、选项和评分等接口
- */
 
 import api from './index'
 import { axios } from '../utils/request'
 
-/**
+// 导出一个函数，用于获取问题列表
- * @description: 根据传入的参数获取问题列表
- * @param {Object} parameter - 查询参数
- * @returns {Promise} - 返回问题列表的Promise对象
- */
 export function getQuestionList (parameter) {
+  // 使用axios发送get请求，获取问题列表
   return axios({
-    url: api.ExamQuestionList,
+    url: api.ExamQuestionList, // 请求的URL
-    method: 'get',
+    method: 'get', // 请求的方法
-    params: parameter
+    params: parameter // 请求的参数
   })
 }
 
-/**
+// 导出一个函数，用于获取所有题目
- * @description: 获取所有问题
- * @returns {Promise} - 返回所有问题的Promise对象
- */
 export function getQuestionAll () {
+  // 使用axios发送get请求，获取所有题目
   return axios({
     url: api.ExamQuestionAll,
     method: 'get'
   })
 }
 
-/**
+// 导出一个名为questionUpdate的函数，参数为parameter
- * @description: 更新问题信息
- * @param {Object} parameter - 问题更新参数
- * @returns {Promise} - 返回更新操作的Promise对象
- */
 export function questionUpdate (parameter) {
+  // 打印参数
   console.log(parameter)
+  // 返回一个axios请求，请求的url为api.ExamQuestionUpdate，请求方法为post，请求的数据为parameter
   return axios({
     url: api.ExamQuestionUpdate,
     method: 'post',
@@ -43,27 +34,26 @@ export function questionUpdate (parameter) {
   })
 }
 
-/**
+// 导出一个函数，用于获取题目选择
- * @description: 获取问题的选项
- * @returns {Promise} - 返回问题选项的Promise对象
- */
 export function getQuestionSelection () {
+  // 使用axios发送get请求，获取题目选择
   return axios({
+    // 请求的URL
     url: api.ExamQuestionSelection,
+    // 请求的方法
     method: 'get',
+    // 请求的头部信息
     headers: {
       'Content-Type': 'application/json;charset=UTF-8'
     }
   })
 }
 
-/**
+// 导出一个名为questionCreate的函数，参数为parameter
- * @description: 创建新问题
- * @param {Object} parameter - 问题创建参数
- * @returns {Promise} - 返回创建操作的Promise对象
- */
 export function questionCreate (parameter) {
+  // 打印参数
   console.log(parameter)
+  // 使用axios发送post请求，url为api.ExamQuestionCreate，参数为parameter
   return axios({
     url: api.ExamQuestionCreate,
     method: 'post',
@@ -71,12 +61,9 @@ export function questionCreate (parameter) {
   })
 }
 
-/**
+// 导出一个函数，用于获取考试列表
- * @description: 根据传入的参数获取考试列表
- * @param {Object} parameter - 查询参数
- * @returns {Promise} - 返回考试列表的Promise对象
- */
 export function getExamList (parameter) {
+  // 使用axios发送get请求，获取考试列表
   return axios({
     url: api.ExamList,
     method: 'get',
@@ -84,22 +71,18 @@ export function getExamList (parameter) {
   })
 }
 
-/**
+// 导出一个函数，用于获取所有考试
- * @description: 获取所有考试
- * @returns {Promise} - 返回所有考试的Promise对象
- */
 export function getExamAll () {
+  // 使用axios发送get请求，获取所有考试
   return axios({
     url: api.ExamAll,
     method: 'get'
   })
 }
 
-/**
+// 导出一个函数，用于获取所有问题，按照单选、多选和判断进行分类
- * @description: 获取所有问题，并按单选、多选和判断进行分类
- * @returns {Promise} - 返回分类问题列表的Promise对象
- */
 export function getExamQuestionTypeList () {
+  // 使用axios发送get请求，获取所有问题，按照单选、多选和判断进行分类
   return axios({
     url: api.ExamQuestionTypeList,
     method: 'get',
@@ -109,11 +92,9 @@ export function getExamQuestionTypeList () {
   })
 }
 
-/**
+// 导出一个函数，用于获取考试卡片列表
- * @description: 获取考试卡片列表
- * @returns {Promise} - 返回考试卡片列表的Promise对象
- */
 export function getExamCardList () {
+  // 使用axios发送get请求，获取考试卡片列表
   return axios({
     url: api.ExamCardList,
     method: 'get',
@@ -123,13 +104,11 @@ export function getExamCardList () {
   })
 }
 
-/**
+// 导出一个函数examCreate，用于创建考试
- * @description: 创建新考试
- * @param {Object} parameter - 考试创建参数
- * @returns {Promise} - 返回创建操作的Promise对象
- */
 export function examCreate (parameter) {
+  // 打印传入的参数
   console.log(parameter)
+  // 返回一个axios请求，请求的url为api.ExamCreate，请求方法为post，请求的数据为parameter
   return axios({
     url: api.ExamCreate,
     method: 'post',
@@ -137,56 +116,44 @@ export function examCreate (parameter) {
   })
 }
 
-/**
+// 导出一个函数examUpdate，用于更新考试
- * @description: 更新考试信息
- * @param {Object} parameter - 考试更新参数
- * @returns {Promise} - 返回更新操作的Promise对象
- */
 export function examUpdate (parameter) {
+  // 打印传入的参数
   console.log(parameter)
+  // 返回一个axios请求，请求的url为api.ExamUpdate，请求方法为post，请求的数据为parameter
   return axios({
     url: api.ExamUpdate,
     method: 'post',
     data: parameter
   })
 }
-
+// 导出一个函数，用于获取考试详情
-/**
- * @description: 根据考试ID获取考试详情
- * @param {String} examId - 考试ID
- * @returns {Promise} - 返回考试详情的Promise对象
- */
 export function getExamDetail (examId) {
+  // 使用axios发送get请求，获取考试详情
   return axios({
-    url: api.ExamDetail + examId,
+    url: api.ExamDetail + examId, // 请求的URL，拼接了examId
-    method: 'get',
+    method: 'get', // 请求方法为get
     headers: {
-      'Content-Type': 'application/json;charset=UTF-8'
+      'Content-Type': 'application/json;charset=UTF-8' // 设置请求头，指定请求体的类型为json
     }
   })
 }
 
-/**
+// 导出一个函数，用于获取考试记录详情
- * @description: 根据记录ID获取考试记录详情
- * @param {String} recordId - 记录ID
- * @returns {Promise} - 返回考试记录详情的Promise对象
- */
 export function getExamRecordDetail (recordId) {
+  // 使用axios发送get请求，获取考试记录详情
   return axios({
-    url: api.recordDetail + recordId,
+    url: api.recordDetail + recordId, // 请求的URL，拼接了recordId
-    method: 'get',
+    method: 'get', // 请求方法为get
     headers: {
-      'Content-Type': 'application/json;charset=UTF-8'
+      'Content-Type': 'application/json;charset=UTF-8' // 设置请求头，指定请求体的类型为json
     }
   })
 }
 
-/**
+// 导出一个函数，用于获取问题详情
- * @description: 根据问题ID获取问题详情
- * @param {String} questionId - 问题ID
- * @returns {Promise} - 返回问题详情的Promise对象
- */
 export function getQuestionDetail (questionId) {
+  // 使用axios发送get请求，获取问题详情
   return axios({
     url: api.QuestionDetail + questionId,
     method: 'get',
@@ -196,14 +163,11 @@ export function getQuestionDetail (questionId) {
   })
 }
 
-/**
+// 导出一个函数，用于完成考试
- * @description: 提交考试答案，完成考试
- * @param {String} examId - 考试ID
- * @param {Object} answersMap - 答案映射
- * @returns {Promise} - 返回完成考试的Promise对象
- */
 export function finishExam (examId, answersMap) {
+  // 打印答案
   console.log(answersMap)
+  // 使用axios发送post请求，完成考试
   return axios({
     url: api.FinishExam + examId,
     method: 'post',
@@ -214,11 +178,9 @@ export function finishExam (examId, answersMap) {
   })
 }
 
-/**
+// 导出一个函数，用于获取考试记录列表
- * @description: 获取所有考试记录
- * @returns {Promise} - 返回所有考试记录的Promise对象
- */
 export function getExamRecordList () {
+  // 使用axios发送get请求，获取考试记录列表
   return axios({
     url: api.ExamRecordList,
     method: 'get',

frontend/src/api/index.js

@@ -1,117 +1,61 @@
-/**
+// 定义一个api对象，包含各种接口的路径
- * @description: api接口统一管理
- */
 const api = {
-  /**
+  // 登录接口
-   * @description: 用户登录的接口
-   */
   Login: '/auth/login',
-  /**
+  // 登出接口
-   * @description: 用户注销的接口
-   */
   Logout: '/auth/logout',
-  /**
+  // 密码找回接口
-   * @description: 重置密码的接口
-   */
   ForgePassword: '/auth/forge-password',
-  /**
+  // 注册接口
-   * @description: 用户注册的接口
-   */
   Register: '/auth/register',
-  /**
+  // 二维码接口
-   * @description: 两步验证码的接口
-   */
   twoStepCode: '/auth/2step-code',
-  /**
+  // 发送短信接口
-   * @description: 发送短信的接口
-   */
   SendSms: '/account/sms',
-  /**
+  // 发送短信错误接口
-   * @description: 发送短信错误的接口
-   */
   SendSmsErr: '/account/sms_err',
-  /**
+  // 获取用户信息接口
-   * @description: 获取用户信息的接口
-   */
   UserInfo: '/user/info',
 
   // 下面是自己的用户认证的接口
-  /**
+  // 用户注册接口
-   * @description: 用户注册（自定义）的接口
-   */
   UserRegister: '/user/register',
-  /**
+  // 用户登录接口
-   * @description: 用户登录（自定义）的接口
-   */
   UserLogin: '/user/login',
 
   // 考试的接口
-  /**
+  // 获取问题列表接口
-   * @description: 获取考试问题列表的接口
-   */
   ExamQuestionList: '/exam/question/list',
-  /**
+  // 获取所有问题接口
-   * @description: 获取所有考试问题的接口
-   */
   ExamQuestionAll: '/exam/question/all',
-  /**
+  // 更新问题接口
-   * @description: 更新考试问题的接口
-   */
   ExamQuestionUpdate: '/exam/question/update',
-  /**
+  // 选择问题接口
-   * @description: 选择考试问题的接口
-   */
   ExamQuestionSelection: '/exam/question/selection',
-  /**
+  // 创建问题接口
-   * @description: 创建考试问题的接口
-   */
   ExamQuestionCreate: '/exam/question/create',
-  /**
+  // 获取考试列表接口
-   * @description: 获取考试列表的接口
-   */
   ExamList: '/exam/list',
-  /**
+  // 获取所有考试接口
-   * @description: 获取所有考试的接口
-   */
   ExamAll: '/exam/all',
-  /**
+  // 获取问题列表，按照单选、多选和判断进行分类接口
-   * @description: 按照单选、多选和判断分类获取问题列表的接口
-   */
   ExamQuestionTypeList: '/exam/question/type/list',
-  /**
+  // 创建考试接口
-   * @description: 创建考试的接口
-   */
   ExamCreate: '/exam/create',
-  /**
+  // 更新考试接口
-   * @description: 更新考试的接口
-   */
   ExamUpdate: '/exam/update',
-  /**
+  // 获取考试卡片列表接口
-   * @description: 获取考试卡片列表的接口
-   */
   ExamCardList: '/exam/card/list',
-  /**
+  // 获取考试详情接口
-   * @description: 获取考试详情的接口
-   */
   ExamDetail: '/exam/detail/',
-  /**
+  // 获取问题详情接口
-   * @description: 获取问题详情的接口
-   */
   QuestionDetail: '/exam/question/detail/',
-  /**
+  // 交卷接口
-   * @description: 交卷的接口
-   */
   FinishExam: '/exam/finish/',
-  /**
+  // 获取考试记录列表接口
-   * @description: 获取考试记录列表的接口
-   */
   ExamRecordList: '/exam/record/list',
-  /**
+  // 获取考试记录详情接口
-   * @description: 获取考试记录详情的接口
-   */
   recordDetail: '/exam/record/detail/'
 }
-/**
+// 导出api对象
- * @description: 默认导出api对象
+export default api
- */
-export default api