Update SystemController.java

src/main/java/com/zsz/controller/SystemController.java

@@ -1,255 +1,368 @@
 package com.zsz.controller;
 
+// 导入 MyBatis-Plus 的条件查询包装器，用于构建查询条件
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+// 导入系统工具类，可能包含一些系统级别的配置或操作方法
 import com.zsz.config.SystemUtil;
+// 导入管理员实体类，用于封装管理员信息
 import com.zsz.pojo.Admin;
+// 导入登录表单实体类，用于封装用户登录时提交的信息
 import com.zsz.pojo.LoginForm;
+// 导入学生实体类，用于封装学生信息
 import com.zsz.pojo.Student;
+// 导入教师实体类，用于封装教师信息
 import com.zsz.pojo.Teacher;
+// 导入管理员服务类，用于调用管理员相关的业务逻辑
 import com.zsz.service.AdminService;
+// 导入学生服务类，用于调用学生相关的业务逻辑
 import com.zsz.service.StudentService;
+// 导入教师服务类，用于调用教师相关的业务逻辑
 import com.zsz.service.TeacherService;
+// 导入自定义的工具类，如 MD5 加密、JWT 工具等
 import com.zsz.util.*;
+// 导入 Swagger 注解，用于生成 API 文档
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
+// 导入 Spring 框架的自动注入注解和 Web 相关注解
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
+// 导入 Spring 框架的资源注入注解
 import org.springframework.web.multipart.MultipartFile;
-
 import javax.annotation.Resource;
+// 导入 Java 图像处理相关类，用于处理验证码图片
 import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+// 导入 Java Servlet 相关类，用于处理 HTTP 请求和响应
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
-import java.awt.image.BufferedImage;
 import java.io.IOException;
+// 导入 Java 集合类，用于存储和操作数据
 import java.util.LinkedHashMap;
 import java.util.Map;
 
 import static com.zsz.config.ConfigurerAdapter.PATH_PREFIX;
 
+/**
+ * 系统控制器，处理与系统相关的 HTTP 请求，如登录、头像上传、获取用户信息等
+ */
 @Api("系统控制器")
+// 标识该类为 RESTful 风格的控制器
 @RestController
+// 设置该控制器处理的请求路径前缀
 @RequestMapping("/sms/system")
 public class SystemController {
 
+    // 自动注入管理员服务类的实例，用于调用管理员相关的业务逻辑
     @Autowired
     AdminService adminService;
+    // 自动注入学生服务类的实例，用于调用学生相关的业务逻辑
     @Autowired
     StudentService studentService;
+    // 自动注入教师服务类的实例，用于调用教师相关的业务逻辑
     @Autowired
     TeacherService teacherService;
 
+    // 注入系统工具类的实例，可能用于系统级别的配置或操作
     @Resource
     private SystemUtil systemUtil;
 
+    // 注入本地文件上传工具类的实例，用于处理文件上传操作
     @Resource
     private LocalUploadUtil localUploadUtil;
 
-    //  http://localhost:8080/sms/system/headerImgUpload
+    /**
+     * 头像上传接口
+     * 请求 URL 示例：http://localhost:8080/sms/system/headerImgUpload
+     * @param multipartFile 前端上传的头像文件
+     * @return 封装了上传结果（文件路径）的结果对象
+     */
     @ApiOperation("头像上传")
+    // 处理 POST 请求，用于上传头像文件
     @PostMapping("/headerImgUpload")
     public Result headerImgUpload(
+            // 从请求中获取上传的文件，并使用 Swagger 注解进行参数描述
             @RequestPart("multipartFile") MultipartFile multipartFile
     ) {
-
+        // 调用本地文件上传工具类的上传方法，保存图片并返回文件路径
-        //保存图片
-
         String upload = localUploadUtil.upload(multipartFile);
-
+        // 将上传结果封装到自定义的结果对象中并返回
         return Result.ok(upload);
     }
 
-    //从请求头中的token信息获取用户类型，并响应用户信息
+    /**
-    @ApiOperation("从请求头中的token信息中获取用户类型，并响应用户信息")
+     * 从请求头中的 token 信息获取用户类型，并响应用户信息
+     * @param token 请求头中的 token 信息
+     * @return 封装了用户类型和用户信息的结果对象
+     */
+    @ApiOperation("从请求头中的 token 信息中获取用户类型，并响应用户信息")
+    // 处理 GET 请求，用于根据 token 获取用户信息
     @GetMapping("/getInfo")
     public Result getInfoByToken(
-            @ApiParam("请求头中的token信息") @RequestHeader("token") String token) {
+            // 从请求头中获取 token 信息，并使用 Swagger 注解进行参数描述
-        //验证token是否已经失效
+            @ApiParam("请求头中的 token 信息") @RequestHeader("token") String token) {
+        // 验证 token 是否已经失效
         boolean expiration = JwtHelper.isExpiration(token);
         if (expiration) {
+            // 如果 token 失效，返回错误结果对象
             return Result.build(null, ResultCodeEnum.TOKEN_ERROR);
         }
+        // 从 token 中获取用户 ID
         Long userId = JwtHelper.getUserId(token);
+        // 从 token 中获取用户类型
         Integer userType = JwtHelper.getUserType(token);
+        // 创建一个有序的 Map 集合，用于存储用户类型和用户信息
         Map<String, Object> stringObjectLinkedHashMap = new LinkedHashMap<>();
+        // 根据用户类型进行不同的处理
         switch (userType) {
             case 1:
+                // 如果是管理员类型，调用管理员服务类的方法获取管理员信息
                 Admin admin = adminService.getAdminById(userId);
+                // 将用户类型和管理员信息存入 Map 集合
                 stringObjectLinkedHashMap.put("userType", 1);
                 stringObjectLinkedHashMap.put("user", admin);
                 break;
             case 2:
+                // 如果是学生类型，调用学生服务类的方法获取学生信息
                 Student student = studentService.getStudentById(userId);
+                // 将用户类型和学生信息存入 Map 集合
                 stringObjectLinkedHashMap.put("userType", 2);
                 stringObjectLinkedHashMap.put("user", student);
                 break;
             case 3:
+                // 如果是教师类型，调用教师服务类的方法获取教师信息
                 Teacher teacher = teacherService.getTeacherById(userId);
+                // 将用户类型和教师信息存入 Map 集合
                 stringObjectLinkedHashMap.put("userType", 3);
                 stringObjectLinkedHashMap.put("user", teacher);
                 break;
         }
+        // 将包含用户类型和用户信息的 Map 集合封装到结果对象中并返回
         return Result.ok(stringObjectLinkedHashMap);
     }
 
-    //将前端提交POST请求的信息封装起来，使用@RequestBody注解
+    /**
+     * 登录功能实现，首先校验验证码是否失效和正确，然后从提交的表单中判断用户类型，获取不同的响应信息
+     * @param loginForm 用户登录提交的表单
+     * @param request HTTP 请求对象
+     * @return 封装了登录结果（token 或错误信息）的结果对象
+     */
     @ApiOperation("登录功能实现，首先校验验证码是否失效和正确，然后从提交的表单中判断用户类型，获取不同的响应信息")
+    // 处理 POST 请求，用于用户登录操作
     @PostMapping("/login")
     public Result login(
+            // 从请求体中获取用户登录提交的表单信息，并使用 Swagger 注解进行参数描述
             @ApiParam("用户登录提交的表单") @RequestBody LoginForm loginForm,
+            // 获取 HTTP 请求对象，用于获取 session 信息
             @ApiParam("请求") HttpServletRequest request) {
-        //校验用户输入的验证码和session中的验证码
+        // 获取当前请求的 session 对象
         HttpSession session = request.getSession();
+        // 从 session 中获取之前生成的验证码
         String sessionVerifiCode = (String) session.getAttribute("verifiCode");
+        // 从登录表单中获取用户输入的验证码
         String loginVerifiCode = loginForm.getVerifiCode();
-        //1.session中验证码失效了
+        // 1. 检查 session 中验证码是否失效
         if ("".equals(sessionVerifiCode)) {
+            // 如果验证码失效，返回错误结果对象并提示用户刷新页面重试
             return Result.fail().message("验证码失效，请刷新页面重试");
         }
+        // 检查用户输入的验证码与 session 中的验证码是否一致（忽略大小写）
         if (!loginVerifiCode.equalsIgnoreCase(sessionVerifiCode)) {
+            // 如果验证码输入有误，返回错误结果对象并提示用户
             return Result.fail().message("验证码输入有误！");
         }
-        //验证码使用完毕，移除当前请求域中的验证码
+        // 验证码使用完毕，移除当前请求域中的验证码，防止重复使用
         session.removeAttribute("verifiCode");
 
-        //准备一个map集合，存放用户响应的信息
+        // 准备一个有序的 Map 集合，用于存放用户响应的信息（如 token）
         Map<String, Object> map = new LinkedHashMap<>();
-        //2.根据选择的用户类型去不同角色的用户表中查询用户，判断用户名和密码是否正确
+        // 2. 根据选择的用户类型去不同角色的用户表中查询用户，判断用户名和密码是否正确
         switch (loginForm.getUserType()) {
             case 1:
                 try {
-                    //调用服务层登录方法,根据用户提交的LoginInfo信息,查询对应的Admin对象,找不到返回Null
+                    // 调用管理员服务类的登录方法，根据用户提交的登录信息查询对应的管理员对象，找不到返回 null
                     Admin admin = adminService.login(loginForm);
                     if (admin != null) {
-                        //登录成功，将用户ID和用户类型转换为token口令，作为信息响应给前端
+                        // 如果登录成功，将用户 ID 和用户类型转换为 token 口令，存入 Map 集合
                         map.put("token", JwtHelper.createToken(admin.getId().longValue(), 1));
                     } else {
+                        // 如果用户名或密码有误，抛出运行时异常
                         throw new RuntimeException("用户名或者密码有误！");
                     }
+                    // 将包含 token 的 Map 集合封装到结果对象中并返回
                     return Result.ok(map);
                 } catch (RuntimeException e) {
+                    // 捕获异常，打印堆栈信息
                     e.printStackTrace();
-                    //捕获异常，向用户响应错误信息
+                    // 向用户响应错误信息
                     return Result.fail().message(e.getMessage());
                 }
             case 2:
                 try {
-                    //调用服务层登录方法,根据用户提交的LoginInfo信息,查询对应的Admin对象,找不到返回Null
+                    // 调用学生服务类的登录方法，根据用户提交的登录信息查询对应的学生对象，找不到返回 null
                     Student student = studentService.login(loginForm);
                     if (student != null) {
-                        //登录成功，将用户ID和用户类型转换为token口令，作为信息响应给前端
+                        // 如果登录成功，将用户 ID 和用户类型转换为 token 口令，存入 Map 集合
                         map.put("token", JwtHelper.createToken(student.getId().longValue(), 2));
                     } else {
+                        // 如果用户名或密码有误，抛出运行时异常
                         throw new RuntimeException("用户名或者密码有误！");
                     }
+                    // 将包含 token 的 Map 集合封装到结果对象中并返回
                     return Result.ok(map);
                 } catch (RuntimeException e) {
+                    // 捕获异常，打印堆栈信息
                     e.printStackTrace();
-                    //捕获异常，向用户响应错误信息
+                    // 向用户响应错误信息
                     return Result.fail().message(e.getMessage());
                 }
             case 3:
                 try {
-                    //调用服务层登录方法,根据用户提交的LoginInfo信息,查询对应的Admin对象,找不到返回Null
+                    // 调用教师服务类的登录方法，根据用户提交的登录信息查询对应的教师对象，找不到返回 null
                     Teacher teacher = teacherService.login(loginForm);
                     if (teacher != null) {
-                        //登录成功，将用户ID和用户类型转换为token口令，作为信息响应给前端
+                        // 如果登录成功，将用户 ID 和用户类型转换为 token 口令，存入 Map 集合
                         map.put("token", JwtHelper.createToken(teacher.getId().longValue(), 3));
                     } else {
+                        // 如果用户名或密码有误，抛出运行时异常
                         throw new RuntimeException("用户名或者密码有误！");
                     }
+                    // 将包含 token 的 Map 集合封装到结果对象中并返回
                     return Result.ok(map);
                 } catch (RuntimeException e) {
+                    // 捕获异常，打印堆栈信息
                     e.printStackTrace();
-                    //捕获异常，向用户响应错误信息
+                    // 向用户响应错误信息
                     return Result.fail().message(e.getMessage());
                 }
         }
+        // 如果以上用户类型都不匹配，返回错误结果对象并提示用户查无此人
         return Result.fail().message("查无此人!");
     }
 
+    /**
+     * 获取验证码图片
+     * @param request HTTP 请求对象
+     * @param response HTTP 响应对象
+     */
     @ApiOperation("获取验证码图片")
+    // 处理 GET 请求，用于获取验证码图片
     @GetMapping("/getVerifiCodeImage")
     public void getVerifiCodeImage(HttpServletRequest request, HttpServletResponse response) {
-        //获取验证码图片
+        // 调用工具类方法获取验证码图片
         BufferedImage verifiCodeImage = CreateVerifiCodeImage.getVerifiCodeImage();
-        //获取图片上的验证码
+        // 调用工具类方法获取图片上的验证码文本
         String verifiCode = new String(CreateVerifiCodeImage.getVerifiCode());
-        //将验证码文本放入Session域，为下一次验证做准备
+        // 获取当前请求的 session 对象
         HttpSession session = request.getSession();
+        // 将验证码文本放入 session 域，为下一次验证做准备
         session.setAttribute("verifiCode", verifiCode);
-        //将验证码图片响应给浏览器
+        // 将验证码图片响应给浏览器
         try {
             ImageIO.write(verifiCodeImage, "JPEG", response.getOutputStream());
         } catch (IOException e) {
+            // 捕获异常，打印堆栈信息
             e.printStackTrace();
         }
     }
 
-    //  POST  http://localhost:8080/sms/system/updatePwd/admin/admin123
+    /**
+     * 修改密码
+     * 请求 URL 示例：POST  http://localhost:8080/sms/system/updatePwd/admin/admin123
+     * @param oldPwd 原密码
+     * @param newPwd 新密码
+     * @param token token 信息，用来判断当前登录的用户类型
+     * @return 封装了修改密码操作结果的结果对象
+     */
     @ApiOperation("修改密码")
+    // 处理 POST 请求，用于修改用户密码
     @PostMapping("/updatePwd/{oldPwd}/{newPwd}")
     public Result updatePwd(
+            // 从路径中获取原密码，并使用 Swagger 注解进行参数描述
             @ApiParam("原密码") @PathVariable("oldPwd") String oldPwd,
+            // 从路径中获取新密码，并使用 Swagger 注解进行参数描述
             @ApiParam("新密码") @PathVariable("newPwd") String newPwd,
-            @ApiParam("token信息，用来判断当前登录的用户类型") @RequestHeader String token
+            // 从请求头中获取 token 信息，并使用 Swagger 注解进行参数描述
+            @ApiParam("token 信息，用来判断当前登录的用户类型") @RequestHeader String token
     ) {
-        //判断token是否失效
+        // 判断 token 是否失效
         boolean expiration = JwtHelper.isExpiration(token);
         if (expiration) {
-            return Result.fail().message("token失效，请重新登录。");
+            // 如果 token 失效，返回错误结果对象并提示用户重新登录
+            return Result.fail().message("token 失效，请重新登录。");
         }
 
-        //从token中获取用户id，用户类型，判断从哪个表中查询
+        // 从 token 中获取用户 ID
         Long userId = JwtHelper.getUserId(token);
+        // 从 token 中获取用户类型
         Integer userType = JwtHelper.getUserType(token);
 
-        //请求链接中原密码和新密码都是以明文方式传输的，数据库中的密码是以密文存储的，所以要将原密码和新密码转换成密文
+        // 请求链接中原密码和新密码都是以明文方式传输的，数据库中的密码是以密文存储的，所以要将原密码和新密码转换成密文
         String encryptOldPwd = MD5.encrypt(oldPwd);
         String encryptNewPwd = MD5.encrypt(newPwd);
 
+        // 根据用户类型进行不同的处理
         switch (userType) {
             case 1:
+                // 创建一个管理员查询条件包装器
                 QueryWrapper<Admin> adminQueryWrapper = new QueryWrapper<>();
+                // 添加查询条件：用户 ID 相等
                 adminQueryWrapper.eq("id", userId);
+                // 添加查询条件：原密码相等（密文）
                 adminQueryWrapper.eq("password", encryptOldPwd);
+                // 根据查询条件查询管理员对象
                 Admin one = adminService.getOne(adminQueryWrapper);
                 if (one != null) {
+                    // 如果查询到管理员对象，将新密码（密文）设置到对象中
                     one.setPassword(encryptNewPwd);
+                    // 调用管理员服务类的保存或更新方法，更新管理员信息
                     adminService.saveOrUpdate(one);
                 } else {
+                    // 如果原密码错误，返回错误结果对象并提示用户
                     return Result.fail().message("原密码错误！");
                 }
                 break;
             case 2:
+                // 创建一个学生查询条件包装器
                 QueryWrapper<Student> studentQueryWrapper = new QueryWrapper<>();
+                // 添加查询条件：用户 ID 相等
                 studentQueryWrapper.eq("id", userId);
+                // 添加查询条件：原密码相等（密文）
                 studentQueryWrapper.eq("password", encryptOldPwd);
+                // 根据查询条件查询学生对象
                 Student studentServiceOne = studentService.getOne(studentQueryWrapper);
                 if (studentServiceOne != null) {
+                    // 如果查询到学生对象，将新密码（密文）设置到对象中
                     studentServiceOne.setPassword(encryptNewPwd);
+                    // 调用学生服务类的保存或更新方法，更新学生信息
                     studentService.saveOrUpdate(studentServiceOne);
                 } else {
+                    // 如果原密码错误，返回错误结果对象并提示用户
                     return Result.fail().message("原密码错误!");
                 }
                 break;
             case 3:
+                // 创建一个教师查询条件包装器
                 QueryWrapper<Teacher> teacherQueryWrapper = new QueryWrapper<>();
+                // 添加查询条件：用户 ID 相等
                 teacherQueryWrapper.eq("id", userId);
+                // 添加查询条件：原密码相等（密文）
                 teacherQueryWrapper.eq("password", encryptOldPwd);
+                // 根据查询条件查询教师对象
                 Teacher teacherServiceOne = teacherService.getOne(teacherQueryWrapper);
                 if (teacherServiceOne != null) {
+                    // 如果查询到教师对象，将新密码（密文）设置到对象中
                     teacherServiceOne.setPassword(encryptNewPwd);
+                    // 调用教师服务类的保存或更新方法，更新教师信息
                     teacherService.saveOrUpdate(teacherServiceOne);
                 } else {
+                    // 如果原密码错误，返回错误结果对象并提示用户
                     return Result.fail().message("原密码错误!");
                 }
                 break;
         }
-
+        // 返回操作成功的结果对象
         return Result.ok();
     }
-
 }