Merge pull request '更新注释文档' (#2) from feature/wyh into develop

README.md

@@ -1,18 +1,108 @@
- ResultVO<RecordDetailVo> getExamRecordDetail(@PathVariable String recordId) {
+# spring-boot-online-exam
-        // 定义返回结果
+
-        ResultVO<RecordDetailVo> resultVO;
+> 在线Demo预览，http://129.211.88.191 ，账户分别是admin、teacher、student，密码是admin123。视频讲解代码：https://www.bilibili.com/video/BV1FP4y1L7xt/
-        try {
+
-            // 调用examService获取考试记录详情
+> 好消息！！！一个小伙伴做了Python实现，欢迎大家star：https://github.com/xingxingzaixian/django-drf-online-exam
-            RecordDetailVo recordDetailVo = examService.getRecordDetail(recordId);
+
-            // 返回成功结果
+## 1.快速体验
-            resultVO = new ResultVO<>(0, "获取考试记录详情成功", recordDetailVo);
+### 1.1 事先准备
-        } catch (Exception e) {
+> clone代码并进入代码路径
-            // 打印异常信息
+
-            e.printStackTrace();
+```shell
-            // 返回失败结果
+git clone git@github.com:lsgwr/spring-boot-online-exam.git
-            resultVO = new ResultVO<>(-1, "获取考试记录详情失败", null);
+cd spring-boot-online-exam
-        }
+```
-        // 返回结果
+
-        return resultVO;
+下面按照Linux和windows说明快速搭建的方法
-    }
+### 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

@@ -3,6 +3,9 @@ package lsgwr.exam;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
+/**
+ * 这是Spring Boot应用程序的主要类。它作为应用程序的入口点，启动Spring Boot应用程序上下文。
+ */
 @SpringBootApplication
 public class ExamApplication {
 

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

@@ -1,9 +1,6 @@
-/***********************************************************
+/**
- * @Description : 考试服务
+ * @Description : 这是一个REST控制器,处理与考试、问题和考试记录相关的HTTP请求,它包括创建、更新和检索考试和问题的方法,以及处理用户提交和评分。
- * @author      : 梁山广(Laing Shan Guang)
+ */
- * @date        : 2019-05-28 08:04
- * @email       : liangshanguang2@gmail.com
- ***********************************************************/
 package lsgwr.exam.controller;
 
 import lsgwr.exam.entity.Exam;
@@ -22,54 +19,58 @@ import java.util.List;
 
 @RestController
 @Api(tags = "Exam APIs")
+//将此控制器中的所有端点映射到/api/exam URL路径
 @RequestMapping("/api/exam")
 public class ExamController {
-    @Autowired
+    @Autowired //注入一个ExamService实例，用于处理与考试和问题相关的业务逻辑
     private ExamService examService;
 
+    /**
+     * @Description: 使用examService.getQuestionAll()获取数据,并将其包装在ResultVO对象中,用于获取所有考试列表
+     * @ApiOperation注解用于描述API操作,它将显示在SwaggerUI中
+     */
     @GetMapping("/question/all")
     @ApiOperation("获取所有问题的列表")
-   // 获取全部问题列表
     ResultVO<List<QuestionVo>> getQuestionAll() {
-        // 定义返回值
         ResultVO<List<QuestionVo>> resultVO;
         try {
-            // 调用examService获取全部问题列表
             List<QuestionVo> questionAll = examService.getQuestionAll();
-            // 返回成功结果
             resultVO = new ResultVO<>(0, "获取全部问题列表成功", questionAll);
         } catch (Exception e) {
-            // 打印异常信息
             e.printStackTrace();
-            // 返回失败结果
             resultVO = new ResultVO<>(-1, "获取全部问题列表失败", null);
         }
-        // 返回结果
         return resultVO;
     }
 
+    /**
+     * @Description: 从请求体中获取一个QuestionVo对象，并使用examService.updateQuestion()更新问题
+     * @param questionVo 从请求体中获取的QuestionVo对象
+     */
     @PostMapping("/question/update")
     @ApiOperation("更新问题")
     ResultVO<QuestionVo> questionUpdate(@RequestBody QuestionVo questionVo) {
         // 完成问题的更新
         System.out.println(questionVo);
         try {
-            // 调用examService的updateQuestion方法，更新问题
             QuestionVo questionVoResult = examService.updateQuestion(questionVo);
-            // 返回更新成功的结果
             return new ResultVO<>(0, "更新问题成功", questionVoResult);
         } catch (Exception e) {
-            // 打印异常信息
             e.printStackTrace();
-            // 返回更新失败的结果
             return new ResultVO<>(-1, "更新问题失败", null);
         }
     }
 
+    /**
+     * 创建问题
+     * @Description: 从请求体中获取一个QuestionCreateSimplifyVo对象，将其属性复制到QuestionCreateVo，设置创建者的ID，并使用examService.questionCreate()创建问题。
+     * @param questionCreateSimplifyVo 从请求体中获取的QuestionCreateSimplifyVo对象
+     * @param request HttpServletRequest对象，用于获取当前用户的ID
+     * @return ResultVO<String> 对象，包含操作结果信息
+     */
     @PostMapping("/question/create")
     @ApiOperation("创建问题")
     ResultVO<String> questionCreate(@RequestBody QuestionCreateSimplifyVo questionCreateSimplifyVo, HttpServletRequest request) {
-        // 创建一个QuestionCreateVo对象
         QuestionCreateVo questionCreateVo = new QuestionCreateVo();
         // 把能拷贝过来的属性都拷贝过来
         BeanUtils.copyProperties(questionCreateSimplifyVo, questionCreateVo);
@@ -78,33 +79,34 @@ ResultVO<List<QuestionVo>> getQuestionAll() {
         questionCreateVo.setQuestionCreatorId(userId);
         System.out.println(questionCreateVo);
         try {
-            // 调用examService的questionCreate方法创建问题
             examService.questionCreate(questionCreateVo);
-            // 返回问题创建成功的ResultVO
             return new ResultVO<>(0, "问题创建成功", null);
         } catch (Exception e) {
-            // 打印异常信息
             e.printStackTrace();
-            // 返回创建问题失败的ResultVO
             return new ResultVO<>(-1, "创建问题失败", null);
         }
     }
 
+    /**
+     * @Description: 获取全部问题列表,使用examService.getSelections()获取数据，并将其包装在ResultVO对象中
+     * @return ResultVO<QuestionAllVo> 对象，包含问题列表
+     */
     @GetMapping("/question/selection")
     @ApiOperation("获取问题分类的相关选项")
-   // 获取问题分类选项
     ResultVO<QuestionSelectionVo> getSelections() {
-        // 调用examService的getSelections方法获取问题分类选项
         QuestionSelectionVo questionSelectionVo = examService.getSelections();
-        // 如果获取成功
         if (questionSelectionVo != null) {
-            // 返回成功的结果
             return new ResultVO<>(0, "获取问题分类选项成功", questionSelectionVo);
         } else {
-            // 否则返回失败的结果
             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) {
@@ -112,115 +114,121 @@ ResultVO<QuestionSelectionVo> getSelections() {
         System.out.println(id);
         ResultVO<QuestionDetailVo> resultVO;
         try {
-            // 调用examService的getQuestionDetail方法，根据问题id获取问题的详细信息
             QuestionDetailVo questionDetailVo = examService.getQuestionDetail(id);
-            // 如果获取成功，则返回ResultVO对象，状态码为0，提示信息为"获取问题详情成功"，数据为questionDetailVo
             resultVO = new ResultVO<>(0, "获取问题详情成功", questionDetailVo);
         } catch (Exception e) {
-            // 如果获取失败，则打印异常信息，并返回ResultVO对象，状态码为-1，提示信息为"获取问题详情失败"，数据为null
             e.printStackTrace();
             resultVO = new ResultVO<>(-1, "获取问题详情失败", null);
         }
-        // 返回ResultVO对象
         return resultVO;
     }
+
+    /**
+     * @Description: 使用examService.getExamAll()获取数据,并将其包装在ResultVO对象中,用于获取全部考试列表
+     * @return ResultVO<QuestionDetailVo> 对象，包含考试列表详情
+     */
     @GetMapping("/all")
     @ApiOperation("获取全部考试的列表")
     ResultVO<List<ExamVo>> getExamAll() {
         // 需要拼接前端需要的考试列表对象
         ResultVO<List<ExamVo>> resultVO;
         try {
-            // 调用examService的getExamAll方法获取全部考试的列表
             List<ExamVo> examVos = examService.getExamAll();
-            // 将获取到的考试列表封装到ResultVO对象中，并返回
             resultVO = new ResultVO<>(0, "获取全部考试的列表成功", examVos);
         } catch (Exception e) {
-            // 捕获异常，并打印异常信息
             e.printStackTrace();
-            // 将异常信息封装到ResultVO对象中，并返回
             resultVO = new ResultVO<>(-1, "获取全部考试的列表失败", null);
         }
         return resultVO;
     }
+
+    /**
+     * @Description: 使用examService.getExamQuestionTypeList()获取数据,并将其包装在ResultVO对象中,用于获取问题列表
+     * @return ResultVO<ExamQuestionTypeVo> 对象，包含问题列表
+     */
     @GetMapping("/question/type/list")
     @ApiOperation("获取问题列表，按照单选、多选和判断题分类返回")
     ResultVO<ExamQuestionTypeVo> getExamQuestionTypeList() {
         // 获取问题的分类列表
         ResultVO<ExamQuestionTypeVo> resultVO;
         try {
-            // 调用examService的getExamQuestionType方法获取问题分类列表
             ExamQuestionTypeVo examQuestionTypeVo = examService.getExamQuestionType();
-            // 如果获取成功，则返回成功的结果
             resultVO = new ResultVO<>(0, "获取问题列表成功", examQuestionTypeVo);
         } catch (Exception e) {
-            // 如果获取失败，则打印异常信息，并返回失败的结果
             e.printStackTrace();
             resultVO = new ResultVO<>(-1, "获取问题列表失败", null);
         }
-        // 返回结果
         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;
-        // 获取当前用户的id
         String userId = (String) request.getAttribute("user_id");
         try {
-            // 调用examService的create方法，将examCreateVo和userId作为参数传入，创建考试
             Exam exam = examService.create(examCreateVo, userId);
-            // 创建一个ResultVO对象，将创建成功的考试信息返回
             resultVO = new ResultVO<>(0, "创建考试成功", exam);
         } catch (Exception e) {
-            // 捕获异常，打印异常信息，并创建一个ResultVO对象，将创建失败的考试信息返回
             e.printStackTrace();
             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) {
         // 从前端传参数过来，在这里完成考试的入库
         ResultVO<Exam> resultVO;
-        // 获取当前用户id
         String userId = (String) request.getAttribute("user_id");
         try {
-            // 调用service层更新考试
             Exam exam = examService.update(examVo, userId);
-            // 返回更新成功的resultVO
             resultVO = new ResultVO<>(0, "更新考试成功", exam);
         } catch (Exception e) {
-            // 打印异常信息
             e.printStackTrace();
-            // 返回更新失败的resultVO
             resultVO = new ResultVO<>(-1, "更新考试失败", null);
         }
         return resultVO;
     }
 
+    /**
+     * @Description: 获取考试列表，适配前端卡片列表
+     * @return ResultVO<List<ExamCardVo>> 对象，包含考试列表卡片信息
+     */
     @GetMapping("/card/list")
     @ApiOperation("获取考试列表，适配前端卡片列表")
     ResultVO<List<ExamCardVo>> getExamCardList() {
         // 获取考试列表卡片
         ResultVO<List<ExamCardVo>> resultVO;
         try {
-            // 调用examService的getExamCardList方法获取考试列表卡片
             List<ExamCardVo> examCardVoList = examService.getExamCardList();
-            // 如果获取成功，则返回成功的结果
             resultVO = new ResultVO<>(0, "获取考试列表卡片成功", examCardVoList);
         } catch (Exception e) {
-            // 如果获取失败，则打印异常信息，并返回失败的结果
             e.printStackTrace();
             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) {
@@ -235,30 +243,37 @@ ResultVO<QuestionSelectionVo> getSelections() {
         return 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;
         try {
             // 拦截器里设置上的用户id
             String userId = (String) request.getAttribute("user_id");
             // 下面根据用户提交的信息进行判分,返回用户的得分情况
             ExamRecord examRecord = examService.judge(userId, examId, answersMap);
-            // 返回结果
             resultVO = new ResultVO<>(0, "考卷提交成功", examRecord);
         } catch (Exception e) {
             e.printStackTrace();
-            // 返回错误结果
             resultVO = new ResultVO<>(-1, "考卷提交失败", null);
         }
         return resultVO;
     }
 
+    /**
+     * @Description: 使用examService.getExamRecordList获取数据,并将其包装在ResultVO对象中,用于获取当前用户的考试记录
+     * @param request 获取用户id
+     * @return ResultVO<List<ExamRecordVo>> 返回一个包含考试记录列表的ResultVO对象，如果发生异常，则返回一个包含错误信息的ResultVO对象。
+     */
     @GetMapping("/record/list")
     @ApiOperation("获取当前用户的考试记录")
-    // 获取考试记录列表
     ResultVO<List<ExamRecordVo>> getExamRecordList(HttpServletRequest request) {
         ResultVO<List<ExamRecordVo>> resultVO;
         try {
@@ -274,23 +289,22 @@ ResultVO<QuestionSelectionVo> getSelections() {
         return resultVO;
     }
 
+    /**
+     * @Description: 使用examService.getExamRecordDetail获取数据,并将其包装在ResultVO对象中,用于获取指定id的考试记录详情
+     * @param recordId 考试记录id
+     * @return ResultVO<RecordDetailVo> 返回一个包含考试记录详情的ResultVO对象，如果发生异常，则返回一个包含错误信息的ResultVO对象。
+     */
     @GetMapping("/record/detail/{recordId}")
     @ApiOperation("根据考试记录id获取考试记录详情")
     ResultVO<RecordDetailVo> getExamRecordDetail(@PathVariable String recordId) {
-        // 定义返回结果
         ResultVO<RecordDetailVo> resultVO;
         try {
-            // 调用examService获取考试记录详情
             RecordDetailVo recordDetailVo = examService.getRecordDetail(recordId);
-            // 返回成功结果
             resultVO = new ResultVO<>(0, "获取考试记录详情成功", recordDetailVo);
         } catch (Exception e) {
-            // 打印异常信息
             e.printStackTrace();
-            // 返回失败结果
             resultVO = new ResultVO<>(-1, "获取考试记录详情失败", null);
         }
-        // 返回结果
         return resultVO;
     }
 }

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

@@ -42,49 +42,37 @@ public class UploadDownloadController {
 
     @ApiOperation("单文件上传,支持同时传入参数")
     @PostMapping("/api/upload/singleAndparas")
-    // 单文件上传
     public String uploadFileSingle(@RequestParam("dir") String dir, @RequestParam("file") MultipartFile uploadfile) {
-        // 调用FileTransUtil工具类中的uploadFile方法，将上传的文件和目录作为参数传入
         return FileTransUtil.uploadFile(uploadfile, dir);
     }
 
-    // 单文件上传，支持同时传入参数，Model
     @ApiOperation("单文件上传,支持同时传入参数,Model")
     @PostMapping("/upload/single/model")
     public String singleUploadFileModel(@ModelAttribute("model") UploadModel2 model) {
-        // 调用FileTransUtil工具类中的uploadFile方法，将上传的文件和目录作为参数传入
         return FileTransUtil.uploadFile(model.getFile(), model.getDir());
     }
 
-    // 多文件上传，支持同时传入参数
     @ApiOperation("多文件上传,支持同时传入参数")
     @PostMapping("upload/multiAndparas")
     public String uploadFileMulti(@RequestParam("dir") String dir, @RequestParam("files") MultipartFile[] uploadfiles) {
-        // 调用FileTransUtil工具类中的uploadFiles方法，将上传的文件数组和目录作为参数传入
         return FileTransUtil.uploadFiles(uploadfiles, dir);
     }
 
-    // 多文件上传，支持同时传入参数
     @ApiOperation("多文件上传,支持同时传入参数")
     @PostMapping(value = "/upload/multi/model")
     public String multiUploadFileModel(@ModelAttribute(("model")) UploadModel model) {
-        // 调用FileTransUtil工具类中的uploadFiles方法，将上传的文件数组和目录作为参数传入
         return FileTransUtil.uploadFiles(model.getFiles(), model.getDir());
     }
 
-    // Get下载文件
     @ApiOperation("Get下载文件")
     @GetMapping(value = "/download/get")
     public ResponseEntity<InputStreamResource> downloadFileGet(@RequestParam String filePath) throws IOException {
-        // 调用FileTransUtil工具类中的downloadFile方法，将文件路径作为参数传入
         return FileTransUtil.downloadFile(filePath);
     }
 
-    // Post下载文件
     @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

@@ -70,15 +70,10 @@ public class UserController {
 
     @GetMapping("/info")
     @ApiOperation("获取用户的详细信息，包括个人信息页面和操作权限")
-    // 获取用户信息的接口
     ResultVO<UserInfoVo> getInfo(HttpServletRequest request) {
-        // 打印进入接口的日志
         System.out.println("进入/user/info的获取用户信息的接口");
-        // 获取用户ID
         String userId = (String) request.getAttribute("user_id");
-        // 调用userService获取用户信息
         UserInfoVo userInfoVo = userService.getInfo(userId);
-        // 返回结果
         return new ResultVO<>(ResultEnum.GET_INFO_SUCCESS.getCode(), ResultEnum.GET_INFO_SUCCESS.getMessage(), userInfoVo);
     }
 

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

@@ -1,24 +1,38 @@
-/***********************************************************
- * @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;
 import lombok.Data;
-
+/**
+ * @Description: 用于表示考试卡片的信息,这个类可以很方便地与JSON数据绑定
+ * 用于从API响应中解析考试卡片信息,将考试卡片信息序列化为JSON格式发送到服务器
+ * Lombok库的@Data注解用于自动生成getter和setter方法
+ * Jackson库的@JsonProperty注解用于指定JSON序列化和反序列化时使用的属性名称。
+ */
 @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;
     /**