p6zkavi9o
/
club_system
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

zhushi #9

Merged
pfvaqhn2p merged 3 commits from branch-wangjy into develop_idea 1 year ago
Conversation 0 Commits 3 Files Changed 12
12 changed files with 447 additions and 436 deletions
Show Stats Download Patch File Download Diff File

2
springboota009社团管理系统/代码/AssociationManagerApi - idea/.idea/vcs.xml
Unescape View File

@ -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>

105
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActiveLogsController.java
Unescape View File

@ -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();
}
}

52
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActivitiesController.java
Unescape View File

@ -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
}

102
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ApplyLogsController.java
Unescape View File

@ -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();
}
}

42
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/BaseController.java
Unescape View File

@ -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();
}
}
}

133
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/IndexController.java
Unescape View File

@ -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();
// 返回成功响应
}
}

15
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ActiveLogsDao.java
Unescape View File

@ -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> {
}
// 该接口继承BaseMapper后已经包含了基本的CRUD操作，无需额外定义方法
// 可以根据需要添加自定义的数据库操作方法
}

40
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ApplyLogsDao.java
Unescape View File

@ -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 " +

62
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ActiveLogs.java
Unescape View File

@ -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() {

74
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ApplyLogs.java
Unescape View File

@ -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() {

129
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/ActiveLogsServiceImpl.java
Unescape View File

@ -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; // 返回结果列表
}
}

127
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/impl/ApplyLogsServiceImpl.java
Unescape View File

@ -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; // 返回转换后的分页数据
}
}
Write Preview
Loading…
Cancel
Save