YZY 4 months ago
parent 43e6486731
commit 562311e111

@ -146,6 +146,7 @@
<workItem from="1744197535410" duration="1873000" />
<workItem from="1744199899989" duration="1551000" />
<workItem from="1744202106298" duration="8351000" />
<workItem from="1744270789267" duration="1977000" />
</task>
<servers />
</component>

@ -1,78 +1,82 @@
package self.cases.teams;
package self.cases.teams; // 定义项目主包名
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import com.alibaba.fastjson.serializer.SerializerFeature; // 引入 FastJSON 的序列化特性
import com.alibaba.fastjson.support.config.FastJsonConfig; // 引入 FastJSON 的配置类
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter; // 引入 FastJSON 的 HTTP 消息转换器
import com.baomidou.mybatisplus.annotation.DbType; // 引入 MyBatis-Plus 的数据库类型枚举
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; // 引入 MyBatis-Plus 的拦截器
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; // 引入 MyBatis-Plus 的分页拦截器
import org.mybatis.spring.annotation.MapperScan; // 引入 MyBatis 的 Mapper 扫描注解
import org.springframework.boot.SpringApplication; // 引入 Spring Boot 的启动类
import org.springframework.boot.autoconfigure.SpringBootApplication; // 引入 Spring Boot 的启动注解
import org.springframework.boot.autoconfigure.http.HttpMessageConverters; // 引入 Spring Boot 的消息转换器
import org.springframework.cache.annotation.EnableCaching; // 引入缓存注解
import org.springframework.context.annotation.Bean; // 引入 Bean 注解
import org.springframework.http.MediaType; // 引入 HTTP 媒体类型
import org.springframework.http.converter.HttpMessageConverter; // 引入 HTTP 消息转换器
import org.springframework.web.servlet.config.annotation.CorsRegistry; // 引入 CORS 配置
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; // 引入 Web MVC 配置
import java.util.ArrayList;
import java.util.List;
import java.util.ArrayList; // 导入 ArrayList 类,用于创建动态数组
import java.util.List; // 导入 List 接口,用于表示有序集合
@SpringBootApplication
@MapperScan({"self.cases.teams.dao"})
@EnableCaching
public class Application implements WebMvcConfigurer{
@SpringBootApplication // 启动类注解
@MapperScan({"self.cases.teams.dao"}) // 扫描 Mapper 接口所在的包
@EnableCaching // 开启缓存功能
public class Application implements WebMvcConfigurer { // 定义启动类并实现 WebMvcConfigurer 接口
/**
* JSON
* @return
* @return FastJsonHttpMessageConverter
*/
@Bean
@Bean // 声明为 Spring 容器中的 Bean
public HttpMessageConverters fastJsonHttpMessageConverters() {
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
FastJsonConfig fastJsonConfig = new FastJsonConfig();
fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
List<MediaType> fastMedisTypes = new ArrayList<>();
fastMedisTypes.add(MediaType.APPLICATION_JSON);
fastConverter.setSupportedMediaTypes(fastMedisTypes);
fastConverter.setFastJsonConfig(fastJsonConfig);
HttpMessageConverter<?> converter = fastConverter;
return new HttpMessageConverters(converter);
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter(); // 创建 FastJSON 消息转换器实例
FastJsonConfig fastJsonConfig = new FastJsonConfig(); // 创建 FastJSON 配置实例
fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat); // 设置序列化特性为美化格式
List<MediaType> fastMedisTypes = new ArrayList<>(); // 创建支持的媒体类型列表
fastMedisTypes.add(MediaType.APPLICATION_JSON); // 添加 JSON 类型
fastConverter.setSupportedMediaTypes(fastMedisTypes); // 设置支持的媒体类型
fastConverter.setFastJsonConfig(fastJsonConfig); // 设置 FastJSON 配置
HttpMessageConverter<?> converter = fastConverter; // 转换为通用消息转换器
return new HttpMessageConverters(converter); // 返回消息转换器集合
}
/**
* MySQL
* @return
* MySQL
* @return MybatisPlusInterceptor
*/
@Bean
@Bean // 声明为 Spring 容器中的 Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return interceptor;
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); // 创建拦截器实例
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 添加分页拦截器,并指定数据库类型为 MySQL
return interceptor; // 返回拦截器实例
}
@Bean
/**
* (CORS)
* @return WebMvcConfigurer
*/
@Bean // 声明为 Spring 容器中的 Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurer() {
@Override
return new WebMvcConfigurer() { // 匿名内部类实现 WebMvcConfigurer 接口
@Override // 重写 addCorsMappings 方法
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("*")
.allowCredentials(true)
.allowedMethods("GET", "POST", "DELETE", "PUT","PATCH")
.maxAge(3600);
registry.addMapping("/**") // 配置所有路径都支持跨域
.allowedOrigins("*") // 允许所有来源访问
.allowCredentials(true) // 允许携带凭证(如 Cookies
.allowedMethods("GET", "POST", "DELETE", "PUT", "PATCH") // 允许的 HTTP 方法
.maxAge(3600); // 设置预检请求的有效期为 3600 秒
}
};
}
/**
*
* @param args
*/
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
SpringApplication.run(Application.class, args); // 启动 Spring Boot 应用程序
}
}

@ -6,24 +6,26 @@ import java.util.*;
import java.util.stream.Collectors;
// 学生类
// 定义一个名为 Student 的类,实现序列化接口,用于存储学生信息
class Student implements Serializable {
private String id;
private String name;
private int age;
private String className;
private Date enrollDate;
private Map<String, Double> scores;
private String id; // 学号
private String name; // 姓名
private int age; // 年龄
private String className; // 班级
private Date enrollDate; // 入学日期
private Map<String, Double> scores; // 存储学生成绩的映射表
// 构造函数,初始化学生的基本信息
public Student(String id, String name, int age, String className) {
this.id = id;
this.name = name;
this.age = age;
this.className = className;
this.enrollDate = new Date();
this.scores = new HashMap<>();
this.enrollDate = new Date(); // 当前时间作为入学日期
this.scores = new HashMap<>(); // 初始化空的成绩表
}
// Getter和Setter方法
// Getter Setter 方法,用于访问和修改私有字段
public String getId() { return id; }
public String getName() { return name; }
public int getAge() { return age; }
@ -31,321 +33,350 @@ class Student implements Serializable {
public Date getEnrollDate() { return enrollDate; }
public Map<String, Double> getScores() { return scores; }
// 更新学生的某门课程成绩
public void updateScore(String course, double score) {
scores.put(course, score);
}
// 计算学生的平均成绩
public double calculateAverage() {
return scores.values().stream()
.mapToDouble(Double::doubleValue)
.average()
.orElse(0.0);
.orElse(0.0); // 如果没有成绩则返回默认值 0.0
}
// 将学生信息以字符串形式输出
@Override
public String toString() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
return String.format("学号: %s\n姓名: %s\n年龄: %d\n班级: %s\n入学日期: %s",
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 格式化日期
return String.format("学号: %s\\n姓名: %s\\n年龄: %d\\n班级: %s\\n入学日期: %s",
id, name, age, className, sdf.format(enrollDate));
}
}
// 课程管理类
// 定义一个名为 CourseManager 的类,用于管理课程信息
class CourseManager {
private static final List<String> AVAILABLE_COURSES = Arrays.asList(
"数学", "语文", "英语", "物理", "化学"
"数学", "语文", "英语", "物理", "化学" // 可用课程列表
);
// 判断课程是否有效
public static boolean isValidCourse(String course) {
return AVAILABLE_COURSES.contains(course);
}
// 显示可用课程列表
public static void showAvailableCourses() {
System.out.println("可选课程列表:");
AVAILABLE_COURSES.forEach(c -> System.out.print(c + " "));
AVAILABLE_COURSES.forEach(c -> System.out.print(c + " ")); // 打印课程名
System.out.println();
}
}
// 文件工具类
// 定义一个名为 FileUtil 的类,用于文件操作
class FileUtil {
private static final String DATA_FILE = "students.dat";
private static final String DATA_FILE = "students.dat"; // 数据文件路径
// 将学生列表保存到文件中
public static void saveData(List<Student> students) {
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(DATA_FILE))) {
oos.writeObject(students);
oos.writeObject(students); // 序列化并写入文件
} catch (IOException e) {
System.err.println("数据保存失败: " + e.getMessage());
System.err.println("数据保存失败: " + e.getMessage()); // 错误处理
}
}
// 从文件中加载学生数据
@SuppressWarnings("unchecked")
public static List<Student> loadData() {
File file = new File(DATA_FILE);
if (!file.exists()) return new ArrayList<>();
if (!file.exists()) return new ArrayList<>(); // 文件不存在时返回空列表
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream(DATA_FILE))) {
return (List<Student>) ois.readObject();
return (List<Student>) ois.readObject(); // 反序列化读取数据
} catch (IOException | ClassNotFoundException e) {
System.err.println("数据加载失败: " + e.getMessage());
return new ArrayList<>();
System.err.println("数据加载失败: " + e.getMessage()); // 错误处理
return new ArrayList<>(); // 返回空列表
}
}
}
// 输入工具类
// 定义一个名为 InputUtil 的类,用于获取用户输入
class InputUtil {
private static final Scanner scanner = new Scanner(System.in);
private static final Scanner scanner = new Scanner(System.in); // 输入流
// 获取整数输入
public static int getIntInput(String prompt) {
while (true) {
System.out.print(prompt);
System.out.print(prompt); // 提示信息
try {
return Integer.parseInt(scanner.nextLine());
return Integer.parseInt(scanner.nextLine()); // 转换为整数
} catch (NumberFormatException e) {
System.out.println("输入无效,请输入整数!");
System.out.println("输入无效,请输入整数!"); // 错误提示
}
}
}
// 获取字符串输入
public static String getStringInput(String prompt) {
System.out.print(prompt);
return scanner.nextLine().trim();
System.out.print(prompt); // 提示信息
return scanner.nextLine().trim(); // 去除首尾空格
}
// 获取双精度浮点数输入
public static double getDoubleInput(String prompt) {
while (true) {
System.out.print(prompt);
System.out.print(prompt); // 提示信息
try {
return Double.parseDouble(scanner.nextLine());
return Double.parseDouble(scanner.nextLine()); // 转换为浮点数
} catch (NumberFormatException e) {
System.out.println("输入无效,请输入数字!");
System.out.println("输入无效,请输入数字!"); // 错误提示
}
}
}
}
// 主系统类
// 定义主系统类 StudentManagementSystem
class StudentManagementSystem {
private List<Student> students;
private boolean isRunning = true;
private List<Student> students; // 存储学生列表
private boolean isRunning = true; // 控制程序运行状态
// 构造函数,初始化学生列表并加载数据
public StudentManagementSystem() {
students = FileUtil.loadData();
}
// 启动系统主循环
public void start() {
while (isRunning) {
showMainMenu();
int choice = InputUtil.getIntInput("请选择操作:");
handleMainMenu(choice);
showMainMenu(); // 显示主菜单
int choice = InputUtil.getIntInput("请选择操作:"); // 获取用户选择
handleMainMenu(choice); // 处理用户选择
}
}
// 显示主菜单
private void showMainMenu() {
System.out.println("\n==== 学生信息管理系统 ====");
System.out.println("\\n==== 学生信息管理 ====");
System.out.println("1. 添加学生");
System.out.println("2. 查询学生");
System.out.println("3. 录入成绩");
System.out.println("3. 录入活动成绩");
System.out.println("4. 显示统计");
System.out.println("5. 删除学生");
System.out.println("5. 删除学生信息");
System.out.println("6. 保存数据");
System.out.println("7. 退出系统");
}
// 处理主菜单选项
private void handleMainMenu(int choice) {
switch (choice) {
// case 1 -> addStudent();
// case 2 -> searchStudent();
// case 3 -> inputScore();
// case 4 -> showStatistics();
// case 5 -> deleteStudent();
// case 6 -> saveData();
// case 7 -> exitSystem();
// case 1 -> addStudent(); // 添加学生
// case 2 -> searchStudent(); // 查询学生
// case 3 -> inputScore(); // 录入成绩
// case 4 -> showStatistics(); // 显示统计信息
// case 5 -> deleteStudent(); // 删除学生
// case 6 -> saveData(); // 保存数据
// case 7 -> exitSystem(); // 退出系统
// default -> System.out.println("无效选项!");
}
}
// 添加学生
private void addStudent() {
String id = InputUtil.getStringInput("请输入学号:");
if (isStudentExist(id)) {
String id = InputUtil.getStringInput("请输入学号:"); // 获取学号
if (isStudentExist(id)) { // 检查学号是否已存在
System.out.println("该学号已存在!");
return;
}
String name = InputUtil.getStringInput("请输入姓名:");
int age = InputUtil.getIntInput("请输入年龄:");
String className = InputUtil.getStringInput("请输入班级:");
String name = InputUtil.getStringInput("请输入姓名:"); // 获取姓名
int age = InputUtil.getIntInput("请输入年龄:"); // 获取年龄
String className = InputUtil.getStringInput("请输入班级:"); // 获取班级
Student student = new Student(id, name, age, className);
students.add(student);
Student student = new Student(id, name, age, className); // 创建学生对象
students.add(student); // 添加到学生列表
System.out.println("学生添加成功!");
}
// 查询学生
private void searchStudent() {
System.out.println("\n==== 查询选项 ====");
System.out.println("\\n==== 查询选项 ====");
System.out.println("1. 按学号查询");
System.out.println("2. 按姓名查询");
System.out.println("3. 显示全部");
int choice = InputUtil.getIntInput("请选择查询方式:");
int choice = InputUtil.getIntInput("请选择查询方式:"); // 获取查询方式
switch (choice) {
// case 1 -> searchById();
// case 2 -> searchByName();
// case 3 -> showAllStudents();
// case 1 -> searchById(); // 按学号查询
// case 2 -> searchByName(); // 按姓名查询
// case 3 -> showAllStudents(); // 显示全部学生
// default -> System.out.println("无效选项!");
}
}
// 按学号查询学生
private void searchById() {
String id = InputUtil.getStringInput("请输入学号:");
String id = InputUtil.getStringInput("请输入学号:"); // 获取学号
students.stream()
.filter(s -> s.getId().equals(id))
.findFirst();
.filter(s -> s.getId().equals(id)) // 筛选符合条件的学生
.findFirst(); // 查找第一个匹配项
}
// 按姓名查询学生
private void searchByName() {
String name = InputUtil.getStringInput("请输入姓名:");
String name = InputUtil.getStringInput("请输入姓名:"); // 获取姓名
List<Student> result = null;
try {
students.stream()
.filter(s -> s.getName().equalsIgnoreCase(name))
.wait();
.filter(s -> s.getName().equalsIgnoreCase(name)) // 忽略大小写筛选
.wait(); // 等待(此处有误,应改为 collect 或其他操作)
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (result.isEmpty()) {
if (result.isEmpty()) { // 如果未找到学生
System.out.println("找不到该学生");
} else {
result.forEach(System.out::println);
result.forEach(System.out::println); // 输出学生信息
}
}
// 显示所有学生
private void showAllStudents() {
if (students.isEmpty()) {
if (students.isEmpty()) { // 如果学生列表为空
System.out.println("当前没有学生记录");
return;
}
students.forEach(s -> {
System.out.println(s);
students.forEach(s -> { // 遍历学生列表
System.out.println(s); // 输出学生信息
System.out.println("--------------------");
});
}
// 录入成绩
private void inputScore() {
String id = InputUtil.getStringInput("请输入学号:");
Student student = findStudentById(id);
if (student == null) {
String id = InputUtil.getStringInput("请输入学号:"); // 获取学号
Student student = findStudentById(id); // 查找学生
if (student == null) { // 如果学生不存在
System.out.println("学生不存在!");
return;
}
CourseManager.showAvailableCourses();
String course = InputUtil.getStringInput("请输入课程名称:");
if (!CourseManager.isValidCourse(course)) {
CourseManager.showAvailableCourses(); // 显示可用课程
String course = InputUtil.getStringInput("请输入课程名称:"); // 获取课程名称
if (!CourseManager.isValidCourse(course)) { // 检查课程是否有效
System.out.println("无效课程!");
return;
}
double score = InputUtil.getDoubleInput("请输入成绩:");
student.updateScore(course, score);
double score = InputUtil.getDoubleInput("请输入成绩:"); // 获取成绩
student.updateScore(course, score); // 更新学生成绩
System.out.println("成绩录入成功!");
}
// 显示统计信息
private void showStatistics() {
System.out.println("\n==== 统计信息 ====");
System.out.println("\\n==== 统计信息 ====");
System.out.println("1. 班级人数统计");
System.out.println("2. 课程平均分");
System.out.println("3. 学生个人成绩");
int choice = InputUtil.getIntInput("请选择统计类型:");
int choice = InputUtil.getIntInput("请选择统计类型:"); // 获取统计类型
switch (choice) {
// case 1 -> showClassStatistics();
// case 2 -> showCourseStatistics();
// case 3 -> showStudentScores();
// case 1 -> showClassStatistics(); // 显示班级人数统计
// case 2 -> showCourseStatistics(); // 显示课程平均分
// case 3 -> showStudentScores(); // 显示学生个人成绩
// default -> System.out.println("无效选项!");
}
}
// 显示班级人数统计
private void showClassStatistics() {
Map<String, Long> classCount = students.stream()
.collect(Collectors.groupingBy(
Student::getClassName,
Collectors.counting()));
Student::getClassName, // 按班级分组
Collectors.counting())); // 统计每班人数
classCount.forEach((className, count) ->
System.out.printf("班级 %s: %d 人\n", className, count));
classCount.forEach((className, count) -> // 遍历班级和人数
System.out.printf("班级 %s: %d 人\\n", className, count)); // 输出结果
}
// 显示课程平均分
private void showCourseStatistics() {
Map<String, Double> courseAverages = new HashMap<>();
students.forEach(student ->
student.getScores().forEach((course, score) ->
courseAverages.merge(course, score, Double::sum)));
students.forEach(student -> // 遍历每个学生
student.getScores().forEach((course, score) -> // 遍历每门课程成绩
courseAverages.merge(course, score, Double::sum))); // 累加成绩
courseAverages.forEach((course, total) -> {
courseAverages.forEach((course, total) -> { // 遍历课程总分
long count = students.stream()
.filter(s -> s.getScores().containsKey(course))
.count();
double average = count > 0 ? total / count : 0;
System.out.printf("%s 平均分: %.2f\n", course, average);
.filter(s -> s.getScores().containsKey(course)) // 筛选有该课程的学生
.count(); // 统计学生数量
double average = count > 0 ? total / count : 0; // 计算平均分
System.out.printf("%s 平均分: %.2f\\n", course, average); // 输出结果
});
}
// 显示学生个人成绩
private void showStudentScores() {
String id = InputUtil.getStringInput("请输入学号:");
Student student = findStudentById(id);
if (student == null) {
String id = InputUtil.getStringInput("请输入学号:"); // 获取学号
Student student = findStudentById(id); // 查找学生
if (student == null) { // 如果学生不存在
System.out.println("学生不存在!");
return;
}
System.out.println(student);
if (student.getScores().isEmpty()) {
System.out.println(student); // 输出学生基本信息
if (student.getScores().isEmpty()) { // 如果没有成绩记录
System.out.println("暂无成绩记录");
return;
}
student.getScores().forEach((course, score) ->
System.out.printf("%s: %.2f\n", course, score));
System.out.printf("平均分: %.2f\n", student.calculateAverage());
student.getScores().forEach((course, score) -> // 遍历每门课程成绩
System.out.printf("%s: %.2f\\n", course, score)); // 输出课程成绩
System.out.printf("平均分: %.2f\\n", student.calculateAverage()); // 输出平均分
}
// 删除学生信息
private void deleteStudent() {
String id = InputUtil.getStringInput("请输入要删除的学号:");
boolean removed = students.removeIf(s -> s.getId().equals(id));
System.out.println(removed ? "删除成功!" : "学生不存在!");
String id = InputUtil.getStringInput("请输入要删除的学号:"); // 获取学号
boolean removed = students.removeIf(s -> s.getId().equals(id)); // 删除学生
System.out.println(removed ? "删除成功!" : "学生不存在!"); // 输出结果
}
// 保存数据
private void saveData() {
FileUtil.saveData(students);
FileUtil.saveData(students); // 保存学生列表到文件
System.out.println("数据已保存!");
}
// 退出系统
private void exitSystem() {
isRunning = false;
System.out.println("正在退出系统...");
saveData();
System.out.println("谢谢使用!");
isRunning = false; // 设置运行标志为 false
System.out.println("正在退出系统..."); // 提示退出
saveData(); // 保存数据
System.out.println("谢谢使用!"); // 结束提示
}
// 检查学号是否存在
private boolean isStudentExist(String id) {
return students.stream()
.anyMatch(s -> s.getId().equals(id));
.anyMatch(s -> s.getId().equals(id)); // 判断是否有相同学号的学生
}
// 根据学号查找学生
private Student findStudentById(String id) {
return students.stream()
.filter(s -> s.getId().equals(id))
.findFirst()
.orElse(null);
.filter(s -> s.getId().equals(id)) // 筛选符合条件的学生
.findFirst() // 查找第一个匹配项
.orElse(null); // 如果未找到返回 null
}
public static void main(String[] args) {
new StudentManagementSystem().start();
new StudentManagementSystem().start(); // 启动系统
}
}
}

@ -1,121 +1,120 @@
package self.cases.teams.controller;
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;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import self.cases.teams.entity.Users;
import self.cases.teams.handle.CacheHandle;
import self.cases.teams.service.UsersService;
import self.cases.teams.utils.DateUtils;
import self.cases.teams.utils.IDUtils;
import self.cases.teams.msg.R;
import self.cases.teams.msg.PageData;
import self.cases.teams.entity.ActiveLogs;
import self.cases.teams.service.ActiveLogsService;
import java.util.List;
import java.util.Map;
import org.slf4j.LoggerFactory; // 导入日志工具类
import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.*; // RESTful 注解支持
import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理注解
import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据注解
import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.handle.CacheHandle; // 缓存处理类
import self.cases.teams.service.UsersService; // 用户服务接口
import self.cases.teams.utils.DateUtils; // 日期工具类
import self.cases.teams.utils.IDUtils; // ID 工具类
import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.entity.ActiveLogs; // 报名记录实体类
import self.cases.teams.service.ActiveLogsService; // 报名记录服务接口
import java.util.List; // Java 集合 List 接口
import java.util.Map; // Java 集合 Map 接口
/**
*
*
*/
@Controller
@RequestMapping("/activeLogs")
public class ActiveLogsController extends BaseController {
@RequestMapping("/activeLogs") // 设置默认请求路径
public class ActiveLogsController extends BaseController { // 继承基础控制器
protected static final Logger Log = LoggerFactory.getLogger(ActiveLogsController.class);
protected static final Logger Log = LoggerFactory.getLogger(ActiveLogsController.class); // 日志实例
@Autowired
@Autowired // 自动注入缓存处理类
private CacheHandle cacheHandle;
@Autowired
@Autowired // 自动注入用户服务
private UsersService usersService;
@Autowired
@Autowired // 自动注入报名记录服务
private ActiveLogsService activeLogsService;
@RequestMapping("")
@RequestMapping("") // 默认请求映射
public String index() {
return "pages/ActiveLogs";
return "pages/ActiveLogs"; // 返回视图页面名称
}
@GetMapping("/info")
@ResponseBody
@GetMapping("/info") // GET 请求获取单条记录
@ResponseBody // 返回 JSON 数据
public R getInfo(String id) {
Log.info("查找指定报名记录ID{}", id);
Log.info("查找指定报名记录ID{}", id); // 记录日志
ActiveLogs activeLogs = activeLogsService.getOne(id);
ActiveLogs activeLogs = activeLogsService.getOne(id); // 查询单条记录
return R.successData(activeLogs);
return R.successData(activeLogs); // 返回成功数据
}
@GetMapping("/list")
@ResponseBody
@GetMapping("/list") // GET 请求获取指定活动的报名记录
@ResponseBody // 返回 JSON 数据
public R getList(String activeId) {
Log.info("获取指定活动的报名记录活动ID{}", activeId);
Log.info("获取指定活动的报名记录活动ID{}", activeId); // 记录日志
List<Map<String, Object>> list = activeLogsService.getListByActiveId(activeId);
List<Map<String, Object>> list = activeLogsService.getListByActiveId(activeId); // 查询指定活动的报名记录
return R.successData(list);
return R.successData(list); // 返回成功数据
}
@PostMapping("/add")
@ResponseBody
@PostMapping("/add") // POST 请求新增记录
@ResponseBody // 返回 JSON 数据
public R addInfo(String token, ActiveLogs activeLogs) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 获取当前用户
if (activeLogsService.isActive(activeLogs.getActiveId(), user.getId())) { // 判断是否已参与
if(activeLogsService.isActive(activeLogs.getActiveId(), user.getId())){
activeLogs.setId(IDUtils.makeIDByCurrent()); // 生成唯一 ID
activeLogs.setUserId(user.getId()); // 设置用户 ID
activeLogs.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
activeLogs.setId(IDUtils.makeIDByCurrent());
activeLogs.setUserId(user.getId());
activeLogs.setCreateTime(DateUtils.getNowDate());
Log.info("添加报名记录,传入参数:{}", activeLogs); // 记录日志
Log.info("添加报名记录,传入参数:{}", activeLogs);
activeLogsService.add(activeLogs); // 添加记录
activeLogsService.add(activeLogs);
return R.success(); // 返回成功响应
return R.success();
}else{
} else {
return R.warn("该活动您已参与,请勿重复报名");
return R.warn("该活动您已参与,请勿重复报名"); // 返回警告响应
}
}
@PostMapping("/upd")
@ResponseBody
@PostMapping("/upd") // POST 请求更新记录
@ResponseBody // 返回 JSON 数据
public R updInfo(ActiveLogs activeLogs) {
Log.info("修改报名记录,传入参数:{}", activeLogs);
Log.info("修改报名记录,传入参数:{}", activeLogs); // 记录日志
activeLogsService.update(activeLogs);
activeLogsService.update(activeLogs); // 更新记录
return R.success();
return R.success(); // 返回成功响应
}
@PostMapping("/del")
@ResponseBody
@PostMapping("/del") // POST 请求删除记录
@ResponseBody // 返回 JSON 数据
public R delInfo(String id) {
Log.info("删除报名记录, ID:{}", id);
Log.info("删除报名记录, ID:{}", id); // 记录日志
ActiveLogs activeLogs = activeLogsService.getOne(id);
ActiveLogs activeLogs = activeLogsService.getOne(id); // 查询待删除记录
activeLogsService.delete(activeLogs);
activeLogsService.delete(activeLogs); // 删除记录
return R.success();
return R.success(); // 返回成功响应
}
}
}

@ -1,146 +1,142 @@
package self.cases.teams.controller;
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;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import self.cases.teams.entity.Users;
import self.cases.teams.handle.CacheHandle;
import self.cases.teams.service.UsersService;
import self.cases.teams.utils.DateUtils;
import self.cases.teams.utils.IDUtils;
import self.cases.teams.msg.R;
import self.cases.teams.msg.PageData;
import self.cases.teams.entity.ApplyLogs;
import self.cases.teams.service.ApplyLogsService;
import org.slf4j.LoggerFactory; // 导入日志工具类
import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.*; // RESTful 注解支持
import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理注解
import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据注解
import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.handle.CacheHandle; // 缓存处理类
import self.cases.teams.service.UsersService; // 用户服务接口
import self.cases.teams.utils.DateUtils; // 日期工具类
import self.cases.teams.utils.IDUtils; // ID 工具类
import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.entity.ApplyLogs; // 申请记录实体类
import self.cases.teams.service.ApplyLogsService; // 申请记录服务接口
/**
*
*
*/
@Controller
@RequestMapping("/applyLogs")
public class ApplyLogsController extends BaseController {
@RequestMapping("/applyLogs") // 设置默认请求路径
public class ApplyLogsController extends BaseController { // 继承基础控制器
protected static final Logger Log = LoggerFactory.getLogger(ApplyLogsController.class);
protected static final Logger Log = LoggerFactory.getLogger(ApplyLogsController.class); // 日志实例
@Autowired
@Autowired // 自动注入缓存处理类
private CacheHandle cacheHandle;
@Autowired
@Autowired // 自动注入用户服务
private UsersService usersService;
@Autowired
@Autowired // 自动注入申请记录服务
private ApplyLogsService applyLogsService;
@RequestMapping("")
@RequestMapping("") // 默认请求映射
public String index() {
return "pages/ApplyLogs";
return "pages/ApplyLogs"; // 返回视图页面名称
}
@GetMapping("/info")
@ResponseBody
@GetMapping("/info") // GET 请求获取单条记录
@ResponseBody // 返回 JSON 数据
public R getInfo(String id) {
Log.info("查找指定申请记录ID{}", id);
Log.info("查找指定申请记录ID{}", id); // 记录日志
ApplyLogs applyLogs = applyLogsService.getOne(id);
ApplyLogs applyLogs = applyLogsService.getOne(id); // 查询单条记录
return R.successData(applyLogs);
return R.successData(applyLogs); // 返回成功数据
}
@GetMapping("/page")
@ResponseBody
@GetMapping("/page") // GET 请求分页查询
@ResponseBody // 返回 JSON 数据
public R getPageInfos(Long pageIndex, Long pageSize,
String token, String teamName, String userName) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 获取当前用户
if (user.getType() == 0) {
if (user.getType() == 0) { // 普通用户权限
Log.info("分页查看全部申请记录,当前页码:{}"
+ "每页数据量:{}, 模糊查询,团队名称:{},用户姓名:{}", pageIndex,
pageSize, teamName, userName);
Log.info("分页查看全部申请记录,当前页码:{},每页数据量:{}, 模糊查询,团队名称:{},用户姓名:{}",
pageIndex, pageSize, teamName, userName);
PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, null, teamName, userName);
PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, null, teamName, userName); // 查询分页数据
return R.successData(page);
return R.successData(page); // 返回成功数据
} else if (user.getType() == 1) {
} else if (user.getType() == 1) { // 团队管理员权限
Log.info("团队管理员查看申请记录,当前页码:{}"
+ "每页数据量:{}, 模糊查询,团队名称:{},用户姓名:{}", pageIndex,
pageSize, teamName, userName);
Log.info("团队管理员查看申请记录,当前页码:{},每页数据量:{}, 模糊查询,团队名称:{},用户姓名:{}",
pageIndex, pageSize, teamName, userName);
PageData page = applyLogsService.getManPageInfo(pageIndex, pageSize, user.getId(), teamName, userName);
PageData page = applyLogsService.getManPageInfo(pageIndex, pageSize, user.getId(), teamName, userName); // 查询团队管理员分页数据
return R.successData(page);
return R.successData(page); // 返回成功数据
} else {
} else { // 其他权限
Log.info("分页用户相关申请记录,当前页码:{}"
+ "每页数据量:{}, 模糊查询,团队名称:{},用户姓名:{}", pageIndex,
pageSize, teamName, userName);
Log.info("分页用户相关申请记录,当前页码:{},每页数据量:{}, 模糊查询,团队名称:{},用户姓名:{}",
pageIndex, pageSize, teamName, userName);
PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, user.getId(), teamName, null);
PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, user.getId(), teamName, null); // 查询用户相关分页数据
return R.successData(page);
return R.successData(page); // 返回成功数据
}
}
@PostMapping("/add")
@ResponseBody
@PostMapping("/add") // POST 请求新增记录
@ResponseBody // 返回 JSON 数据
public R addInfo(String token, ApplyLogs applyLogs) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 获取当前用户
if (applyLogsService.isApply(user.getId(), applyLogs.getTeamId())) { // 判断是否已申请
if(applyLogsService.isApply(user.getId(), applyLogs.getTeamId())){
applyLogs.setId(IDUtils.makeIDByCurrent()); // 生成唯一 ID
applyLogs.setUserId(user.getId()); // 设置用户 ID
applyLogs.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
applyLogs.setId(IDUtils.makeIDByCurrent());
applyLogs.setUserId(user.getId());
applyLogs.setCreateTime(DateUtils.getNowDate());
Log.info("添加申请记录,传入参数:{}", applyLogs); // 记录日志
Log.info("添加申请记录,传入参数:{}", applyLogs);
applyLogsService.add(applyLogs); // 添加记录
applyLogsService.add(applyLogs);
return R.success(); // 返回成功响应
return R.success();
}else{
} else {
return R.warn("申请审核中,请耐心等待");
return R.warn("申请审核中,请耐心等待"); // 返回警告响应
}
}
@PostMapping("/upd")
@ResponseBody
@PostMapping("/upd") // POST 请求更新记录
@ResponseBody // 返回 JSON 数据
public R updInfo(ApplyLogs applyLogs) {
Log.info("修改申请记录,传入参数:{}", applyLogs);
Log.info("修改申请记录,传入参数:{}", applyLogs); // 记录日志
applyLogsService.update(applyLogs);
applyLogsService.update(applyLogs); // 更新记录
return R.success();
return R.success(); // 返回成功响应
}
@PostMapping("/del")
@ResponseBody
@PostMapping("/del") // POST 请求删除记录
@ResponseBody // 返回 JSON 数据
public R delInfo(String id) {
Log.info("删除申请记录, ID:{}", id);
Log.info("删除申请记录, ID:{}", id); // 记录日志
ApplyLogs applyLogs = applyLogsService.getOne(id);
ApplyLogs applyLogs = applyLogsService.getOne(id); // 查询待删除记录
applyLogsService.delete(applyLogs);
applyLogsService.delete(applyLogs); // 删除记录
return R.success();
return R.success(); // 返回成功响应
}
}
}

@ -1,10 +1,10 @@
package self.cases.teams.controller;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import self.cases.teams.msg.R;
import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理注解
import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据注解
import self.cases.teams.msg.R; // 响应封装类
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSession; // Servlet HTTP 会话
/**
*
@ -12,16 +12,16 @@ import javax.servlet.http.HttpSession;
*/
public abstract class BaseController {
protected static final String SESSION_USER = "user";
protected static final String SESSION_USER = "user"; // 定义会话中存储用户信息的键值
/**
*
* @param session
* @return
* @return
*/
protected Object getSessionUser(HttpSession session) {
return session.getAttribute(SESSION_USER);
return session.getAttribute(SESSION_USER); // 从会话中获取用户信息
}
/**
@ -31,15 +31,20 @@ public abstract class BaseController {
*/
protected void setSessionUser(HttpSession session, Object user) {
session.setAttribute(SESSION_USER, user);
session.setAttribute(SESSION_USER, user); // 将用户信息存入会话
}
@ExceptionHandler(Exception.class)
@ResponseBody
/**
*
* @param e
* @return
*/
@ExceptionHandler(Exception.class) // 捕获所有类型的异常
@ResponseBody // 返回 JSON 数据
public R exception(Exception e) {
e.printStackTrace();
e.printStackTrace(); // 打印异常堆栈信息
return R.error();
return R.error(); // 返回错误响应
}
}

@ -1,148 +1,171 @@
package self.cases.teams.controller;
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.*;
import self.cases.teams.entity.Notices;
import self.cases.teams.handle.CacheHandle;
import self.cases.teams.msg.R;
import self.cases.teams.entity.Users;
import self.cases.teams.service.NoticesService;
import self.cases.teams.service.UsersService;
import self.cases.teams.utils.IDUtils;
import javax.servlet.http.HttpSession;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger; // 日志工具类
import org.slf4j.LoggerFactory; // 日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.*; // 注解支持 RESTful API
import self.cases.teams.entity.Notices; // 公告实体类
import self.cases.teams.handle.CacheHandle; // 缓存处理类
import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.service.NoticesService; // 公告服务接口
import self.cases.teams.service.UsersService; // 用户服务接口
import self.cases.teams.utils.IDUtils; // ID 工具类
import javax.servlet.http.HttpSession; // Servlet HTTP 会话
import java.util.List; // Java 集合类
import java.util.Map; // Java Map 集合
@Controller
@RequestMapping("/")
@RequestMapping("/") // 基础路径映射
public class IndexController extends BaseController {
private static final Logger Log = LoggerFactory.getLogger(IndexController.class);
private static final Logger Log = LoggerFactory.getLogger(IndexController.class); // 初始化日志记录器
@Autowired
@Autowired // 自动注入用户服务接口
private UsersService usersService;
@Autowired
@Autowired // 自动注入缓存处理类
private CacheHandle cacheHandle;
@Autowired
@Autowired // 自动注入公告服务接口
private NoticesService noticesService;
/**
*
*/
@GetMapping("/sys/notices")
@ResponseBody
public R getNoticeList(String token){
@ResponseBody // 返回 JSON 数据
public R getNoticeList(String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 从缓存中获取用户信息
if (user.getType() == 0) { // 如果用户类型为普通用户
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
List<Notices> list = noticesService.getSysNotices(); // 获取系统公告列表
if(user.getType() == 0){
return R.successData(list); // 返回系统公告数据
List<Notices> list = noticesService.getSysNotices();
} else if (user.getType() == 1) { // 如果用户类型为管理员
return R.successData(list);
}else if(user.getType() == 1){
List<Notices> list = noticesService.getManNotices(user.getId()); // 获取管理员相关的公告列表
List<Notices> list = noticesService.getManNotices(user.getId());
return R.successData(list); // 返回管理员公告数据
return R.successData(list);
}else{
} else { // 如果用户类型为会员
List<Notices> list = noticesService.getMemNotices(user.getId());
List<Notices> list = noticesService.getMemNotices(user.getId()); // 获取会员相关的公告列表
return R.successData(list);
return R.successData(list); // 返回会员公告数据
}
}
//用户登录
/**
*
*/
@PostMapping("/login")
@ResponseBody
public R login(String userName, String passWord, HttpSession session){
public R login(String userName, String passWord, HttpSession session) {
Log.info("用户登录,用户名:{} 用户密码:{}", userName, passWord);
Log.info("用户登录,用户名:{} 用户密码:{}", userName, passWord); // 记录日志
Users user = usersService.getUserByUserName(userName);
Users user = usersService.getUserByUserName(userName); // 根据用户名获取用户信息
if(user == null) {
if (user == null) { // 如果用户不存在
return R.error("输入的用户名不存在");
}else {
return R.error("输入的用户名不存在"); // 返回错误信息
if(passWord.equals(user.getPassWord().trim())) {
} else { // 如果用户存在
if (passWord.equals(user.getPassWord().trim())) { // 如果密码匹配
String token = IDUtils.makeIDByUUID();
cacheHandle.addUserCache(token, user.getId());
String token = IDUtils.makeIDByUUID(); // 生成登录令牌
cacheHandle.addUserCache(token, user.getId()); // 将用户信息存入缓存
return R.success("登录成功", token);
}else {
return R.success("登录成功", token); // 返回登录成功信息和令牌
return R.error("输入的密码错误");
} else { // 如果密码不匹配
return R.error("输入的密码错误"); // 返回密码错误信息
}
}
}
/**
* 退
*/
@RequestMapping("/exit")
@ResponseBody
public R exit(String token) {
Log.info("用户退出系统并移除登录信息");
Log.info("用户退出系统并移除登录信息"); // 记录日志
cacheHandle.removeUserCache(token);
cacheHandle.removeUserCache(token); // 移除用户的缓存信息
return R.success();
return R.success(); // 返回成功响应
}
/**
*
*/
@GetMapping("/info")
@ResponseBody
public R info(String token){
public R info(String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 从缓存中获取用户信息
return R.successData(user);
return R.successData(user); // 返回用户信息
}
/**
*
*/
@PostMapping("/info")
@ResponseBody
public R info(Users user){
public R info(Users user) {
Log.info("修改用户信息,{}", user);
Log.info("修改用户信息,{}", user); // 记录日志
usersService.update(user);
usersService.update(user); // 调用服务层更新用户信息
return R.success();
return R.success(); // 返回成功响应
}
/**
*
*/
@RequestMapping("/checkPwd")
@ResponseBody
public R checkPwd(String oldPwd, String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 从缓存中获取用户信息
if (oldPwd.equals(user.getPassWord())) { // 如果旧密码匹配
if(oldPwd.equals(user.getPassWord())) {
return R.success(); // 返回成功响应
return R.success();
}else {
} else { // 如果旧密码不匹配
return R.warn("原始密码和输入密码不一致");
return R.warn("原始密码和输入密码不一致"); // 返回警告信息
}
}
//用户密码修改
/**
*
*/
@PostMapping("/pwd")
@ResponseBody
public R pwd(String token, String password) {
Log.info("修改用户密码,{}", password);
Log.info("修改用户密码,{}", password); // 记录日志
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 从缓存中获取用户信息
user.setPassWord(password);
usersService.update(user);
user.setPassWord(password); // 设置新密码
usersService.update(user); // 调用服务层更新用户密码
return R.success();
return R.success(); // 返回成功响应
}
}
}

@ -1,124 +1,143 @@
package self.cases.teams.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.GetMapping; // HTTP GET 请求映射
import org.springframework.web.bind.annotation.PostMapping; // HTTP POST 请求映射
import org.springframework.web.bind.annotation.RequestMapping; // 请求路径映射
import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理器
import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据
import self.cases.teams.utils.DateUtils;
import self.cases.teams.utils.IDUtils;
import self.cases.teams.msg.R;
import self.cases.teams.msg.PageData;
import self.cases.teams.utils.DateUtils; // 自定义日期工具类
import self.cases.teams.utils.IDUtils; // 自定义 ID 工具类
import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.entity.TeamTypes;
import self.cases.teams.service.TeamTypesService;
import self.cases.teams.entity.TeamTypes; // 社团类型实体类
import self.cases.teams.service.TeamTypesService; // 社团类型服务接口
import java.util.List;
import java.util.List; // Java 集合类
/**
*
*
*
*/
@Controller
@RequestMapping("/teamTypes")
@RequestMapping("/teamTypes") // 基础路径映射
public class TeamTypesController extends BaseController {
// 日志记录器
protected static final Logger Log = LoggerFactory.getLogger(TeamTypesController.class);
@Autowired
@Autowired // 自动注入 TeamTypesService
private TeamTypesService teamTypesService;
/**
*
*/
@RequestMapping("")
public String index() {
return "pages/TeamTypes";
return "pages/TeamTypes"; // 返回对应的视图页面
}
/**
*
*/
@GetMapping("/all")
@ResponseBody
public R getAll(){
@ResponseBody // 返回 JSON 数据
public R getAll() {
Log.info("查看全部的社团类型信息");
Log.info("查看全部的社团类型信息"); // 记录日志
List<TeamTypes> list = teamTypesService.getAll();
List<TeamTypes> list = teamTypesService.getAll(); // 调用服务层获取所有社团类型
return R.successData(list);
return R.successData(list); // 返回成功数据
}
/**
* ID
*/
@GetMapping("/info")
@ResponseBody
public R getInfo(String id) {
Log.info("查找指定社团类型ID{}", id);
Log.info("查找指定社团类型ID{}", id); // 记录日志
TeamTypes teamTypes = teamTypesService.getOne(id);
TeamTypes teamTypes = teamTypesService.getOne(id); // 调用服务层获取指定社团类型
return R.successData(teamTypes);
return R.successData(teamTypes); // 返回成功数据
}
//社团类型管理
/**
*
*/
@GetMapping("/page")
@ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize,
TeamTypes teamTypes) {
public R getPageInfos(Long pageIndex, Long pageSize, TeamTypes teamTypes) {
Log.info("分页查找社团类型,当前页码:{}"
+ "每页数据量:{}, 模糊查询,附加参数:{}", pageIndex,
pageSize, teamTypes);
Log.info("分页查找社团类型,当前页码:{},每页数据量:{}, 模糊查询,附加参数:{}",
pageIndex, pageSize, teamTypes); // 记录日志
PageData page = teamTypesService.getPageInfo(pageIndex, pageSize, teamTypes);
PageData page = teamTypesService.getPageInfo(pageIndex, pageSize, teamTypes); // 调用服务层分页查询
return R.successData(page);
return R.successData(page); // 返回分页数据
}
/**
*
*/
@PostMapping("/add")
@ResponseBody
public R addInfo(TeamTypes teamTypes) {
teamTypes.setId(IDUtils.makeIDByCurrent());
teamTypes.setCreateTime(DateUtils.getNowDate());
teamTypes.setId(IDUtils.makeIDByCurrent()); // 生成社团类型 ID
teamTypes.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
Log.info("添加社团类型,传入参数:{}", teamTypes);
Log.info("添加社团类型,传入参数:{}", teamTypes); // 记录日志
teamTypesService.add(teamTypes);
teamTypesService.add(teamTypes); // 调用服务层添加社团类型
return R.success();
return R.success(); // 返回成功响应
}
/**
*
*/
@PostMapping("/upd")
@ResponseBody
public R updInfo(TeamTypes teamTypes) {
Log.info("修改社团类型,传入参数:{}", teamTypes);
Log.info("修改社团类型,传入参数:{}", teamTypes); // 记录日志
teamTypesService.update(teamTypes);
teamTypesService.update(teamTypes); // 调用服务层修改社团类型
return R.success();
return R.success(); // 返回成功响应
}
/**
*
*/
@PostMapping("/del")
@ResponseBody
public R delInfo(String id) {
if(teamTypesService.isRemove(id)){
// 检查是否存在关联社团
if(teamTypesService.isRemove(id)) {
Log.info("删除社团类型, ID:{}", id);
Log.info("删除社团类型, ID:{}", id); // 记录日志
TeamTypes teamTypes = teamTypesService.getOne(id);
TeamTypes teamTypes = teamTypesService.getOne(id); // 获取社团类型信息
teamTypesService.delete(teamTypes);
teamTypesService.delete(teamTypes); // 调用服务层删除社团类型
return R.success();
}else{
return R.success(); // 返回成功响应
} else {
return R.warn("存在关联社团,无法移除");
return R.warn("存在关联社团,无法移除"); // 返回警告响应
}
}
}
}

@ -1,143 +1,167 @@
package self.cases.teams.controller;
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;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import self.cases.teams.entity.Users;
import self.cases.teams.handle.CacheHandle;
import self.cases.teams.service.UsersService;
import self.cases.teams.utils.DateUtils;
import self.cases.teams.utils.IDUtils;
import self.cases.teams.msg.R;
import self.cases.teams.msg.PageData;
import self.cases.teams.entity.Teams;
import self.cases.teams.service.TeamsService;
import java.util.List;
import org.slf4j.Logger; // 日志工具类
import org.slf4j.LoggerFactory; // 日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.GetMapping; // HTTP GET 请求映射
import org.springframework.web.bind.annotation.PostMapping; // HTTP POST 请求映射
import org.springframework.web.bind.annotation.RequestMapping; // 请求路径映射
import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理器
import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据
import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.handle.CacheHandle; // 缓存处理类
import self.cases.teams.service.UsersService; // 用户服务接口
import self.cases.teams.utils.DateUtils; // 自定义日期工具类
import self.cases.teams.utils.IDUtils; // 自定义 ID 工具类
import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.entity.Teams; // 社团实体类
import self.cases.teams.service.TeamsService; // 社团服务接口
import java.util.List; // Java 集合类
/**
*
*
*
*/
@Controller
@RequestMapping("/teams")
@RequestMapping("/teams") // 基础路径映射
public class TeamsController extends BaseController {
// 日志记录器
protected static final Logger Log = LoggerFactory.getLogger(TeamsController.class);
@Autowired
@Autowired // 自动注入缓存处理类
private CacheHandle cacheHandle;
@Autowired
@Autowired // 自动注入用户服务接口
private UsersService usersService;
@Autowired
@Autowired // 自动注入社团服务接口
private TeamsService teamsService;
/**
*
*/
@RequestMapping("")
public String index() {
return "pages/Teams";
return "pages/Teams"; // 返回对应的视图页面
}
/**
* ID
*/
@GetMapping("/info")
@ResponseBody
@ResponseBody // 返回 JSON 数据
public R getInfo(String id) {
Log.info("查找指定社团信息ID{}", id);
Log.info("查找指定社团信息ID{}", id); // 记录日志
Teams teams = teamsService.getOne(id);
Teams teams = teamsService.getOne(id); // 调用服务层获取指定社团信息
return R.successData(teams);
return R.successData(teams); // 返回成功数据
}
/**
*
*/
@GetMapping("/all")
@ResponseBody
public R getAll(){
public R getAll() {
Log.info("获取全部的社团");
Log.info("获取全部的社团"); // 记录日志
List<Teams> list = teamsService.getAll();
List<Teams> list = teamsService.getAll(); // 调用服务层获取所有社团信息
return R.successData(list);
return R.successData(list); // 返回成功数据
}
/**
*
*/
@GetMapping("/man")
@ResponseBody
public R getListByManId(String manId){
public R getListByManId(String manId) {
Log.info("获取指定社团管理员相关的社团列表");
Log.info("获取指定社团管理员相关的社团列表"); // 记录日志
List<Teams> list = teamsService.getListByManId(manId);
List<Teams> list = teamsService.getListByManId(manId); // 调用服务层获取指定管理员相关的社团列表
return R.successData(list);
return R.successData(list); // 返回成功数据
}
/**
*
*/
@GetMapping("/page")
@ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize,
String token, Teams teams) {
public R getPageInfos(Long pageIndex, Long pageSize, String token, Teams teams) {
// 从缓存中获取用户信息
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
if(user.getType() == 1){
// 如果用户类型为管理员,则设置社团管理员为当前用户
if (user.getType() == 1) {
teams.setManager(user.getId());
}
Log.info("分页查找社团信息,当前页码:{}"
+ "每页数据量:{}, 模糊查询,附加参数:{}", pageIndex,
pageSize, teams);
Log.info("分页查找社团信息,当前页码:{},每页数据量:{}, 模糊查询,附加参数:{}",
pageIndex, pageSize, teams); // 记录日志
PageData page = teamsService.getPageInfo(pageIndex, pageSize, teams);
PageData page = teamsService.getPageInfo(pageIndex, pageSize, teams); // 调用服务层分页查询
return R.successData(page);
return R.successData(page); // 返回分页数据
}
/**
*
*/
@PostMapping("/add")
@ResponseBody
public R addInfo(Teams teams) {
teams.setId(IDUtils.makeIDByCurrent());
teams.setCreateTime(DateUtils.getNowDate("yyyy-MM-dd"));
teams.setId(IDUtils.makeIDByCurrent()); // 生成社团 ID
teams.setCreateTime(DateUtils.getNowDate("yyyy-MM-dd")); // 设置创建时间
Log.info("添加社团信息,传入参数:{}", teams);
Log.info("添加社团信息,传入参数:{}", teams); // 记录日志
teamsService.add(teams);
teamsService.add(teams); // 调用服务层添加社团信息
return R.success();
return R.success(); // 返回成功响应
}
/**
*
*/
@PostMapping("/upd")
@ResponseBody
public R updInfo(Teams teams) {
Log.info("修改社团信息,传入参数:{}", teams);
Log.info("修改社团信息,传入参数:{}", teams); // 记录日志
teamsService.update(teams);
teamsService.update(teams); // 调用服务层修改社团信息
return R.success();
return R.success(); // 返回成功响应
}
/**
*
*/
@PostMapping("/del")
@ResponseBody
public R delInfo(String id) {
Log.info("删除社团信息, ID:{}", id);
Log.info("删除社团信息, ID:{}", id); // 记录日志
Teams teams = teamsService.getOne(id);
Teams teams = teamsService.getOne(id); // 获取社团信息
teamsService.delete(teams);
teamsService.delete(teams); // 调用服务层删除社团信息
return R.success();
return R.success(); // 返回成功响应
}
}
}

@ -1,117 +1,134 @@
package self.cases.teams.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.GetMapping; // HTTP GET 请求映射
import org.springframework.web.bind.annotation.PostMapping; // HTTP POST 请求映射
import org.springframework.web.bind.annotation.RequestMapping; // 请求路径映射
import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理器
import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据
import self.cases.teams.utils.DateUtils;
import self.cases.teams.utils.IDUtils;
import self.cases.teams.msg.R;
import self.cases.teams.msg.PageData;
import self.cases.teams.utils.DateUtils; // 自定义日期工具类
import self.cases.teams.utils.IDUtils; // 自定义 ID 工具类
import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.entity.Users;
import self.cases.teams.service.UsersService;
import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.service.UsersService; // 用户服务接口
/**
*
*
*
*/
@Controller
@RequestMapping("/users")
@RequestMapping("/users") // 基础路径映射
public class UsersController extends BaseController {
// 日志记录器
protected static final Logger Log = LoggerFactory.getLogger(UsersController.class);
@Autowired
@Autowired // 自动注入 UsersService
private UsersService usersService;
/**
*
*/
@RequestMapping("")
public String index() {
return "pages/Users";
return "pages/Users"; // 返回对应的视图页面
}
/**
* ID
*/
@GetMapping("/info")
@ResponseBody
@ResponseBody // 返回 JSON 数据
public R getInfo(String id) {
Log.info("查找指定系统用户ID{}", id);
Log.info("查找指定系统用户ID{}", id); // 记录日志
Users users = usersService.getOne(id);
Users users = usersService.getOne(id); // 调用服务层获取用户信息
return R.successData(users);
return R.successData(users); // 返回成功数据
}
/**
*
*/
@GetMapping("/page")
@ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize,
Users users) {
public R getPageInfos(Long pageIndex, Long pageSize, Users users) {
Log.info("分页查找系统用户,当前页码:{}"
+ "每页数据量:{}, 模糊查询,附加参数:{}", pageIndex,
pageSize, users);
Log.info("分页查找系统用户,当前页码:{},每页数据量:{}, 模糊查询,附加参数:{}",
pageIndex, pageSize, users); // 记录日志
PageData page = usersService.getPageInfo(pageIndex, pageSize, users);
PageData page = usersService.getPageInfo(pageIndex, pageSize, users); // 调用服务层分页查询
return R.successData(page);
return R.successData(page); // 返回分页数据
}
//注册用户
/**
*
*/
@PostMapping("/add")
@ResponseBody
public R addInfo(Users users) {
// 检查用户名是否已存在
if(usersService.getUserByUserName(users.getUserName()) == null){
users.setId(IDUtils.makeIDByCurrent());
users.setCreateTime(DateUtils.getNowDate());
users.setId(IDUtils.makeIDByCurrent()); // 生成用户 ID
users.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
Log.info("添加系统用户,传入参数:{}", users);
Log.info("添加系统用户,传入参数:{}", users); // 记录日志
usersService.add(users);
usersService.add(users); // 调用服务层添加用户
return R.success();
}else{
return R.success(); // 返回成功响应
} else {
return R.warn("用户账号已存在,请重新输入");
return R.warn("用户账号已存在,请重新输入"); // 返回警告响应
}
}
//修改系统用户
/**
*
*/
@PostMapping("/upd")
@ResponseBody
public R updInfo(Users users) {
Log.info("修改系统用户,传入参数:{}", users);
Log.info("修改系统用户,传入参数:{}", users); // 记录日志
usersService.update(users);
usersService.update(users); // 调用服务层更新用户信息
return R.success();
return R.success(); // 返回成功响应
}
/**
*
*/
@PostMapping("/del")
@ResponseBody
public R delInfo(String id) {
// 检查用户是否可以被删除
if(usersService.isRemove(id)){
Log.info("删除系统用户, ID:{}", id);
Users users = usersService.getOne(id);
Log.info("删除系统用户, ID:{}", id); // 记录日志
Users users = usersService.getOne(id); // 获取用户信息
usersService.delete(users);
usersService.delete(users); // 调用服务层删除用户
return R.success();
}else{
return R.success(); // 返回成功响应
} else {
return R.warn("用户存在关联社团,无法移除");
return R.warn("用户存在关联社团,无法移除"); // 返回警告响应
}
}
}
}

@ -1,97 +1,91 @@
package self.cases.teams.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 主键注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 表注解
import java.io.Serializable;
import java.io.Serializable; // 引入序列化接口
/**
*
*
*/
@TableName(value = "active_logs")
public class ActiveLogs implements Serializable {
@TableName(value = "active_logs") // 设置对应的数据库表名
public class ActiveLogs implements Serializable { // 实现 Serializable 接口以便序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 设置主键字段名
private String id; // 主键字段
/**
/**
*
*/
@TableField(value = "create_time")
private String createTime;
@TableField(value = "create_time") // 设置字段名
private String createTime; // 报名时间字段
/**
/**
*
*/
@TableField(value = "active_id")
private String activeId;
@TableField(value = "active_id") // 设置字段名
private String activeId; // 活动编号字段
/**
/**
*
*/
@TableField(value = "user_id")
private String userId;
@TableField(value = "user_id") // 设置字段名
private String userId; // 用户 ID 字段
// Getter 方法,用于获取 id
public String getId(){
return id;
}
// Setter 方法,用于设置 id
public void setId(String id){
this.id = id;
}
// Getter 方法,用于获取 createTime
public String getCreateTime(){
return createTime;
}
// Setter 方法,用于设置 createTime
public void setCreateTime(String createTime){
this.createTime = createTime;
}
// Getter 方法,用于获取 activeId
public String getActiveId(){
return activeId;
}
// Setter 方法,用于设置 activeId
public void setActiveId(String activeId){
this.activeId = activeId;
}
// Getter 方法,用于获取 userId
public String getUserId(){
return userId;
}
// Setter 方法,用于设置 userId
public void setUserId(String userId){
this.userId = userId;
}
// 重写 toString 方法,便于打印对象信息
@Override
public String toString() {
return "ActiveLogs [id=" + id
return "ActiveLogs [id=" + id
+ ", createTime=" + createTime
+ ", activeId=" + activeId
+ ", userId=" + userId
+ "]";
+ "]"; // 返回对象属性的字符串表示
}
}
}

@ -1,161 +1,152 @@
package self.cases.teams.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 主键注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 表注解
import java.io.Serializable;
import java.io.Serializable; // 引入序列化接口
/**
*
*
*/
@TableName(value = "activities")
public class Activities implements Serializable {
@TableName(value = "activities") // 设置对应的数据库表名
public class Activities implements Serializable { // 实现 Serializable 接口以便序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 设置主键字段名
private String id; // 主键字段
/**
/**
*
*/
@TableField(value = "name")
private String name;
@TableField(value = "name") // 设置字段名
private String name; // 活动名称字段
/**
/**
*
*/
@TableField(value = "comm")
private String comm;
@TableField(value = "comm") // 设置字段名
private String comm; // 活动概述字段
/**
/**
*
*/
@TableField(value = "detail")
private String detail;
@TableField(value = "detail") // 设置字段名
private String detail; // 活动详情字段
/**
/**
*
*/
@TableField(value = "ask")
private String ask;
@TableField(value = "ask") // 设置字段名
private String ask; // 活动要求字段
/**
/**
*
*/
@TableField(value = "total")
private Integer total;
@TableField(value = "total") // 设置字段名
private Integer total; // 报名人数字段
/**
/**
*
*/
@TableField(value = "active_time")
private String activeTime;
@TableField(value = "active_time") // 设置字段名
private String activeTime; // 活动时间字段
/**
/**
*
*/
@TableField(value = "team_id")
private String teamId;
@TableField(value = "team_id") // 设置字段名
private String teamId; // 社团 ID 字段
// Getter 方法,用于获取 id
public String getId(){
return id;
}
// Setter 方法,用于设置 id
public void setId(String id){
this.id = id;
}
// Getter 方法,用于获取 name
public String getName(){
return name;
}
// Setter 方法,用于设置 name
public void setName(String name){
this.name = name;
}
// Getter 方法,用于获取 comm
public String getComm(){
return comm;
}
// Setter 方法,用于设置 comm
public void setComm(String comm){
this.comm = comm;
}
// Getter 方法,用于获取 detail
public String getDetail(){
return detail;
}
// Setter 方法,用于设置 detail
public void setDetail(String detail){
this.detail = detail;
}
// Getter 方法,用于获取 ask
public String getAsk(){
return ask;
}
// Setter 方法,用于设置 ask
public void setAsk(String ask){
this.ask = ask;
}
// Getter 方法,用于获取 total
public Integer getTotal(){
return total;
}
// Setter 方法,用于设置 total
public void setTotal(Integer total){
this.total = total;
}
// Getter 方法,用于获取 activeTime
public String getActiveTime(){
return activeTime;
}
// Setter 方法,用于设置 activeTime
public void setActiveTime(String activeTime){
this.activeTime = activeTime;
}
// Getter 方法,用于获取 teamId
public String getTeamId(){
return teamId;
}
// Setter 方法,用于设置 teamId
public void setTeamId(String teamId){
this.teamId = teamId;
}
// 重写 toString 方法,便于打印对象信息
@Override
public String toString() {
return "Activities [id=" + id
return "Activities [id=" + id
+ ", name=" + name
+ ", comm=" + comm
+ ", detail=" + detail
@ -163,7 +154,6 @@ public class Activities implements Serializable {
+ ", total=" + total
+ ", activeTime=" + activeTime
+ ", teamId=" + teamId
+ "]";
+ "]"; // 返回对象属性的字符串表示
}
}
}

@ -1,115 +1,108 @@
package self.cases.teams.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 主键注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 表注解
import java.io.Serializable;
import java.io.Serializable; // 引入序列化接口
/**
*
*
*/
@TableName(value = "apply_logs")
public class ApplyLogs implements Serializable {
@TableName(value = "apply_logs") // 设置对应的数据库表名
public class ApplyLogs implements Serializable { // 实现 Serializable 接口以便序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 设置主键字段名
private String id; // 主键字段
/**
/**
*
*/
@TableField(value = "status")
private Integer status;
@TableField(value = "status") // 设置字段名
private Integer status; // 状态字段(整数类型)
/**
/**
*
*/
@TableField(value = "create_time")
private String createTime;
@TableField(value = "create_time") // 设置字段名
private String createTime; // 申请时间字段
/**
/**
*
*/
@TableField(value = "team_id")
private String teamId;
@TableField(value = "team_id") // 设置字段名
private String teamId; // 社团 ID 字段
/**
/**
*
*/
@TableField(value = "user_id")
private String userId;
@TableField(value = "user_id") // 设置字段名
private String userId; // 用户 ID 字段
// Getter 方法,用于获取 id
public String getId(){
return id;
}
// Setter 方法,用于设置 id
public void setId(String id){
this.id = id;
}
// Getter 方法,用于获取 status
public Integer getStatus(){
return status;
}
// Setter 方法,用于设置 status
public void setStatus(Integer status){
this.status = status;
}
// Getter 方法,用于获取 createTime
public String getCreateTime(){
return createTime;
}
// Setter 方法,用于设置 createTime
public void setCreateTime(String createTime){
this.createTime = createTime;
}
// Getter 方法,用于获取 teamId
public String getTeamId(){
return teamId;
}
// Setter 方法,用于设置 teamId
public void setTeamId(String teamId){
this.teamId = teamId;
}
// Getter 方法,用于获取 userId
public String getUserId(){
return userId;
}
// Setter 方法,用于设置 userId
public void setUserId(String userId){
this.userId = userId;
}
// 重写 toString 方法,便于打印对象信息
@Override
public String toString() {
return "ApplyLogs [id=" + id
return "ApplyLogs [id=" + id
+ ", status=" + status
+ ", createTime=" + createTime
+ ", teamId=" + teamId
+ ", userId=" + userId
+ "]";
+ "]"; // 返回对象属性的字符串表示
}
}
}

@ -1,135 +1,133 @@
package self.cases.teams.entity;
import java.util.Date;
public class Clubshenqing {
private String id;
private String clubName;
private String activityName;
private String description;
private Date startDate;
private Date endDate;
private String location;
private int maxParticipants;
private String contactPerson;
private String contactEmail;
private String contactPhone;
private boolean approved;
private Date createdAt;
private Date updatedAt;
// Getters and Setters
public String getId() {
package self.cases.teams.entity; // 定义包路径
import java.util.Date; // 导入日期类
public class Clubshenqing { // 定义实体类 Clubshenqing
private String id; // 唯一标识符
private String clubName; // 社团名称
private String activityName; // 活动名称
private String description; // 活动描述
private Date startDate; // 活动开始日期
private Date endDate; // 活动结束日期
private String location; // 活动地点
private int maxParticipants; // 最大参与人数
private String contactPerson; // 联系人姓名
private String contactEmail; // 联系人邮箱
private String contactPhone; // 联系人电话
private boolean approved; // 是否已批准
private Date createdAt; // 创建时间
private Date updatedAt; // 更新时间
// Getter 和 Setter 方法
public String getId() { // 获取 id
return id;
}
public void setId(String id) {
public void setId(String id) { // 设置 id
this.id = id;
}
public String getClubName() {
public String getClubName() { // 获取社团名称
return clubName;
}
public void setClubName(String clubName) {
public void setClubName(String clubName) { // 设置社团名称
this.clubName = clubName;
}
public String getActivityName() {
public String getActivityName() { // 获取活动名称
return activityName;
}
public void setActivityName(String activityName) {
public void setActivityName(String activityName) { // 设置活动名称
this.activityName = activityName;
}
public String getDescription() {
public String getDescription() { // 获取活动描述
return description;
}
public void setDescription(String description) {
public void setDescription(String description) { // 设置活动描述
this.description = description;
}
public Date getStartDate() {
public Date getStartDate() { // 获取活动开始日期
return startDate;
}
public void setStartDate(Date startDate) {
public void setStartDate(Date startDate) { // 设置活动开始日期
this.startDate = startDate;
}
public Date getEndDate() {
public Date getEndDate() { // 获取活动结束日期
return endDate;
}
public void setEndDate(Date endDate) {
public void setEndDate(Date endDate) { // 设置活动结束日期
this.endDate = endDate;
}
public String getLocation() {
public String getLocation() { // 获取活动地点
return location;
}
public void setLocation(String location) {
public void setLocation(String location) { // 设置活动地点
this.location = location;
}
public int getMaxParticipants() {
public int getMaxParticipants() { // 获取最大参与人数
return maxParticipants;
}
public void setMaxParticipants(int maxParticipants) {
public void setMaxParticipants(int maxParticipants) { // 设置最大参与人数
this.maxParticipants = maxParticipants;
}
public String getContactPerson() {
public String getContactPerson() { // 获取联系人姓名
return contactPerson;
}
public void setContactPerson(String contactPerson) {
public void setContactPerson(String contactPerson) { // 设置联系人姓名
this.contactPerson = contactPerson;
}
public String getContactEmail() {
public String getContactEmail() { // 获取联系人邮箱
return contactEmail;
}
public void setContactEmail(String contactEmail) {
public void setContactEmail(String contactEmail) { // 设置联系人邮箱
this.contactEmail = contactEmail;
}
public String getContactPhone() {
public String getContactPhone() { // 获取联系人电话
return contactPhone;
}
public void setContactPhone(String contactPhone) {
public void setContactPhone(String contactPhone) { // 设置联系人电话
this.contactPhone = contactPhone;
}
public boolean isApproved() {
public boolean isApproved() { // 获取是否已批准
return approved;
}
public void setApproved(boolean approved) {
public void setApproved(boolean approved) { // 设置是否已批准
this.approved = approved;
}
public Date getCreatedAt() {
public Date getCreatedAt() { // 获取创建时间
return createdAt;
}
public void setCreatedAt(Date createdAt) {
public void setCreatedAt(Date createdAt) { // 设置创建时间
this.createdAt = createdAt;
}
public Date getUpdatedAt() {
public Date getUpdatedAt() { // 获取更新时间
return updatedAt;
}
public void setUpdatedAt(Date updatedAt) {
public void setUpdatedAt(Date updatedAt) { // 设置更新时间
this.updatedAt = updatedAt;
}
}

@ -1,97 +1,84 @@
package self.cases.teams.entity;
package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的主键注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的表名注解
import java.io.Serializable; // 引入序列化接口
/**
*
*
*/
@TableName(value = "members")
public class Members implements Serializable {
@TableName(value = "members") // 表名映射为 members
public class Members implements Serializable { // 实现 Serializable 接口,支持序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 主键字段映射到数据库中的 id 列
private String id; // 成员的唯一标识符
/**
/**
*
*/
@TableField(value = "create_time")
private String createTime;
@TableField(value = "create_time") // 字段映射到数据库中的 create_time 列
private String createTime; // 成员加入的时间
/**
/**
*
*/
@TableField(value = "team_id")
private String teamId;
@TableField(value = "team_id") // 字段映射到数据库中的 team_id 列
private String teamId; // 成员所属社团的唯一标识符
/**
/**
*
*/
@TableField(value = "user_id")
private String userId;
public String getId(){
@TableField(value = "user_id") // 字段映射到数据库中的 user_id 列
private String userId; // 申请成员的用户唯一标识符
// Getter 和 Setter 方法
public String getId(){ // 获取成员 ID
return id;
}
public void setId(String id){
public void setId(String id){ // 设置成员 ID
this.id = id;
}
public String getCreateTime(){
public String getCreateTime(){ // 获取入团时间
return createTime;
}
public void setCreateTime(String createTime){
public void setCreateTime(String createTime){ // 设置入团时间
this.createTime = createTime;
}
public String getTeamId(){
public String getTeamId(){ // 获取社团 ID
return teamId;
}
public void setTeamId(String teamId){
public void setTeamId(String teamId){ // 设置社团 ID
this.teamId = teamId;
}
public String getUserId(){
public String getUserId(){ // 获取用户 ID
return userId;
}
public void setUserId(String userId){
public void setUserId(String userId){ // 设置用户 ID
this.userId = userId;
}
// 自定义 toString 方法
@Override
public String toString() {
return "Members [id=" + id
return "Members [id=" + id // 返回成员的基本信息
+ ", createTime=" + createTime
+ ", teamId=" + teamId
+ ", userId=" + userId
+ "]";
}
}
}

@ -1,115 +1,99 @@
package self.cases.teams.entity;
package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的主键注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的表名注解
import java.io.Serializable; // 引入序列化接口
/**
*
*
*/
@TableName(value = "notices")
public class Notices implements Serializable {
@TableName(value = "notices") // 表名映射为 notices
public class Notices implements Serializable { // 实现 Serializable 接口,支持序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 主键字段映射到数据库中的 id 列
private String id; // 通知的唯一标识符
/**
/**
*
*/
@TableField(value = "title")
private String title;
@TableField(value = "title") // 字段映射到数据库中的 title 列
private String title; // 通知的标题内容
/**
/**
*
*/
@TableField(value = "detail")
private String detail;
@TableField(value = "detail") // 字段映射到数据库中的 detail 列
private String detail; // 通知的具体内容
/**
/**
*
*/
@TableField(value = "create_time")
private String createTime;
@TableField(value = "create_time") // 字段映射到数据库中的 create_time 列
private String createTime; // 通知发布时间
/**
/**
*
*/
@TableField(value = "team_id")
private String teamId;
public String getId(){
@TableField(value = "team_id") // 字段映射到数据库中的 team_id 列
private String teamId; // 通知所属社团的唯一标识符
// Getter 和 Setter 方法
public String getId(){ // 获取通知 ID
return id;
}
public void setId(String id){
public void setId(String id){ // 设置通知 ID
this.id = id;
}
public String getTitle(){
public String getTitle(){ // 获取通知标题
return title;
}
public void setTitle(String title){
public void setTitle(String title){ // 设置通知标题
this.title = title;
}
public String getDetail(){
public String getDetail(){ // 获取通知详情
return detail;
}
public void setDetail(String detail){
public void setDetail(String detail){ // 设置通知详情
this.detail = detail;
}
public String getCreateTime(){
public String getCreateTime(){ // 获取发布时间
return createTime;
}
public void setCreateTime(String createTime){
public void setCreateTime(String createTime){ // 设置发布时间
this.createTime = createTime;
}
public String getTeamId(){
public String getTeamId(){ // 获取发布社团 ID
return teamId;
}
public void setTeamId(String teamId){
public void setTeamId(String teamId){ // 设置发布社团 ID
this.teamId = teamId;
}
// 自定义 toString 方法
@Override
public String toString() {
return "Notices [id=" + id
return "Notices [id=" + id // 返回通知的基本信息
+ ", title=" + title
+ ", detail=" + detail
+ ", createTime=" + createTime
+ ", teamId=" + teamId
+ "]";
}
}
}

@ -1,115 +1,99 @@
package self.cases.teams.entity;
package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的主键注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的表名注解
import java.io.Serializable; // 引入序列化接口
/**
*
*
*/
@TableName(value = "pay_logs")
public class PayLogs implements Serializable {
@TableName(value = "pay_logs") // 表名映射为 pay_logs
public class PayLogs implements Serializable { // 实现 Serializable 接口,支持序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 主键字段映射到数据库中的 id 列
private String id; // 缴费记录的唯一标识符
/**
/**
*
*/
@TableField(value = "create_time")
private String createTime;
@TableField(value = "create_time") // 字段映射到数据库中的 create_time 列
private String createTime; // 缴费发生的日期时间
/**
/**
*
*/
@TableField(value = "total")
private Double total;
@TableField(value = "total") // 字段映射到数据库中的 total 列
private Double total; // 缴纳的总金额
/**
/**
*
*/
@TableField(value = "team_id")
private String teamId;
@TableField(value = "team_id") // 字段映射到数据库中的 team_id 列
private String teamId; // 缴费对应的社团唯一标识符
/**
/**
*
*/
@TableField(value = "user_id")
private String userId;
public String getId(){
@TableField(value = "user_id") // 字段映射到数据库中的 user_id 列
private String userId; // 缴费用户的唯一标识符
// Getter 和 Setter 方法
public String getId(){ // 获取缴费记录 ID
return id;
}
public void setId(String id){
public void setId(String id){ // 设置缴费记录 ID
this.id = id;
}
public String getCreateTime(){
public String getCreateTime(){ // 获取缴费时间
return createTime;
}
public void setCreateTime(String createTime){
public void setCreateTime(String createTime){ // 设置缴费时间
this.createTime = createTime;
}
public Double getTotal(){
public Double getTotal(){ // 获取缴纳费用
return total;
}
public void setTotal(Double total){
public void setTotal(Double total){ // 设置缴纳费用
this.total = total;
}
public String getTeamId(){
public String getTeamId(){ // 获取收费社团 ID
return teamId;
}
public void setTeamId(String teamId){
public void setTeamId(String teamId){ // 设置收费社团 ID
this.teamId = teamId;
}
public String getUserId(){
public String getUserId(){ // 获取缴费用户 ID
return userId;
}
public void setUserId(String userId){
public void setUserId(String userId){ // 设置缴费用户 ID
this.userId = userId;
}
// 自定义 toString 方法
@Override
public String toString() {
return "PayLogs [id=" + id
return "PayLogs [id=" + id // 返回缴费记录的基本信息
+ ", createTime=" + createTime
+ ", total=" + total
+ ", teamId=" + teamId
+ ", userId=" + userId
+ "]";
}
}
}

@ -1,97 +1,99 @@
package self.cases.teams.entity;
package self.cases.teams.entity;// 定义包路径
import java.util.Date;
// 定义实体类 STjiao表示社团缴费相关信息
public class STjiao {
private String id;
private String clubName;
private String memberName;
private double amount;
private Date paymentDate;
private String paymentMethod;
private String transactionId;
private boolean isPaid;
private Date createdAt;
private Date updatedAt;
// Getters and Setters
public String getId() {
private String id; // 社团缴费记录的唯一标识符
private String clubName; // 社团名称
private String memberName; // 缴费成员姓名
private double amount; // 缴费金额
private Date paymentDate; // 缴费日期
private String paymentMethod; // 缴费方式
private String transactionId; // 交易流水号
private boolean isPaid; // 是否已支付(布尔值)
private Date createdAt; // 记录创建时间
private Date updatedAt; // 记录最后更新时间
// Getter 和 Setter 方法
public String getId() { // 获取缴费记录 ID
return id;
}
public void setId(String id) {
public void setId(String id) { // 设置缴费记录 ID
this.id = id;
}
public String getClubName() {
public String getClubName() { // 获取社团名称
return clubName;
}
public void setClubName(String clubName) {
public void setClubName(String clubName) { // 设置社团名称
this.clubName = clubName;
}
public String getMemberName() {
public String getMemberName() { // 获取成员姓名
return memberName;
}
public void setMemberName(String memberName) {
public void setMemberName(String memberName) { // 设置成员姓名
this.memberName = memberName;
}
public double getAmount() {
public double getAmount() { // 获取缴费金额
return amount;
}
public void setAmount(double amount) {
public void setAmount(double amount) { // 设置缴费金额
this.amount = amount;
}
public Date getPaymentDate() {
public Date getPaymentDate() { // 获取缴费日期
return paymentDate;
}
public void setPaymentDate(Date paymentDate) {
public void setPaymentDate(Date paymentDate) { // 设置缴费日期
this.paymentDate = paymentDate;
}
public String getPaymentMethod() {
public String getPaymentMethod() { // 获取缴费方式
return paymentMethod;
}
public void setPaymentMethod(String paymentMethod) {
public void setPaymentMethod(String paymentMethod) { // 设置缴费方式
this.paymentMethod = paymentMethod;
}
public String getTransactionId() {
public String getTransactionId() { // 获取交易流水号
return transactionId;
}
public void setTransactionId(String transactionId) {
public void setTransactionId(String transactionId) { // 设置交易流水号
this.transactionId = transactionId;
}
public boolean isPaid() {
public boolean isPaid() { // 获取是否已支付状态
return isPaid;
}
public void setPaid(boolean paid) {
public void setPaid(boolean paid) { // 设置是否已支付状态
isPaid = paid;
}
public Date getCreatedAt() {
public Date getCreatedAt() { // 获取记录创建时间
return createdAt;
}
public void setCreatedAt(Date createdAt) {
public void setCreatedAt(Date createdAt) { // 设置记录创建时间
this.createdAt = createdAt;
}
public Date getUpdatedAt() {
public Date getUpdatedAt() { // 获取记录最后更新时间
return updatedAt;
}
public void setUpdatedAt(Date updatedAt) {
public void setUpdatedAt(Date updatedAt) { // 设置记录最后更新时间
this.updatedAt = updatedAt;
}
}

@ -1,79 +1,87 @@
package self.cases.teams.entity;
package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的 TableField 注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的 TableId 注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import java.io.Serializable; // 引入 Serializable 接口,用于序列化
/**
*
*
*/
@TableName(value = "team_types")
public class TeamTypes implements Serializable {
@TableName(value = "team_types") // 指定数据库表名为 "team_types"
public class TeamTypes implements Serializable { // 实现 Serializable 接口,支持序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 表明该字段为主键,对应的数据库字段名为 "id"
private String id; // 社团类型的唯一标识符
/**
/**
*
*/
@TableField(value = "name")
private String name;
@TableField(value = "name") // 对应数据库字段名为 "name"
private String name; // 社团类型的名称
/**
/**
*
*/
@TableField(value = "create_time")
private String createTime;
public String getId(){
@TableField(value = "create_time") // 对应数据库字段名为 "create_time"
private String createTime; // 社团类型的创建时间
return id;
/**
* Getter ID
*/
public String getId() {
return id; // 返回社团类型的记录ID
}
public void setId(String id){
this.id = id;
/**
* Setter ID
*/
public void setId(String id) {
this.id = id; // 设置社团类型的记录ID
}
public String getName(){
return name;
/**
* Getter
*/
public String getName() {
return name; // 返回社团类型的名称
}
public void setName(String name){
this.name = name;
/**
* Setter
*/
public void setName(String name) {
this.name = name; // 设置社团类型的名称
}
public String getCreateTime(){
return createTime;
/**
* Getter
*/
public String getCreateTime() {
return createTime; // 返回社团类型的创建时间
}
public void setCreateTime(String createTime){
this.createTime = createTime;
/**
* Setter
*/
public void setCreateTime(String createTime) {
this.createTime = createTime; // 设置社团类型的创建时间
}
/**
* toString 便
*/
@Override
public String toString() {
return "TeamTypes [id=" + id
+ ", name=" + name
+ ", createTime=" + createTime
+ "]";
return "TeamTypes [id=" + id // 打印社团类型的记录ID
+ ", name=" + name // 打印社团类型的名称
+ ", createTime=" + createTime // 打印创建时间
+ "]"; // 打印结束
}
}
}

@ -1,133 +1,150 @@
package self.cases.teams.entity;
package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的 TableField 注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的 TableId 注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import java.io.Serializable; // 引入 Serializable 接口,用于序列化
/**
*
*
*/
@TableName(value = "teams")
public class Teams implements Serializable {
@TableName(value = "teams") // 指定数据库表名为 "teams"
public class Teams implements Serializable { // 实现 Serializable 接口,支持序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 表明该字段为主键,对应的数据库字段名为 "id"
private String id; // 社团记录的唯一标识符
/**
/**
*
*/
@TableField(value = "name")
private String name;
@TableField(value = "name") // 对应数据库字段名为 "name"
private String name; // 社团的名称
/**
/**
*
*/
@TableField(value = "create_time")
private String createTime;
@TableField(value = "create_time") // 对应数据库字段名为 "create_time"
private String createTime; // 社团的建立时间
/**
/**
*
*/
@TableField(value = "total")
private Integer total;
@TableField(value = "total") // 对应数据库字段名为 "total"
private Integer total; // 社团的总人数
/**
/**
*
*/
@TableField(value = "manager")
private String manager;
@TableField(value = "manager") // 对应数据库字段名为 "manager"
private String manager; // 社团团长的名字
/**
/**
*
*/
@TableField(value = "type_id")
private String typeId;
public String getId(){
@TableField(value = "type_id") // 对应数据库字段名为 "type_id"
private String typeId; // 社团的编号
/**
* Getter ID
*/
public String getId() {
return id;
}
public void setId(String id){
/**
* Setter ID
*/
public void setId(String id) {
this.id = id;
}
public String getName(){
/**
* Getter
*/
public String getName() {
return name;
}
public void setName(String name){
/**
* Setter
*/
public void setName(String name) {
this.name = name;
}
public String getCreateTime(){
/**
* Getter
*/
public String getCreateTime() {
return createTime;
}
public void setCreateTime(String createTime){
/**
* Setter
*/
public void setCreateTime(String createTime) {
this.createTime = createTime;
}
public Integer getTotal(){
/**
* Getter
*/
public Integer getTotal() {
return total;
}
public void setTotal(Integer total){
/**
* Setter
*/
public void setTotal(Integer total) {
this.total = total;
}
public String getManager(){
/**
* Getter
*/
public String getManager() {
return manager;
}
public void setManager(String manager){
/**
* Setter
*/
public void setManager(String manager) {
this.manager = manager;
}
public String getTypeId(){
/**
* Getter
*/
public String getTypeId() {
return typeId;
}
public void setTypeId(String typeId){
/**
* Setter
*/
public void setTypeId(String typeId) {
this.typeId = typeId;
}
/**
* toString 便
*/
@Override
public String toString() {
return "Teams [id=" + id
+ ", name=" + name
+ ", createTime=" + createTime
+ ", total=" + total
+ ", manager=" + manager
+ ", typeId=" + typeId
return "Teams [id=" + id // 打印社团记录ID
+ ", name=" + name // 打印社团名称
+ ", createTime=" + createTime // 打印建立时间
+ ", total=" + total // 打印社团人数
+ ", manager=" + manager // 打印社团团长
+ ", typeId=" + typeId // 打印社团编号
+ "]";
}
}
}

@ -1,223 +1,255 @@
package self.cases.teams.entity;
package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的 TableField 注解
import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的 TableId 注解
import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import java.io.Serializable; // 引入 Serializable 接口,用于序列化
/**
*
*
*/
@TableName(value = "users")
public class Users implements Serializable {
@TableName(value = "users") // 指定数据库表名为 "users"
public class Users implements Serializable { // 实现 Serializable 接口,支持序列化
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
/**
* ID
*/
@TableId(value = "id")
private String id;
@TableId(value = "id") // 表明该字段为主键,对应的数据库字段名为 "id"
private String id; // 用户的唯一标识符
/**
/**
*
*/
@TableField(value = "user_name")
private String userName;
@TableField(value = "user_name") // 对应数据库字段名为 "user_name"
private String userName; // 用户登录时使用的账号
/**
/**
*
*/
@TableField(value = "pass_word")
private String passWord;
@TableField(value = "pass_word") // 对应数据库字段名为 "pass_word"
private String passWord; // 用户的密码(注意:实际应用中应加密存储)
/**
/**
*
*/
@TableField(value = "name")
private String name;
@TableField(value = "name") // 对应数据库字段名为 "name"
private String name; // 用户的真实姓名
/**
/**
*
*/
@TableField(value = "gender")
private String gender;
@TableField(value = "gender") // 对应数据库字段名为 "gender"
private String gender; // 用户的性别,通常为 "男" 或 "女"
/**
/**
*
*/
@TableField(value = "age")
private Integer age;
@TableField(value = "age") // 对应数据库字段名为 "age"
private Integer age; // 用户的年龄
/**
/**
*
*/
@TableField(value = "phone")
private String phone;
@TableField(value = "phone") // 对应数据库字段名为 "phone"
private String phone; // 用户的联系电话
/**
/**
*
*/
@TableField(value = "address")
private String address;
@TableField(value = "address") // 对应数据库字段名为 "address"
private String address; // 用户的联系地址
/**
/**
*
*/
@TableField(value = "status")
private Integer status;
@TableField(value = "status") // 对应数据库字段名为 "status"
private Integer status; // 用户信息的状态,例如启用、禁用等
/**
/**
*
*/
@TableField(value = "create_time")
private String createTime;
@TableField(value = "create_time") // 对应数据库字段名为 "create_time"
private String createTime; // 用户信息的添加时间
/**
/**
*
*/
@TableField(value = "type")
private Integer type;
public String getId(){
@TableField(value = "type") // 对应数据库字段名为 "type"
private Integer type; // 用户的身份类型,例如管理员、普通用户等
return id;
/**
* Getter ID
*/
public String getId() {
return id; // 返回用户的唯一标识符
}
public void setId(String id){
this.id = id;
/**
* Setter ID
*/
public void setId(String id) {
this.id = id; // 设置用户的唯一标识符
}
public String getUserName(){
return userName;
/**
* Getter
*/
public String getUserName() {
return userName; // 返回用户的登录账号
}
public void setUserName(String userName){
this.userName = userName;
/**
* Setter
*/
public void setUserName(String userName) {
this.userName = userName; // 设置用户的登录账号
}
public String getPassWord(){
return passWord;
/**
* Getter
*/
public String getPassWord() {
return passWord; // 返回用户的密码
}
public void setPassWord(String passWord){
this.passWord = passWord;
/**
* Setter
*/
public void setPassWord(String passWord) {
this.passWord = passWord; // 设置用户的密码
}
public String getName(){
return name;
/**
* Getter
*/
public String getName() {
return name; // 返回用户的真实姓名
}
public void setName(String name){
this.name = name;
/**
* Setter
*/
public void setName(String name) {
this.name = name; // 设置用户的真实姓名
}
public String getGender(){
return gender;
/**
* Getter
*/
public String getGender() {
return gender; // 返回用户的性别
}
public void setGender(String gender){
this.gender = gender;
/**
* Setter
*/
public void setGender(String gender) {
this.gender = gender; // 设置用户的性别
}
public Integer getAge(){
return age;
/**
* Getter
*/
public Integer getAge() {
return age; // 返回用户的年龄
}
public void setAge(Integer age){
this.age = age;
/**
* Setter
*/
public void setAge(Integer age) {
this.age = age; // 设置用户的年龄
}
public String getPhone(){
return phone;
/**
* Getter
*/
public String getPhone() {
return phone; // 返回用户的联系电话
}
public void setPhone(String phone){
this.phone = phone;
/**
* Setter
*/
public void setPhone(String phone) {
this.phone = phone; // 设置用户的联系电话
}
public String getAddress(){
return address;
/**
* Getter
*/
public String getAddress() {
return address; // 返回用户的联系地址
}
public void setAddress(String address){
this.address = address;
/**
* Setter
*/
public void setAddress(String address) {
this.address = address; // 设置用户的联系地址
}
public Integer getStatus(){
return status;
/**
* Getter
*/
public Integer getStatus() {
return status; // 返回用户信息的状态
}
public void setStatus(Integer status){
this.status = status;
/**
* Setter
*/
public void setStatus(Integer status) {
this.status = status; // 设置用户信息的状态
}
public String getCreateTime(){
return createTime;
/**
* Getter
*/
public String getCreateTime() {
return createTime; // 返回用户信息的添加时间
}
public void setCreateTime(String createTime){
this.createTime = createTime;
/**
* Setter
*/
public void setCreateTime(String createTime) {
this.createTime = createTime; // 设置用户信息的添加时间
}
public Integer getType(){
return type;
/**
* Getter
*/
public Integer getType() {
return type; // 返回用户的身份类型
}
public void setType(Integer type){
this.type = type;
/**
* Setter
*/
public void setType(Integer type) {
this.type = type; // 设置用户的身份类型
}
/**
* toString 便
*/
@Override
public String toString() {
return "Users [id=" + id
+ ", userName=" + userName
+ ", passWord=" + passWord
+ ", name=" + name
+ ", gender=" + gender
+ ", age=" + age
+ ", phone=" + phone
+ ", address=" + address
+ ", status=" + status
+ ", createTime=" + createTime
+ ", type=" + type
+ "]";
}
}
return "Users [id=" + id // 打印用户的唯一标识符
+ ", userName=" + userName // 打印用户的登录账号
+ ", passWord=" + passWord // 打印用户的密码
+ ", name=" + name // 打印用户的真实姓名
+ ", gender=" + gender // 打印用户的性别
+ ", age=" + age // 打印用户的年龄
+ ", phone=" + phone // 打印用户的联系电话
+ ", address=" + address // 打印用户的联系地址
+ ", status=" + status // 打印用户信息的状态
+ ", createTime=" + createTime // 打印用户信息的添加时间
+ ", type=" + type // 打印用户的身份类型
+ "]"; // 打印结束
}
}

Loading…
Cancel
Save