diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/.idea/vcs.xml b/springboota009社团管理系统/代码/AssociationManagerApi - idea/.idea/vcs.xml
index 7ef1e0e..c2365ab 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/.idea/vcs.xml	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/.idea/vcs.xml	
@@ -1,6 +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>
\ No newline at end of file
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActiveLogsController.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActiveLogsController.java
index f2f560e..fa9a64b 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActiveLogsController.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActiveLogsController.java	
@@ -4,6 +4,7 @@ import com.rabbiter.association.service.ActiveLogsService;
 import com.rabbiter.association.service.UsersService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -23,7 +24,8 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 系统请求响应控制器，负责处理报名记录相关的请求。
+ * 系统请求响应控制器
+ * 报名记录
  */
 @Controller
 @RequestMapping("/activeLogs")
@@ -32,119 +34,86 @@ public class ActiveLogsController extends BaseController {
     protected static final Logger Log = LoggerFactory.getLogger(ActiveLogsController.class);
 
     @Autowired
-    private CacheHandle cacheHandle; // 注入缓存处理类
+    private CacheHandle cacheHandle;
 
     @Autowired
-    private UsersService usersService; // 注入用户服务类
+    private UsersService usersService;
 
     @Autowired
-    private ActiveLogsService activeLogsService; // 注入报名记录服务类
+    private ActiveLogsService activeLogsService;
 
-    /**
-     * 显示报名记录页面。
-     * <p>请求映射到空路径，返回报名记录页面的视图名称。</p>
-     */
     @RequestMapping("")
     public String index() {
-        return "pages/ActiveLogs"; // 返回报名记录页面的视图名称
+
+        return "pages/ActiveLogs";
     }
 
-    /**
-     * 获取指定报名记录的详细信息。
-     * <p>通过HTTP GET请求和报名记录ID获取详细信息。</p>
-     *
-     * @param id 报名记录ID
-     * @return 返回包含报名记录信息的响应对象
-     */
     @GetMapping("/info")
     @ResponseBody
     public R getInfo(String id) {
-        Log.info("查找指定报名记录，ID：{}", id); // 记录日志
 
-        ActiveLogs activeLogs = activeLogsService.getOne(id); // 通过ID获取报名记录
+        Log.info("查找指定报名记录，ID：{}", id);
 
-        return R.successData(activeLogs); // 返回成功响应，包含报名记录信息
+        ActiveLogs activeLogs = activeLogsService.getOne(id);
+
+        return R.successData(activeLogs);
     }
 
-    /**
-     * 获取指定活动的报名记录列表。
-     * <p>通过HTTP GET请求和活动ID获取报名记录列表。</p>
-     *
-     * @param activeId 活动ID
-     * @return 返回包含报名记录列表的响应对象
-     */
     @GetMapping("/list")
     @ResponseBody
     public R getList(String activeId) {
-        Log.info("获取指定活动的报名记录，活动ID：{}", activeId); // 记录日志
 
-        List<Map<String, Object>> list = activeLogsService.getListByActiveId(activeId); // 通过活动ID获取报名记录列表
+        Log.info("获取指定活动的报名记录，活动ID：{}", activeId);
+
+        List<Map<String, Object>> list = activeLogsService.getListByActiveId(activeId);
 
-        return R.successData(list); // 返回成功响应，包含报名记录列表
+        return R.successData(list);
     }
 
-    /**
-     * 添加新的报名记录。
-     * <p>通过HTTP POST请求和报名记录信息添加新的报名记录。</p>
-     *
-     * @param token 用户token
-     * @param activeLogs 报名记录信息
-     * @return 返回操作结果的响应对象
-     */
     @PostMapping("/add")
     @ResponseBody
     public R addInfo(String token, ActiveLogs activeLogs) {
-        Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 通过token获取用户信息
 
-        if (activeLogsService.isActive(activeLogs.getActiveId(), user.getId())) { // 检查用户是否已参与活动
+        Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
 
-            activeLogs.setId(IDUtils.makeIDByCurrent()); // 生成报名记录ID
-            activeLogs.setUserId(user.getId()); // 设置报名用户ID
-            activeLogs.setCreateTime(DateUtils.getNowDate()); // 设置报名时间
+        if(activeLogsService.isActive(activeLogs.getActiveId(), user.getId())){
 
-            Log.info("添加报名记录，传入参数：{}", activeLogs); // 记录日志
+            activeLogs.setId(IDUtils.makeIDByCurrent());
+            activeLogs.setUserId(user.getId());
+            activeLogs.setCreateTime(DateUtils.getNowDate());
 
-            activeLogsService.add(activeLogs); // 添加报名记录
+            Log.info("添加报名记录，传入参数：{}", activeLogs);
 
-            return R.success(); // 返回成功响应
-        } else {
-            return R.warn("该活动您已参与，请勿重复报名"); // 返回警告响应，提示用户已参与活动
+            activeLogsService.add(activeLogs);
+
+            return R.success();
+        }else{
+
+            return R.warn("该活动您已参与，请勿重复报名");
         }
     }
 
-    /**
-     * 更新报名记录。
-     * <p>通过HTTP POST请求和报名记录信息更新指定的报名记录。</p>
-     *
-     * @param activeLogs 报名记录信息
-     * @return 返回操作结果的响应对象
-     */
     @PostMapping("/upd")
     @ResponseBody
     public R updInfo(ActiveLogs activeLogs) {
-        Log.info("修改报名记录，传入参数：{}", activeLogs); // 记录日志
 
-        activeLogsService.update(activeLogs); // 更新报名记录
+        Log.info("修改报名记录，传入参数：{}", activeLogs);
 
-        return R.success(); // 返回成功响应
+        activeLogsService.update(activeLogs);
+
+        return R.success();
     }
 
-    /**
-     * 删除报名记录。
-     * <p>通过HTTP POST请求和报名记录ID删除指定的报名记录。</p>
-     *
-     * @param id 报名记录ID
-     * @return 返回操作结果的响应对象
-     */
     @PostMapping("/del")
     @ResponseBody
     public R delInfo(String id) {
-        Log.info("删除报名记录, ID:{}", id); // 记录日志
 
-        ActiveLogs activeLogs = activeLogsService.getOne(id); // 通过ID获取报名记录
+        Log.info("删除报名记录, ID:{}", id);
+
+        ActiveLogs activeLogs = activeLogsService.getOne(id);
 
-        activeLogsService.delete(activeLogs); // 删除报名记录
+        activeLogsService.delete(activeLogs);
 
-        return R.success(); // 返回成功响应
+        return R.success();
     }
 }
\ No newline at end of file
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActivitiesController.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActivitiesController.java
index 1771080..cffacc6 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActivitiesController.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActivitiesController.java	
@@ -1,26 +1,18 @@
 package com.rabbiter.association.controller;
-//声明该Java类所在的包名为com.rabbiter.association.controller。
 
 import com.rabbiter.association.service.UsersService;
-//导入UsersService类，用于处理用户相关的业务逻辑。
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-//导入slf4j日志框架的Logger和LoggerFactory，用于记录日志。
 
 import org.springframework.beans.factory.annotation.Autowired;
-//导入Autowired注解，用于自动装配依赖。
 import org.springframework.stereotype.Controller;
-//导入Controller注解，表明该类是一个Spring MVC中的控制器。
 import org.springframework.util.ObjectUtils;
-//用于对象工具操作
 import org.springframework.web.bind.annotation.GetMapping;
-//等用于处理Web请求映射
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.ResponseBody;
 
 import com.rabbiter.association.entity.Users;
-//等导入实体类和工具类。
 import com.rabbiter.association.handle.CacheHandle;
 import com.rabbiter.association.utils.IDUtils;
 import com.rabbiter.association.msg.R;
@@ -29,32 +21,33 @@ import com.rabbiter.association.msg.PageData;
 import com.rabbiter.association.entity.Activities;
 import com.rabbiter.association.service.ActivitiesService;
 
-//系统请求响应控制器
-//活动信息
-@Controller//注解将该类标记为Spring MVC的控制器。
-@RequestMapping("/activities")//指定了该控制器处理的基本URL路径为/activities。
+/**
+ * 系统请求响应控制器
+ * 活动信息
+ */
+@Controller
+@RequestMapping("/activities")
 public class ActivitiesController extends BaseController {
-//定义了名为ActivitiesController的类，它继承自BaseController类。
+
     protected static final Logger Log = LoggerFactory.getLogger(ActivitiesController.class);
-//创建一个Logger对象，用于记录ActivitiesController类中的日志信息。
+
 
     @Autowired
     private CacheHandle cacheHandle;
-//使用Autowired注解自动注入CacheHandle类型的依赖，用于处理缓存相关操作。
+
     @Autowired
     private UsersService usersService;
-//自动注入UsersService，用于用户相关业务。
+
     @Autowired
     private ActivitiesService activitiesService;
-//自动注入ActivitiesService，用于活动相关业务。
+
     @RequestMapping("")
     public String index() {
 
         return "pages/Activities";
     }
-//当访问根路径（相对于/activities）时，该方法返回名为"pages/Activities"的视图名称。
+
     @GetMapping("/info")
-    //@GetMapping表示处理HTTP GET请求，/info是相对于/activities的路径。
     @ResponseBody
     public R getInfo(String id) {
 
@@ -64,12 +57,12 @@ public class ActivitiesController extends BaseController {
 
         return R.successData(activities);
     }
-//该方法接收一个id参数，通过activitiesService.getOne(id)获取指定id的活动信息，然后使用R.successData(activities)返回包含活动信息的成功响应。
-    @GetMapping("/page")//处理/page路径的GET请求。
+
+    @GetMapping("/page")
     @ResponseBody
     public R getPageInfos(Long pageIndex, Long pageSize,
                           String token, String teamName, String activeName) {
-//首先通过usersService.getOne(cacheHandle.getUserInfoCache(token))获取用户信息，如果用户不存在则返回登录信息不存在的错误。
+
         Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
         if(ObjectUtils.isEmpty(user)) {
             return R.error("登录信息不存在，请重新登录");
@@ -94,8 +87,8 @@ public class ActivitiesController extends BaseController {
             return R.successData(page);
         }
     }
-//根据用户类型（user.getType()）不同，分别调用activitiesService.getPageAll（普通情况）或activitiesService.getPageByUserId（特定用户类型）来进行分页查询活动信息，最后返回包含分页数据的成功响应。
-    @PostMapping("/add")//处理/add路径的POST请求。
+
+    @PostMapping("/add")
     @ResponseBody
     public R addInfo(Activities activities) {
 
@@ -107,8 +100,8 @@ public class ActivitiesController extends BaseController {
 
         return R.success();
     }
-//为传入的Activities对象设置id（通过IDUtils.makeIDByCurrent()），然后使用activitiesService.add(activities)添加活动信息，最后返回成功响应。
-    @PostMapping("/upd")//处理/upd路径的POST请求。
+
+    @PostMapping("/upd")
     @ResponseBody
     public R updInfo(Activities activities) {
 
@@ -118,8 +111,8 @@ public class ActivitiesController extends BaseController {
 
         return R.success();
     }
-//通过activitiesService.update(activities)修改活动信息，然后返回成功响应。
-    @PostMapping("/del")//处理/del路径的POST请求。
+
+    @PostMapping("/del")
     @ResponseBody
     public R delInfo(String id) {
 
@@ -131,5 +124,4 @@ public class ActivitiesController extends BaseController {
 
         return R.success();
     }
-}
-//先通过activitiesService.getOne(id)获取要删除的活动对象，然后使用`activitiesService.delete
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ApplyLogsController.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ApplyLogsController.java
index 183a115..ce81ae8 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ApplyLogsController.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ApplyLogsController.java	
@@ -4,6 +4,7 @@ import com.rabbiter.association.service.ApplyLogsService;
 import com.rabbiter.association.service.UsersService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.util.ObjectUtils;
@@ -22,7 +23,8 @@ import com.rabbiter.association.msg.PageData;
 import com.rabbiter.association.entity.ApplyLogs;
 
 /**
- * 系统请求响应控制器，负责处理申请记录相关的请求。
+ * 系统请求响应控制器
+ * 申请记录
  */
 @Controller
 @RequestMapping("/applyLogs")
@@ -31,51 +33,31 @@ public class ApplyLogsController extends BaseController {
     protected static final Logger Log = LoggerFactory.getLogger(ApplyLogsController.class);
 
     @Autowired
-    private CacheHandle cacheHandle; // 注入缓存处理类
+    private CacheHandle cacheHandle;
 
     @Autowired
-    private UsersService usersService; // 注入用户服务类
+    private UsersService usersService;
 
     @Autowired
-    private ApplyLogsService applyLogsService; // 注入申请记录服务类
+    private ApplyLogsService applyLogsService;
 
-    /**
-     * 显示申请记录页面。
-     * <p>请求映射到空路径，返回申请记录页面的视图名称。</p>
-     */
     @RequestMapping("")
     public String index() {
-        return "pages/ApplyLogs"; // 返回申请记录页面的视图名称
+
+        return "pages/ApplyLogs";
     }
 
-    /**
-     * 获取指定申请记录的详细信息。
-     * <p>通过HTTP GET请求和申请记录ID获取详细信息。</p>
-     *
-     * @param id 申请记录ID
-     * @return 返回包含申请记录信息的响应对象
-     */
     @GetMapping("/info")
     @ResponseBody
     public R getInfo(String id) {
-        Log.info("查找指定申请记录，ID：{}", id); // 记录日志
 
-        ApplyLogs applyLogs = applyLogsService.getOne(id); // 通过ID获取申请记录
+        Log.info("查找指定申请记录，ID：{}", id);
+
+        ApplyLogs applyLogs = applyLogsService.getOne(id);
 
-        return R.successData(applyLogs); // 返回成功响应，包含申请记录信息
+        return R.successData(applyLogs);
     }
 
-    /**
-     * 分页查询申请记录信息。
-     * <p>根据用户类型，查询不同的申请记录信息。</p>
-     *
-     * @param pageIndex 当前页码
-     * @param pageSize 每页数据量
-     * @param token 用户token
-     * @param teamName 团队名称
-     * @param userName 用户姓名
-     * @return 返回包含分页申请记录信息的响应对象
-     */
     @GetMapping("/page")
     @ResponseBody
     public R getPageInfos(Long pageIndex, Long pageSize,
@@ -117,68 +99,50 @@ public class ApplyLogsController extends BaseController {
         }
     }
 
-    /**
-     * 添加新的申请记录。
-     * <p>通过HTTP POST请求和申请记录信息添加新的申请记录。</p>
-     *
-     * @param token 用户token
-     * @param applyLogs 申请记录信息
-     * @return 返回操作结果的响应对象
-     */
     @PostMapping("/add")
     @ResponseBody
     public R addInfo(String token, ApplyLogs applyLogs) {
-        Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 通过token获取用户信息
 
-        if(applyLogsService.isApply(user.getId(), applyLogs.getTeamId())) { // 检查用户是否已提交申请
+        Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
 
-            applyLogs.setId(IDUtils.makeIDByCurrent()); // 生成申请记录ID
-            applyLogs.setUserId(user.getId()); // 设置申请用户ID
-            applyLogs.setCreateTime(DateUtils.getNowDate()); // 设置申请时间
+        if(applyLogsService.isApply(user.getId(), applyLogs.getTeamId())){
 
-            Log.info("添加申请记录，传入参数：{}", applyLogs); // 记录日志
+            applyLogs.setId(IDUtils.makeIDByCurrent());
+            applyLogs.setUserId(user.getId());
+            applyLogs.setCreateTime(DateUtils.getNowDate());
 
-            applyLogsService.add(applyLogs); // 添加申请记录
+            Log.info("添加申请记录，传入参数：{}", applyLogs);
 
-            return R.success(); // 返回成功响应
-        } else {
-            return R.warn("申请审核中，请耐心等待"); // 返回警告响应，提示申请审核中
+            applyLogsService.add(applyLogs);
+
+            return R.success();
+        }else{
+
+            return R.warn("申请审核中，请耐心等待");
         }
     }
 
-    /**
-     * 更新申请记录。
-     * <p>通过HTTP POST请求和申请记录信息更新指定的申请记录。</p>
-     *
-     * @param applyLogs 申请记录信息
-     * @return 返回操作结果的响应对象
-     */
     @PostMapping("/upd")
     @ResponseBody
     public R updInfo(ApplyLogs applyLogs) {
-        Log.info("修改申请记录，传入参数：{}", applyLogs); // 记录日志
 
-        applyLogsService.update(applyLogs); // 更新申请记录
+        Log.info("修改申请记录，传入参数：{}", applyLogs);
 
-        return R.success(); // 返回成功响应
+        applyLogsService.update(applyLogs);
+
+        return R.success();
     }
 
-    /**
-     * 删除申请记录。
-     * <p>通过HTTP POST请求和申请记录ID删除指定的申请记录。</p>
-     *
-     * @param id 申请记录ID
-     * @return 返回操作结果的响应对象
-     */
     @PostMapping("/del")
     @ResponseBody
     public R delInfo(String id) {
-        Log.info("删除申请记录, ID:{}", id); // 记录日志
 
-        ApplyLogs applyLogs = applyLogsService.getOne(id); // 通过ID获取申请记录
+        Log.info("删除申请记录, ID:{}", id);
+
+        ApplyLogs applyLogs = applyLogsService.getOne(id);
 
-        applyLogsService.delete(applyLogs); // 删除申请记录
+        applyLogsService.delete(applyLogs);
 
-        return R.success(); // 返回成功响应
+        return R.success();
     }
 }
\ No newline at end of file
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/BaseController.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/BaseController.java
index 3efcecf..673c0db 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/BaseController.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/BaseController.java	
@@ -7,53 +7,39 @@ import com.rabbiter.association.msg.R;
 import javax.servlet.http.HttpSession;
 
 /**
- * 系统控制器抽象类，提供基础的会话管理和异常处理功能。
- * 其他控制器需要继承这个控制器以复用这些功能。
+ * 系统控制器抽象类
+ * 其他控制器需要继承这个控制器
  */
 public abstract class BaseController {
 
-    /**
-     * 会话中用户信息的键名。
-     * 用于在会话中存储和检索登录用户的信息。
-     */
     protected static final String SESSION_USER = "user";
 
     /**
-     * 从会话对象中获取登录用户的信息。
-     * 此方法允许子类获取当前登录用户的信息。
-     *
-     * @param session 会话对象，用于存储和检索用户信息。
-     * @return 登录用户的信息对象，如果没有用户登录则可能返回 null。
+     * 获取登录用户的信息
+     * @param session 会话对象
+     * @return
      */
     protected Object getSessionUser(HttpSession session) {
+
         return session.getAttribute(SESSION_USER);
     }
 
     /**
-     * 将登录用户信息记录到会话对象中。
-     * 此方法允许子类在用户登录后将用户信息存储到会话中。
-     *
-     * @param session 会话对象，用于存储用户信息。
-     * @param user 登录用户的信息对象。
+     * 将登录用户信息记录到会话对象中
+     * @param session 会话对象
+     * @param user 登录用户信息
      */
     protected void setSessionUser(HttpSession session, Object user) {
+
         session.setAttribute(SESSION_USER, user);
     }
 
-    /**
-     * 处理控制器中抛出的异常。
-     * 此方法被注解 @ExceptionHandler 标记，用于捕获控制器中抛出的异常。
-     * 方法的返回值被注解 @ResponseBody 标记，表示异常处理的结果将直接作为 HTTP 响应体返回。
-     *
-     * @param e 抛出的异常对象。
-     * @return 一个 R 对象，表示异常处理的结果。
-     */
-    @ExceptionHandler(Exception.class)
+//    @ExceptionHandler(Exception.class)
     @ResponseBody
     public R exception(Exception e) {
-        e.printStackTrace(); // 打印异常堆栈信息，方便调试。
 
-        // 返回一个错误信息的 R 对象，R 是一个自定义的响应消息类。
+        e.printStackTrace();
+
         return R.error();
     }
-}
\ No newline at end of file
+}
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/IndexController.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/IndexController.java
index 8018637..a9c49d9 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/IndexController.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/IndexController.java	
@@ -1,206 +1,149 @@
 package com.rabbiter.association.controller;
 
-
 import com.rabbiter.association.service.UsersService;
-// 导入用户服务类
 import org.slf4j.Logger;
-// 导入日志记录器
 import org.slf4j.LoggerFactory;
-// 导入日志工厂
 import org.springframework.beans.factory.annotation.Autowired;
-// 导入自动注入注解
 import org.springframework.stereotype.Controller;
-// 导入控制器注解
 import org.springframework.util.ObjectUtils;
-// 导入对象工具类
 import org.springframework.web.bind.annotation.*;
-// 导入Spring Web注解
 
 import com.rabbiter.association.entity.Notices;
-// 导入通知实体类
 import com.rabbiter.association.handle.CacheHandle;
-// 导入缓存处理类
 import com.rabbiter.association.msg.R;
-// 导入响应消息类
 import com.rabbiter.association.entity.Users;
-// 导入用户实体类
 import com.rabbiter.association.service.NoticesService;
-// 导入通知服务类
 import com.rabbiter.association.utils.IDUtils;
-// 导入ID工具类
 
 import javax.servlet.http.HttpSession;
-// 导入HTTP会话类
 import java.util.List;
-// 导入列表类
 
-// 此代码实现了一个登录功能
-@Controller // 声明这是一个控制器类
-@RequestMapping("/") // 定义请求映射的根路径
-public class IndexController extends BaseController { // 继承自基础控制器
+@Controller
+@RequestMapping("/")
+public class IndexController extends BaseController {
 
     private static final Logger Log = LoggerFactory.getLogger(IndexController.class);
-    // 创建日志记录器
 
-    @Autowired // 自动注入用户服务
+    @Autowired
     private UsersService usersService;
 
-    @Autowired // 自动注入缓存处理类
+    @Autowired
     private CacheHandle cacheHandle;
 
-    @Autowired // 自动注入通知服务
+    @Autowired
     private NoticesService noticesService;
 
-    // 获取通知列表的GET请求
-    @GetMapping("/sys/notices")// 映射GET请求到/sys/notices
-    @ResponseBody // 返回JSON格式的响应
+    @GetMapping("/sys/notices")
+    @ResponseBody
     public R getNoticeList(String token){
-        // 方法接收token参数
 
         Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
-        // 从缓存中获取用户信息
         if(ObjectUtils.isEmpty(user)) {
-            // 检查用户是否为空
-            return R.error("登录信息不存在，请重新登录"); // 返回错误信息
+            return R.error("登录信息不存在，请重新登录");
         }
 
-        // 根据用户类型获取不同的通知列表
         if(user.getType() == 0){
-            // 管理员类型
+
             List<Notices> list = noticesService.getSysNotices();
-            // 获取系统通知
+
             return R.successData(list);
-            // 返回成功响应和通知列表
         }else if(user.getType() == 1){
-            // 管理员类型
+
             List<Notices> list = noticesService.getManNotices(user.getId());
-            // 获取管理员通知
+
             return R.successData(list);
-            // 返回成功响应和通知列表
         }else{
-            // 普通用户类型
+
             List<Notices> list = noticesService.getMemNotices(user.getId());
-            // 获取普通用户通知
+
             return R.successData(list);
-            // 返回成功响应和通知列表
         }
     }
 
-    // 用户登录的POST请求
-    @PostMapping("/login") // 映射POST请求到/login
-    @ResponseBody // 返回JSON格式的响应
+    @PostMapping("/login")
+    @ResponseBody
     public R login(String userName, String passWord, HttpSession session){
-        // 方法接收用户名、密码和会话
 
         Log.info("用户登录，用户名：{}， 用户密码：{}", userName, passWord);
-        // 记录登录信息
 
         Users user = usersService.getUserByUserName(userName);
-        // 根据用户名获取用户信息
 
         if(user == null) {
-            // 如果用户不存在
+
             return R.error("输入的用户名不存在");
-            // 返回错误信息
-        }else { // 用户存在
+        }else {
+
             if(passWord.equals(user.getPassWord().trim())) {
-                // 检查密码是否匹配
+
+
                 String token = IDUtils.makeIDByUUID();
-                // 生成唯一的token
                 cacheHandle.addUserCache(token, user.getId());
-                // 将用户信息存入缓存
+
                 return R.success("登录成功", token);
-                // 返回成功响应和token
-            }else { // 密码不匹配
+            }else {
+
                 return R.error("输入的密码错误");
-                // 返回错误信息
             }
         }
     }
 
-    // 用户退出的请求
-    @RequestMapping("/exit") // 映射请求到/exit
-    @ResponseBody // 返回JSON格式的响应
+    @RequestMapping("/exit")
+    @ResponseBody
     public R exit(String token) {
-        // 方法接收token参数
 
         Log.info("用户退出系统并移除登录信息");
-        // 记录退出信息
 
         cacheHandle.removeUserCache(token);
-        // 从缓存中移除用户信息
 
-        return R.success(); // 返回成功响应
+        return R.success();
     }
 
-    // 获取用户信息的GET请求
-    @GetMapping("/info") // 映射GET请求到/info
-    @ResponseBody // 返回JSON格式的响应
+    @GetMapping("/info")
+    @ResponseBody
     public R info(String token){
-        // 方法接收token参数
 
         Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
-        // 从缓存中获取用户信息
 
         return R.successData(user);
-        // 返回成功响应和用户信息
     }
 
-    // 修改用户信息的POST请求
-    @PostMapping("/info") // 映射POST请求到/info
-    @ResponseBody // 返回JSON格式的响应
+    @PostMapping("/info")
+    @ResponseBody
     public R info(Users user){
-        // 方法接收用户对象
 
         Log.info("修改用户信息，{}", user);
-        // 记录用户信息修改
 
         usersService.update(user);
-        // 更新用户信息
 
         return R.success();
-        // 返回成功响应
     }
 
-    // 检查密码的请求
-    @RequestMapping("/checkPwd") // 映射请求到/checkPwd
-    @ResponseBody // 返回JSON格式的响应
+    @RequestMapping("/checkPwd")
+    @ResponseBody
     public R checkPwd(String oldPwd, String token) {
-        // 方法接收旧密码和token参数
 
         Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
-        // 从缓存中获取用户信息
 
         if(oldPwd.equals(user.getPassWord())) {
-            // 检查旧密码是否匹配
+
             return R.success();
-            // 返回成功响应
         }else {
-            // 密码不匹配
+
             return R.warn("原始密码和输入密码不一致");
-            // 返回警告信息
         }
     }
 
-    // 修改用户密码的POST请求
-    @PostMapping("/pwd") // 映射POST请求到/pwd
-    @ResponseBody // 返回JSON格式的响应
+    @PostMapping("/pwd")
+    @ResponseBody
     public R pwd(String token, String password) {
-        // 方法接收token和新密码
 
         Log.info("修改用户密码，{}", password);
-        // 记录密码修改信息
-
 
         Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
-        // 从缓存中获取用户信息
 
         user.setPassWord(password);
-        // 设置新密码
         usersService.update(user);
-        // 更新用户信息
 
         return R.success();
-        // 返回成功响应
     }
 }
\ No newline at end of file
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ActiveLogsDao.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ActiveLogsDao.java
index ef4aebd..129b191 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ActiveLogsDao.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ActiveLogsDao.java	
@@ -1,18 +1,19 @@
 package com.rabbiter.association.dao;
 
+// 引入Spring框架的Repository注解，标识这是一个数据访问对象（DAO）
 import org.springframework.stereotype.Repository;
+// 引入MyBatis Plus的BaseMapper接口，提供基础的CRUD操作
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 引入活动日志实体类
 import com.rabbiter.association.entity.ActiveLogs;
 
 /**
  * 数据访问层接口，用于处理与报名记录相关的数据库操作。
- * <p>
- * 此接口继承自 MyBatis Plus 的 BaseMapper，提供了一系列的 CRUD 操作（创建、读取、更新、删除）。
- * 通过继承 BaseMapper，ActiveLogsDao 接口能够直接使用 MyBatis Plus 提供的通用方法，无需手写 SQL 语句。
- * </p>
+ * 继承自MyBatis Plus的BaseMapper，提供CRUD操作。
  */
+// 使用@Repository注解标识该接口为Spring的一个Repository，并给其指定一个唯一的bean名称
 @Repository("activeLogsDao")
 public interface ActiveLogsDao extends BaseMapper<ActiveLogs> {
-
-
-}
\ No newline at end of file
+    // 该接口继承BaseMapper后已经包含了基本的CRUD操作，无需额外定义方法
+    // 可以根据需要添加自定义的数据库操作方法
+}
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ApplyLogsDao.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ApplyLogsDao.java
index 6abf2c5..212eb93 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ApplyLogsDao.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ApplyLogsDao.java	
@@ -1,36 +1,37 @@
 package com.rabbiter.association.dao;
 
+// 引入MyBatis Plus的分页插件
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 引入MyBatis的注解，用于动态SQL
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Select;
+// 引入Spring的注解，标识这是一个Repository
 import org.springframework.stereotype.Repository;
 
+// 引入MyBatis Plus的基础Mapper接口
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
+// 引入应用日志实体类
 import com.rabbiter.association.entity.ApplyLogs;
-
+// 引入Java的Map接口，用于存储键值对
 import java.util.Map;
 
 /**
  * 数据访问层接口，用于处理与申请记录相关的数据库操作。
- * <p>
- * 此接口继承自 MyBatis Plus 的 BaseMapper，提供了一系列的 CRUD 操作（创建、读取、更新、删除）。
- * 通过继承 BaseMapper，ApplyLogsDao 接口能够直接使用 MyBatis Plus 提供的通用方法，无需手写 SQL 语句。
- * </p>
+ * 继承自MyBatis Plus的BaseMapper，提供CRUD操作。
  */
-
-@Repository("applyLogsDao")
+@Repository("applyLogsDao") // Spring容器中的唯一标识
 public interface ApplyLogsDao extends BaseMapper<ApplyLogs> {
 
     /**
      * 分页查询申请记录。
-     * 此方法使用 MyBatis 的动态 SQL 功能，允许根据提供的参数动态构建查询条件。
+     * 使用MyBatis动态SQL功能构建查询条件。
      *
-     * @param page 分页参数，包含分页信息和排序信息。
-     * @param userId 用户ID，用于过滤申请记录。
-     * @param teamName 社团名称，用于过滤申请记录。
-     * @param userName 用户姓名，用于过滤申请记录。
-     * @return 分页的申请记录结果集，每条记录是一个 Map 对象，包含申请记录的详细信息。
+     * @param page 分页参数，包含分页和排序信息
+     * @param userId 用户ID，用于过滤申请记录
+     * @param teamName 社团名称，用于过滤申请记录
+     * @param userName 用户姓名，用于过滤申请记录
+     * @return 分页的申请记录结果集，每条记录是一个Map对象
      */
     @Select("<script>" +
             "SELECT " +
@@ -57,16 +58,15 @@ public interface ApplyLogsDao extends BaseMapper<ApplyLogs> {
                                                  @Param("teamName") String teamName,
                                                  @Param("userName") String userName);
 
-
     /**
      * 分页查询申请记录，特别为管理员设计。
-     * 此方法与 qryPageInfo 类似，但额外支持根据管理员ID过滤申请记录。
+     * 与qryPageInfo类似，但额外支持根据管理员ID过滤申请记录。
      *
-     * @param page 分页参数，包含分页信息和排序信息。
-     * @param userId 用户ID，用于过滤申请记录。
-     * @param teamName 社团名称，用于过滤申请记录。
-     * @param userName 用户姓名，用于过滤申请记录。
-     * @return 分页的申请记录结果集，每条记录是一个 Map 对象，包含申请记录的详细信息。
+     * @param page 分页参数，包含分页和排序信息
+     * @param userId 用户ID，用于过滤申请记录
+     * @param teamName 社团名称，用于过滤申请记录
+     * @param userName 用户姓名，用于过滤申请记录
+     * @return 分页的申请记录结果集，每条记录是一个Map对象
      */
     @Select("<script>" +
             "SELECT " +
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ActiveLogs.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ActiveLogs.java
index ac09ff0..8313652 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ActiveLogs.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ActiveLogs.java	
@@ -1,110 +1,112 @@
 package com.rabbiter.association.entity;
 
+// 导入MyBatis Plus注解，用于映射表和字段
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
+// 导入Java.io.Serializable接口，用于序列化
 import java.io.Serializable;
 
 /**
- * 数据实体类，表示数据库中的报名记录表。
- * <p>该类使用MyBatis Plus框架的注解来映射数据库表和字段。</p>
+ * 数据实体类，代表数据库中的报名记录表。
+ * 使用MyBatis Plus框架的注解映射数据库表和字段。
  */
-@TableName(value = "active_logs")
+@TableName(value = "active_logs") // 指定实体类映射的数据库表名
 public class ActiveLogs implements Serializable {
 
-	private static final long serialVersionUID = 1L; // 序列化ID，用于版本控制
+	private static final long serialVersionUID = 1L; // 用于序列化机制的版本控制
 
 	/**
-	 * 记录ID，映射数据库表的主键字段。
+	 * 报名记录的唯一标识，对应数据库表的主键字段。
 	 */
-	@TableId(value = "id")
+	@TableId(value = "id") // 指定实体类属性映射的表字段
 	private String id;
 
 	/**
-	 * 报名时间，映射数据库表的create_time字段。
+	 * 记录创建的时间，对应数据库表的create_time字段。
 	 */
-	@TableField(value = "create_time")
+	@TableField(value = "create_time") // 指定实体类属性映射的表字段
 	private String createTime;
 
 	/**
-	 * 活动编号，映射数据库表的active_id字段。
+	 * 活动的标识，对应数据库表的active_id字段。
 	 */
-	@TableField(value = "active_id")
+	@TableField(value = "active_id") // 指定实体类属性映射的表字段
 	private String activeId;
 
 	/**
-	 * 报名用户，映射数据库表的user_id字段。
+	 * 报名用户的标识，对应数据库表的user_id字段。
 	 */
-	@TableField(value = "user_id")
+	@TableField(value = "user_id") // 指定实体类属性映射的表字段
 	private String userId;
 
 	/**
-	 * 获取记录ID。
-	 * @return 记录ID。
+	 * 获取报名记录的唯一标识。
+	 * @return 返回报名记录ID。
 	 */
 	public String getId() {
 		return id;
 	}
 
 	/**
-	 * 设置记录ID。
-	 * @param id 记录ID。
+	 * 设置报名记录的唯一标识。
+	 * @param id 报名记录ID。
 	 */
 	public void setId(String id) {
 		this.id = id;
 	}
 
 	/**
-	 * 获取报名时间。
-	 * @return 报名时间。
+	 * 获取记录创建的时间。
+	 * @return 返回创建时间。
 	 */
 	public String getCreateTime() {
 		return createTime;
 	}
 
 	/**
-	 * 设置报名时间。
-	 * @param createTime 报名时间。
+	 * 设置记录创建的时间。
+	 * @param createTime 创建时间。
 	 */
 	public void setCreateTime(String createTime) {
 		this.createTime = createTime;
 	}
 
 	/**
-	 * 获取活动编号。
-	 * @return 活动编号。
+	 * 获取活动的标识。
+	 * @return 返回活动ID。
 	 */
 	public String getActiveId() {
 		return activeId;
 	}
 
 	/**
-	 * 设置活动编号。
-	 * @param activeId 活动编号。
+	 * 设置活动的标识。
+	 * @param activeId 活动ID。
 	 */
 	public void setActiveId(String activeId) {
 		this.activeId = activeId;
 	}
 
 	/**
-	 * 获取报名用户ID。
-	 * @return 报名用户ID。
+	 * 获取报名用户的标识。
+	 * @return 返回用户ID。
 	 */
 	public String getUserId() {
 		return userId;
 	}
 
 	/**
-	 * 设置报名用户ID。
-	 * @param userId 报名用户ID。
+	 * 设置报名用户的标识。
+	 * @param userId 用户ID。
 	 */
 	public void setUserId(String userId) {
 		this.userId = userId;
 	}
 
 	/**
-	 * 重写toString方法，用于返回对象的字符串表示。
-	 * @return 包含对象所有字段信息的字符串。
+	 * 提供对象的字符串表示，方便调试和日志记录。
+	 * @return 返回包含对象所有属性的字符串。
 	 */
 	@Override
 	public String toString() {
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ApplyLogs.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ApplyLogs.java
index 6515f0d..bdf3da9 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ApplyLogs.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ApplyLogs.java	
@@ -1,136 +1,138 @@
 package com.rabbiter.association.entity;
 
+// 导入MyBatis Plus注解，用于映射数据库表和字段
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
+// 导入Serializable接口，用于确保对象可以被序列化
 import java.io.Serializable;
 
 /**
- * 数据实体类，表示数据库中的申请记录表。
- * <p>该类使用MyBatis Plus框架的注解来映射数据库表和字段。</p>
+ * 数据实体类，代表数据库中的申请记录表。
+ * 该类利用MyBatis Plus的注解与数据库表和字段进行映射。
  */
-@TableName(value = "apply_logs")
+@TableName(value = "apply_logs") // 指定实体类映射的数据库表名
 public class ApplyLogs implements Serializable {
 
-	private static final long serialVersionUID = 1L; // 序列化ID，用于版本控制
+	private static final long serialVersionUID = 1L; // 用于序列化的版本UID
 
 	/**
-	 * 记录ID，映射数据库表的主键字段。
+	 * 唯一标识，对应数据库表的主键字段。
 	 */
-	@TableId(value = "id")
+	@TableId(value = "id") // 指定实体类属性映射的表字段
 	private String id;
 
 	/**
-	 * 处理状态，映射数据库表的status字段。
-	 * <p>通常用于表示申请记录的处理状态，例如：0-待审核，1-已通过，2-已拒绝等。</p>
+	 * 申请处理状态，对应数据库表的status字段。
+	 * 用于标识申请记录的处理状态，如：0-待审核，1-已通过，2-已拒绝。
 	 */
 	@TableField(value = "status")
 	private Integer status;
 
 	/**
-	 * 申请时间，映射数据库表的create_time字段。
-	 * <p>记录申请操作的时间。</p>
+	 * 申请时间，对应数据库表的create_time字段。
+	 * 记录申请操作的提交时间。
 	 */
 	@TableField(value = "create_time")
 	private String createTime;
 
 	/**
-	 * 申请社团，映射数据库表的team_id字段。
-	 * <p>表示申请加入的社团ID。</p>
+	 * 申请社团ID，对应数据库表的team_id字段。
+	 * 表示申请加入的社团的唯一标识。
 	 */
 	@TableField(value = "team_id")
 	private String teamId;
 
 	/**
-	 * 申请用户，映射数据库表的user_id字段。
-	 * <p>表示提交申请的用户ID。</p>
+	 * 申请人ID，对应数据库表的user_id字段。
+	 * 表示提交申请的用户的标识。
 	 */
 	@TableField(value = "user_id")
 	private String userId;
 
 	/**
-	 * 获取记录ID。
-	 * @return 记录ID。
+	 * 获取申请记录的唯一标识。
+	 * @return 返回申请记录的ID。
 	 */
 	public String getId() {
 		return id;
 	}
 
 	/**
-	 * 设置记录ID。
-	 * @param id 记录ID。
+	 * 设置申请记录的唯一标识。
+	 * @param id 申请记录的ID。
 	 */
 	public void setId(String id) {
 		this.id = id;
 	}
 
 	/**
-	 * 获取处理状态。
-	 * @return 处理状态。
+	 * 获取申请的处理状态。
+	 * @return 返回申请的处理状态。
 	 */
 	public Integer getStatus() {
 		return status;
 	}
 
 	/**
-	 * 设置处理状态。
-	 * @param status 处理状态。
+	 * 设置申请的处理状态。
+	 * @param status 申请的处理状态。
 	 */
 	public void setStatus(Integer status) {
 		this.status = status;
 	}
 
 	/**
-	 * 获取申请时间。
-	 * @return 申请时间。
+	 * 获取申请的时间。
+	 * @return 返回申请的时间。
 	 */
 	public String getCreateTime() {
 		return createTime;
 	}
 
 	/**
-	 * 设置申请时间。
-	 * @param createTime 申请时间。
+	 * 设置申请的时间。
+	 * @param createTime 申请的时间。
 	 */
 	public void setCreateTime(String createTime) {
 		this.createTime = createTime;
 	}
 
 	/**
-	 * 获取申请社团ID。
-	 * @return 申请社团ID。
+	 * 获取申请社团的ID。
+	 * @return 返回申请社团的ID。
 	 */
 	public String getTeamId() {
 		return teamId;
 	}
 
 	/**
-	 * 设置申请社团ID。
-	 * @param teamId 申请社团ID。
+	 * 设置申请社团的ID。
+	 * @param teamId 申请社团的ID。
 	 */
 	public void setTeamId(String teamId) {
 		this.teamId = teamId;
 	}
 
 	/**
-	 * 获取申请用户ID。
-	 * @return 申请用户ID。
+	 * 获取申请人的ID。
+	 * @return 返回申请人的ID。
 	 */
 	public String getUserId() {
 		return userId;
 	}
 
 	/**
-	 * 设置申请用户ID。
-	 * @param userId 申请用户ID。
+	 * 设置申请人的ID。
+	 * @param userId 申请人的ID。
 	 */
 	public void setUserId(String userId) {
 		this.userId = userId;
 	}
 
 	/**
-	 * 重写toString方法，用于返回对象的字符串表示。
-	 * @return 包含对象所有字段信息的字符串。
+	 * 提供对象的字符串表示形式，方便日志记录和调试。
+	 * @return 返回包含对象所有属性的字符串。
 	 */
 	@Override
 	public String toString() {
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/ActiveLogsServiceImpl.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/ActiveLogsServiceImpl.java
new file mode 100644
index 0000000..2e2b4d1
--- /dev/null
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/ActiveLogsServiceImpl.java	
@@ -0,0 +1,129 @@
+package com.rabbiter.association.service;
+
+// 导入MyBatis Plus的QueryWrapper，用于构建查询条件
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+// 导入服务接口
+// 导入Spring的注解，用于声明服务和自动注入
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+// 导入Spring的注解，用于声明事务
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+// 导入DAO接口
+import com.rabbiter.association.dao.ActivitiesDao;
+import com.rabbiter.association.dao.UsersDao;
+import com.rabbiter.association.dao.ActiveLogsDao;
+// 导入实体类
+import com.rabbiter.association.entity.Activities;
+import com.rabbiter.association.entity.Users;
+import com.rabbiter.association.entity.ActiveLogs;
+// 导入Java的集合类
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * ActiveLogsService的服务实现类。
+ */
+@Service("activeLogsService") // 声明该类为activeLogsService的实现
+public class ActiveLogsServiceImpl implements ActiveLogsService {
+
+    // 自动注入UsersDao
+    @Autowired
+    private UsersDao usersDao;
+
+    // 自动注入ActiveLogsDao
+    @Autowired
+    private ActiveLogsDao activeLogsDao;
+
+    // 自动注入ActivitiesDao
+    @Autowired
+    private ActivitiesDao activitiesDao;
+
+    /**
+     * 添加新的报名记录。
+     * 在添加报名记录的同时，更新活动总报名人数。
+     */
+    @Override
+    @Transactional // 声明事务，确保操作的原子性
+    public void add(ActiveLogs activeLogs) {
+        Activities activitie = activitiesDao.selectById(activeLogs.getActiveId()); // 根据活动ID查询活动
+        activitie.setTotal(activitie.getTotal() + 1); // 增加活动报名人数
+        activitiesDao.updateById(activitie); // 更新活动信息
+
+        activeLogsDao.insert(activeLogs); // 插入报名记录
+    }
+
+    /**
+     * 更新报名记录。
+     */
+    @Override
+    @Transactional // 声明事务
+    public void update(ActiveLogs activeLogs) {
+        activeLogsDao.updateById(activeLogs); // 更新报名记录
+    }
+
+    /**
+     * 删除报名记录。
+     */
+    @Override
+    @Transactional // 声明事务
+    public void delete(ActiveLogs activeLogs) {
+        activeLogsDao.deleteById(activeLogs); // 根据ID删除报名记录
+    }
+
+    /**
+     * 检查用户是否已经报名参加活动。
+     * 如果用户未报名返回true，否则返回false。
+     */
+    @Override
+    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
+    public Boolean isActive(String activeId, String userId){
+        QueryWrapper<ActiveLogs> qw = new QueryWrapper<>(); // 创建查询条件构造器
+        qw.eq("active_id", activeId).eq("user_id", userId); // 添加查询条件
+
+        return activeLogsDao.selectCount(qw) <= 0; // 查询符合条件的记录数，如果为0则未报名
+    }
+
+    /**
+     * 根据ID获取单个报名记录。
+     */
+    @Override
+    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
+    public ActiveLogs getOne(String id) {
+        return activeLogsDao.selectById(id); // 根据ID查询报名记录
+    }
+
+    /**
+     * 根据活动ID获取报名记录列表。
+     * 返回包含报名详细信息的Map列表。
+     */
+    @Override
+    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
+    public List<Map<String, Object>> getListByActiveId(String activeId){
+        List<Map<String, Object>> resl = new ArrayList<>(); // 存储结果的列表
+
+        QueryWrapper<ActiveLogs> qw = new QueryWrapper<>(); // 创建查询条件构造器
+        qw.eq("active_id", activeId).orderByDesc("create_time"); // 添加查询条件并排序
+
+        List<ActiveLogs> activeLogs = activeLogsDao.selectList(qw); // 查询报名记录列表
+
+        for (ActiveLogs activeLog : activeLogs) {
+            Map<String, Object> temp = new HashMap<>(); // 存储单个报名记录的详细信息
+            temp.put("id", activeLog.getId());
+            temp.put("createTime", activeLog.getCreateTime());
+            temp.put("activeId", activeLog.getActiveId());
+
+            Users user = usersDao.selectById(activeLog.getUserId()); // 根据用户ID查询用户信息
+            temp.put("userId", activeLog.getUserId());
+            temp.put("userName", user.getName());
+            temp.put("userGender", user.getGender());
+            temp.put("userPhone", user.getPhone());
+
+            resl.add(temp); // 将单个报名记录的详细信息添加到结果列表
+        }
+
+        return resl; // 返回结果列表
+    }
+}
\ No newline at end of file
diff --git a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/impl/ApplyLogsServiceImpl.java b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/impl/ApplyLogsServiceImpl.java
index b272584..3dac197 100644
--- a/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/impl/ApplyLogsServiceImpl.java	
+++ b/springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/impl/ApplyLogsServiceImpl.java	
@@ -1,121 +1,144 @@
 package com.rabbiter.association.service.impl;
 
+// 导入MyBatis Plus的QueryWrapper，用于构建查询条件
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+// 导入MyBatis Plus的分页插件
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 导入服务接口
+// 导入Spring的注解，用于声明服务和自动注入
 import com.rabbiter.association.service.ApplyLogsService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-
+// 导入Spring的注解，用于声明事务
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
+// 导入DAO接口
 import com.rabbiter.association.dao.MembersDao;
 import com.rabbiter.association.dao.TeamsDao;
+import com.rabbiter.association.dao.ApplyLogsDao;
+// 导入实体类
 import com.rabbiter.association.entity.Members;
 import com.rabbiter.association.entity.Teams;
-import com.rabbiter.association.msg.PageData;
 import com.rabbiter.association.entity.ApplyLogs;
-import com.rabbiter.association.dao.ApplyLogsDao;
+// 导入自定义的分页数据类
+import com.rabbiter.association.msg.PageData;
+// 导入工具类
 import com.rabbiter.association.utils.DateUtils;
 import com.rabbiter.association.utils.IDUtils;
 
 import java.util.Map;
 
-@Service("applyLogsService")
+
+/**
+ * ApplyLogsService的服务实现类。
+ */
+@Service("applyLogsService") // 声明该类为applyLogsService的实现
 public class ApplyLogsServiceImpl implements ApplyLogsService {
 
+    // 自动注入MembersDao
     @Autowired
     private MembersDao membersDao;
 
+    // 自动注入ApplyLogsDao
     @Autowired
     private ApplyLogsDao applyLogsDao;
 
+    // 自动注入TeamsDao
     @Autowired
     private TeamsDao teamsDao;
 
+    /**
+     * 添加申请记录。
+     */
     @Override
-    @Transactional
+    @Transactional // 声明事务，确保操作的原子性
     public void add(ApplyLogs applyLogs) {
-
-        applyLogsDao.insert(applyLogs);
+        applyLogsDao.insert(applyLogs); // 插入申请记录
     }
 
+    /**
+     * 更新申请记录。
+     * 如果申请通过，则创建成员记录并更新团队人数。
+     */
     @Override
-    @Transactional
+    @Transactional // 声明事务
     public void update(ApplyLogs applyLogs) {
-
-        if(applyLogs.getStatus() != null && applyLogs.getStatus() == 1){
-
-            Members member = new Members();
-            member.setId(IDUtils.makeIDByCurrent());
-            member.setCreateTime(DateUtils.getNowDate());
-            member.setUserId(applyLogs.getUserId());
-            member.setTeamId(applyLogs.getTeamId());
-
-            membersDao.insert(member);
-
-            Teams teams = teamsDao.selectById(applyLogs.getTeamId());
-            teams.setTotal(teams.getTotal() + 1);
-            teamsDao.updateById(teams);
+        if(applyLogs.getStatus() != null && applyLogs.getStatus() == 1){ // 如果申请通过
+            Members member = new Members(); // 创建成员记录
+            member.setId(IDUtils.makeIDByCurrent()); // 生成成员ID
+            member.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
+            member.setUserId(applyLogs.getUserId()); // 设置用户ID
+            member.setTeamId(applyLogs.getTeamId()); // 设置团队ID
+
+            membersDao.insert(member); // 插入成员记录
+
+            Teams teams = teamsDao.selectById(applyLogs.getTeamId()); // 根据ID查询团队
+            teams.setTotal(teams.getTotal() + 1); // 增加团队人数
+            teamsDao.updateById(teams); // 更新团队信息
         }
 
-        applyLogsDao.updateById(applyLogs);
+        applyLogsDao.updateById(applyLogs); // 更新申请记录
     }
 
+    /**
+     * 删除申请记录。
+     */
     @Override
-    @Transactional
+    @Transactional // 声明事务
     public void delete(ApplyLogs applyLogs) {
-
-        applyLogsDao.deleteById(applyLogs);
+        applyLogsDao.deleteById(applyLogs); // 根据ID删除申请记录
     }
 
+    /**
+     * 检查用户是否已对团队提交申请。
+     * 如果未提交申请返回true，否则返回false。
+     */
     @Override
-    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
+    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
     public Boolean isApply(String userId, String teamId){
+        QueryWrapper<ApplyLogs> qw = new QueryWrapper<>(); // 创建查询条件构造器
+        qw.eq("user_id", userId).eq("team_id", teamId).eq("status", 0); // 添加查询条件
 
-        QueryWrapper<ApplyLogs> qw = new QueryWrapper<ApplyLogs>();
-        qw.eq("user_id", userId);
-        qw.eq("team_id", teamId);
-        qw.eq("status", 0);
-
-        return applyLogsDao.selectCount(qw) <= 0;
+        return applyLogsDao.selectCount(qw) <= 0; // 查询符合条件的记录数，如果为0则未申请
     }
 
+    /**
+     * 根据ID获取单个申请记录。
+     */
     @Override
-    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
+    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
     public ApplyLogs getOne(String id) {
-
-        ApplyLogs applyLogs = applyLogsDao.selectById(id);
-
-        return applyLogs;
+        return applyLogsDao.selectById(id); // 根据ID查询申请记录
     }
 
+    /**
+     * 获取管理员分页的申请记录信息。
+     */
     @Override
-    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
+    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
     public PageData getManPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName) {
+        Page<Map<String, Object>> page = applyLogsDao.qryManPageInfo(new Page<>(pageIndex, pageSize), userId, teamName, userName); // 分页查询
 
-        Page<Map<String, Object>> page =
-                applyLogsDao.qryManPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName);
-
-        return parsePage(page);
+        return parsePage(page); // 转换分页结果
     }
 
+    /**
+     * 获取普通用户分页的申请记录信息。
+     */
     @Override
-    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
+    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
     public PageData getPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName) {
+        Page<Map<String, Object>> page = applyLogsDao.qryPageInfo(new Page<>(pageIndex, pageSize), userId, teamName, userName); // 分页查询
 
-        Page<Map<String, Object>> page =
-                applyLogsDao.qryPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName);
-
-        return parsePage(page);
+        return parsePage(page); // 转换分页结果
     }
 
     /**
-     * 转化分页查询的结果
+     * 将MyBatis Plus的分页结果转换为自定义的PageData对象。
      */
     public PageData parsePage(Page<Map<String, Object>> p) {
+        PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); // 创建PageData对象
 
-        PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords());
-
-        return pageData;
+        return pageData; // 返回转换后的分页数据
     }
 }
\ No newline at end of file