diff --git a/.mvn/wrapper/MavenWrapperDownloader.java b/.mvn/wrapper/MavenWrapperDownloader.java
index 2281075..4df7bf2 100644
--- a/.mvn/wrapper/MavenWrapperDownloader.java
+++ b/.mvn/wrapper/MavenWrapperDownloader.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012 - 2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -13,91 +13,128 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+// 导入 java.net 包中的类，用于处理网络相关操作
import java.net.*;
+// 导入 java.io 包中的类，用于输入输出操作
import java.io.*;
+// 导入 java.nio.channels 包中的类，用于使用 NIO 通道进行高效的 I/O 操作
import java.nio.channels.*;
+// 导入 java.util.Properties 类，用于处理属性文件
import java.util.Properties;
+// 定义 MavenWrapperDownloader 类，用于下载 Maven 包装器 JAR 文件
public class MavenWrapperDownloader {
+ // 定义 Maven 包装器的版本号
private static final String WRAPPER_VERSION = "0.5.5";
/**
* Default URL to download the maven-wrapper.jar from, if no 'downloadUrl' is provided.
+ * 如果没有提供 'downloadUrl'，则从该默认 URL 下载 maven-wrapper.jar
*/
private static final String DEFAULT_DOWNLOAD_URL = "https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/"
- + WRAPPER_VERSION + "/maven-wrapper-" + WRAPPER_VERSION + ".jar";
+ + WRAPPER_VERSION + "/maven-wrapper-" + WRAPPER_VERSION + ".jar";
/**
* Path to the maven-wrapper.properties file, which might contain a downloadUrl property to
* use instead of the default one.
+ * maven-wrapper.properties 文件的路径，该文件可能包含一个 downloadUrl 属性，用于替代默认的下载 URL
*/
private static final String MAVEN_WRAPPER_PROPERTIES_PATH =
".mvn/wrapper/maven-wrapper.properties";
/**
* Path where the maven-wrapper.jar will be saved to.
+ * maven-wrapper.jar 将保存的路径
*/
private static final String MAVEN_WRAPPER_JAR_PATH =
".mvn/wrapper/maven-wrapper.jar";
/**
* Name of the property which should be used to override the default download url for the wrapper.
+ * 用于覆盖包装器默认下载 URL 的属性名
*/
private static final String PROPERTY_NAME_WRAPPER_URL = "wrapperUrl";
+ // 程序的入口点
public static void main(String args[]) {
+ // 打印下载器启动信息
System.out.println("- Downloader started");
+ // 根据命令行参数创建基础目录文件对象
File baseDirectory = new File(args[0]);
+ // 打印使用的基础目录的绝对路径
System.out.println("- Using base directory: " + baseDirectory.getAbsolutePath());
- // If the maven-wrapper.properties exists, read it and check if it contains a custom
- // wrapperUrl parameter.
+ // 如果 maven-wrapper.properties 文件存在，读取它并检查是否包含自定义的 wrapperUrl 参数
File mavenWrapperPropertyFile = new File(baseDirectory, MAVEN_WRAPPER_PROPERTIES_PATH);
+ // 初始化下载 URL 为默认值
String url = DEFAULT_DOWNLOAD_URL;
if(mavenWrapperPropertyFile.exists()) {
+ // 用于读取 maven-wrapper.properties 文件的输入流
FileInputStream mavenWrapperPropertyFileInputStream = null;
try {
+ // 打开 maven-wrapper.properties 文件的输入流
mavenWrapperPropertyFileInputStream = new FileInputStream(mavenWrapperPropertyFile);
+ // 创建 Properties 对象用于存储属性文件中的键值对
Properties mavenWrapperProperties = new Properties();
+ // 从输入流中加载属性文件内容
mavenWrapperProperties.load(mavenWrapperPropertyFileInputStream);
+ // 获取自定义的下载 URL，如果不存在则使用默认值
url = mavenWrapperProperties.getProperty(PROPERTY_NAME_WRAPPER_URL, url);
} catch (IOException e) {
+ // 打印加载 maven-wrapper.properties 文件出错信息
System.out.println("- ERROR loading '" + MAVEN_WRAPPER_PROPERTIES_PATH + "'");
} finally {
try {
+ // 关闭输入流
if(mavenWrapperPropertyFileInputStream != null) {
mavenWrapperPropertyFileInputStream.close();
}
} catch (IOException e) {
- // Ignore ...
+ // 忽略关闭输入流时可能出现的异常
}
}
}
+ // 打印下载的 URL
System.out.println("- Downloading from: " + url);
+ // 创建要保存 maven-wrapper.jar 的文件对象
File outputFile = new File(baseDirectory.getAbsolutePath(), MAVEN_WRAPPER_JAR_PATH);
+ // 如果输出文件的父目录不存在，则创建它
if(!outputFile.getParentFile().exists()) {
+ // 如果创建父目录失败，打印错误信息
if(!outputFile.getParentFile().mkdirs()) {
System.out.println(
"- ERROR creating output directory '" + outputFile.getParentFile().getAbsolutePath() + "'");
}
}
+ // 打印下载文件的保存路径
System.out.println("- Downloading to: " + outputFile.getAbsolutePath());
try {
+ // 调用下载文件的方法
downloadFileFromURL(url, outputFile);
+ // 打印下载完成信息
System.out.println("Done");
+ // 正常退出程序
System.exit(0);
} catch (Throwable e) {
+ // 打印下载出错信息
System.out.println("- Error downloading");
+ // 打印异常堆栈信息
e.printStackTrace();
+ // 异常退出程序
System.exit(1);
}
}
+ // 从指定 URL 下载文件到指定目标文件的方法
private static void downloadFileFromURL(String urlString, File destination) throws Exception {
+ // 如果环境变量中设置了 MVNW_USERNAME 和 MVNW_PASSWORD
if (System.getenv("MVNW_USERNAME") != null && System.getenv("MVNW_PASSWORD") != null) {
+ // 获取用户名
String username = System.getenv("MVNW_USERNAME");
+ // 获取密码并转换为字符数组
char[] password = System.getenv("MVNW_PASSWORD").toCharArray();
+ // 设置认证器
Authenticator.setDefault(new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
@@ -105,13 +142,20 @@ public class MavenWrapperDownloader {
}
});
}
+ // 创建 URL 对象
URL website = new URL(urlString);
+ // 用于读取网络数据的通道
ReadableByteChannel rbc;
+ // 打开 URL 连接并创建通道
rbc = Channels.newChannel(website.openStream());
+ // 创建用于写入文件的输出流
FileOutputStream fos = new FileOutputStream(destination);
+ // 将通道中的数据传输到文件输出流的通道中
fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
+ // 关闭输出流
fos.close();
+ // 关闭通道
rbc.close();
}
-}
+}
\ No newline at end of file
diff --git a/db/springbootus5uu.sql b/db/springbootus5uu.sql
index a5974fb..fd09b2a 100644
--- a/db/springbootus5uu.sql
+++ b/db/springbootus5uu.sql
@@ -3,629 +3,663 @@
-- Host: localhost Database: springbootus5uu
-- ------------------------------------------------------
-- Server version 5.7.31
+-- MySQL dump 10.13 Distrib 5.7.31, for Linux (x86_64) -- 表示这是一个MySQL数据库的转储文件，版本为10.13 Distrib 5.7.31，适用于Linux (x86_64)系统
+-- -- 空注释行
+-- Host: localhost Database: springbootus5uu -- 说明数据库所在主机为localhost，数据库名称是springbootus5uu
+-- ------------------------------------------------------ -- 分隔线注释
+-- Server version 5.7.31 -- 数据库服务器版本为5.7.31
-/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
-/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
-/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
-/*!40101 SET NAMES utf8 */;
-/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
-/*!40103 SET TIME_ZONE='+00:00' */;
-/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
-/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
-/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
-/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */; -- 保存原来的字符集客户端设置
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */; -- 保存原来的字符集结果设置
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */; -- 保存原来的连接校对设置
+/*!40101 SET NAMES utf8 */; -- 设置字符集为utf8
+/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */; -- 保存原来的时区设置
+/*!40103 SET TIME_ZONE='+00:00' */; -- 设置时区为协调世界时（UTC）
+/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */; -- 保存原来的唯一检查设置，并关闭唯一检查
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */; -- 保存原来的外键检查设置，并关闭外键检查
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */; -- 保存原来的SQL模式设置，并设置新的SQL模式为NO_AUTO_VALUE_ON_ZERO
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */; -- 保存原来的SQL注释设置，并关闭SQL注释
--
--- Table structure for table `chat`
+-- Table structure for table `chat` -- 说明接下来是表chat的表结构定义
--
-DROP TABLE IF EXISTS `chat`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `chat` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `userid` bigint(20) NOT NULL COMMENT '用户id',
- `adminid` bigint(20) DEFAULT NULL COMMENT '管理员id',
- `ask` longtext COMMENT '提问',
- `reply` longtext COMMENT '回复',
- `isreply` int(11) DEFAULT NULL COMMENT '是否回复',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=117 DEFAULT CHARSET=utf8 COMMENT='客户服务';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `chat`; -- 如果表chat存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `chat` ( -- 创建名为chat的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `userid` bigint(20) NOT NULL COMMENT '用户id', -- 定义userid字段，类型为bigint(20)，不能为空，注释为用户id
+ `adminid` bigint(20) DEFAULT NULL COMMENT '管理员id', -- 定义adminid字段，类型为bigint(20)，默认值为null，注释为管理员id
+ `ask` longtext COMMENT '提问', -- 定义ask字段，类型为longtext，注释为提问
+ `reply` longtext COMMENT '回复', -- 定义reply字段，类型为longtext，注释为回复
+ `isreply` int(11) DEFAULT NULL COMMENT '是否回复', -- 定义isreply字段，类型为int(11)，默认值为null，注释为是否回复
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB AUTO_INCREMENT=117 DEFAULT CHARSET=utf8 COMMENT='客户服务'; -- 设置表的存储引擎为InnoDB，自动递增起始值为117，字符集为utf8，注释为客户服务
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `chat`
+-- Dumping data for table `chat` -- 说明接下来是向表chat中插入数据的操作
--
-LOCK TABLES `chat` WRITE;
-/*!40000 ALTER TABLE `chat` DISABLE KEYS */;
-INSERT INTO `chat` VALUES (111,'2021-05-09 07:46:56',1,1,'提问1','回复1',1),(112,'2021-05-09 07:46:56',2,2,'提问2','回复2',2),(113,'2021-05-09 07:46:56',3,3,'提问3','回复3',3),(114,'2021-05-09 07:46:56',4,4,'提问4','回复4',4),(115,'2021-05-09 07:46:56',5,5,'提问5','回复5',5),(116,'2021-05-09 07:46:56',6,6,'提问6','回复6',6);
-/*!40000 ALTER TABLE `chat` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `chat` WRITE; -- 对表chat进行写锁定
+/*!40000 ALTER TABLE `chat` DISABLE KEYS */; -- 禁用表chat的索引以加快数据插入速度
+INSERT INTO `chat` VALUES (111,'2021-05-09 07:46:56',1,1,'提问1','回复1',1),(112,'2021-05-09 07:46:56',2,2,'提问2','回复2',2),(113,'2021-05-09 07:46:56',3,3,'提问3','回复3',3),(114,'2021-05-09 07:46:56',4,4,'提问4','回复4',4),(115,'2021-05-09 07:46:56',5,5,'提问5','回复5',5),(116,'2021-05-09 07:46:56',6,6,'提问6','回复6',6); -- 向表chat中插入多条记录
+/*!40000 ALTER TABLE `chat` ENABLE KEYS */; -- 重新启用表chat的索引
+UNLOCK TABLES; -- 解锁表chat
--
--- Table structure for table `config`
+-- Table structure for table `config` -- 说明接下来是表config的表结构定义
--
-DROP TABLE IF EXISTS `config`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `config` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `name` varchar(100) NOT NULL COMMENT '配置参数名称',
- `value` varchar(100) DEFAULT NULL COMMENT '配置参数值',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COMMENT='配置文件';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `config`; -- 如果表config存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `config` ( -- 创建名为config的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `name` varchar(100) NOT NULL COMMENT '配置参数名称', -- 定义name字段，类型为varchar(100)，不能为空，注释为配置参数名称
+ `value` varchar(100) DEFAULT NULL COMMENT '配置参数值', -- 定义value字段，类型为varchar(100)，默认值为null，注释为配置参数值
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COMMENT='配置文件'; -- 设置表的存储引擎为InnoDB，自动递增起始值为7，字符集为utf8，注释为配置文件
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `config`
+-- Dumping data for table `config` -- 说明接下来是向表config中插入数据的操作
--
-LOCK TABLES `config` WRITE;
-/*!40000 ALTER TABLE `config` DISABLE KEYS */;
-INSERT INTO `config` VALUES (1,'picture1','http://localhost:8080/springbootus5uu/upload/picture1.jpg'),(2,'picture2','http://localhost:8080/springbootus5uu/upload/picture2.jpg'),(3,'picture3','http://localhost:8080/springbootus5uu/upload/picture3.jpg'),(6,'homepage',NULL);
-/*!40000 ALTER TABLE `config` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `config` WRITE; -- 对表config进行写锁定
+/*!40000 ALTER TABLE `config` DISABLE KEYS */; -- 禁用表config的索引以加快数据插入速度
+INSERT INTO `config` VALUES (1,'picture1','http://localhost:8080/springbootus5uu/upload/picture1.jpg'),(2,'picture2','http://localhost:8080/springbootus5uu/upload/picture2.jpg'),(3,'picture3','http://localhost:8080/springbootus5uu/upload/picture3.jpg'),(6,'homepage',NULL); -- 向表config中插入多条记录
+/*!40000 ALTER TABLE `config` ENABLE KEYS */; -- 重新启用表config的索引
+UNLOCK TABLES; -- 解锁表config
--
--- Table structure for table `discusskechengxinxi`
+-- Table structure for table `discusskechengxinxi` -- 说明接下来是表discusskechengxinxi的表结构定义
--
-DROP TABLE IF EXISTS `discusskechengxinxi`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `discusskechengxinxi` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `refid` bigint(20) NOT NULL COMMENT '关联表id',
- `userid` bigint(20) NOT NULL COMMENT '用户id',
- `nickname` varchar(200) DEFAULT NULL COMMENT '用户名',
- `content` longtext NOT NULL COMMENT '评论内容',
- `reply` longtext COMMENT '回复内容',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=197 DEFAULT CHARSET=utf8 COMMENT='课程信息评论表';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `discusskechengxinxi`; -- 如果表discusskechengxinxi存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `discusskechengxinxi` ( -- 创建名为discusskechengxinxi的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `refid` bigint(20) NOT NULL COMMENT '关联表id', -- 定义refid字段，类型为bigint(20)，不能为空，注释为关联表id
+ `userid` bigint(20) NOT NULL COMMENT '用户id', -- 定义userid字段，类型为bigint(20)，不能为空，注释为用户id
+ `nickname` varchar(200) DEFAULT NULL COMMENT '用户名', -- 定义nickname字段，类型为varchar(200)，默认值为null，注释为用户名
+ `content` longtext NOT NULL COMMENT '评论内容', -- 定义content字段，类型为longtext，不能为空，注释为评论内容
+ `reply` longtext COMMENT '回复内容', -- 定义reply字段，类型为longtext，注释为回复内容
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB AUTO_INCREMENT=197 DEFAULT CHARSET=utf8 COMMENT='课程信息评论表'; -- 设置表的存储引擎为InnoDB，自动递增起始值为197，字符集为utf8，注释为课程信息评论表
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `discusskechengxinxi`
+-- Dumping data for table `discusskechengxinxi` -- 说明接下来是向表discusskechengxinxi中插入数据的操作
--
-LOCK TABLES `discusskechengxinxi` WRITE;
-/*!40000 ALTER TABLE `discusskechengxinxi` DISABLE KEYS */;
-INSERT INTO `discusskechengxinxi` VALUES (191,'2021-05-09 07:46:56',1,1,'用户名1','评论内容1','回复内容1'),(192,'2021-05-09 07:46:56',2,2,'用户名2','评论内容2','回复内容2'),(193,'2021-05-09 07:46:56',3,3,'用户名3','评论内容3','回复内容3'),(194,'2021-05-09 07:46:56',4,4,'用户名4','评论内容4','回复内容4'),(195,'2021-05-09 07:46:56',5,5,'用户名5','评论内容5','回复内容5'),(196,'2021-05-09 07:46:56',6,6,'用户名6','评论内容6','回复内容6');
-/*!40000 ALTER TABLE `discusskechengxinxi` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `discusskechengxinxi` WRITE; -- 对表discusskechengxinxi进行写锁定
+/*!40000 ALTER TABLE `discusskechengxinxi` DISABLE KEYS */; -- 禁用表discusskechengxinxi的索引以加快数据插入速度
+INSERT INTO `discusskechengxinxi` VALUES (191,'2021-05-09 07:46:56',1,1,'用户名1','评论内容1','回复内容1'),(192,'2021-05-09 07:46:56',2,2,'用户名2','评论内容2','回复内容2'),(193,'2021-05-09 07:46:56',3,3,'用户名3','评论内容3','回复内容3'),(194,'2021-05-09 07:46:56',4,4,'用户名4','评论内容4','回复内容4'),(195,'2021-05-09 07:46:56',5,5,'用户名5','评论内容5','回复内容5'),(196,'2021-05-09 07:46:56',6,6,'用户名6','评论内容6','回复内容6'); -- 向表discusskechengxinxi中插入多条记录
+/*!40000 ALTER TABLE `discusskechengxinxi` ENABLE KEYS */; -- 重新启用表discusskechengxinxi的索引
+UNLOCK TABLES; -- 解锁表discusskechengxinxi
--
--- Table structure for table `exampaper`
+-- Table structure for table `exampaper` -- 说明接下来是表exampaper的表结构定义
--
-DROP TABLE IF EXISTS `exampaper`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `exampaper` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `name` varchar(200) NOT NULL COMMENT '试卷名称',
- `time` int(11) NOT NULL COMMENT '考试时长(分钟)',
- `status` int(11) NOT NULL DEFAULT '0' COMMENT '试卷状态',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='试卷表';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `exampaper`; -- 如果表exampaper存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `exampaper` ( -- 创建名为exampaper的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `name` varchar(200) NOT NULL COMMENT '试卷名称', -- 定义name字段，类型为varchar(200)，不能为空，注释为试卷名称
+ `time` int(11) NOT NULL COMMENT '考试时长(分钟)', -- 定义time字段，类型为int(11)，不能为空，注释为考试时长(分钟)
+ `status` int(11) NOT NULL DEFAULT '0' COMMENT '试卷状态', -- 定义status字段，类型为int(11)，不能为空，默认值为0，注释为试卷状态
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='试卷表'; -- 设置表的存储引擎为InnoDB，字符集为utf8，注释为试卷表
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `exampaper`
+-- Dumping data for table `exampaper` -- 说明接下来是向表exampaper中插入数据的操作
--
-LOCK TABLES `exampaper` WRITE;
-/*!40000 ALTER TABLE `exampaper` DISABLE KEYS */;
-/*!40000 ALTER TABLE `exampaper` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `exampaper` WRITE; -- 对表exampaper进行写锁定
+/*!40000 ALTER TABLE `exampaper` DISABLE KEYS */; -- 禁用表exampaper的索引以加快数据插入速度
+/*!40000 ALTER TABLE `exampaper` ENABLE KEYS */; -- 重新启用表exampaper的索引
+UNLOCK TABLES; -- 解锁表exampaper
--
--- Table structure for table `examquestion`
+-- Table structure for table `examquestion` -- 说明接下来是表examquestion的表结构定义
--
-DROP TABLE IF EXISTS `examquestion`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `examquestion` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `paperid` bigint(20) NOT NULL COMMENT '所属试卷id（外键）',
- `papername` varchar(200) NOT NULL COMMENT '试卷名称',
- `questionname` varchar(200) NOT NULL COMMENT '试题名称',
- `options` longtext COMMENT '选项，json字符串',
- `score` bigint(20) DEFAULT '0' COMMENT '分值',
- `answer` varchar(200) DEFAULT NULL COMMENT '正确答案',
- `analysis` longtext COMMENT '答案解析',
- `type` bigint(20) DEFAULT '0' COMMENT '试题类型，0：单选题 1：多选题 2：判断题 3：填空题（暂不考虑多项填空）',
- `sequence` bigint(20) DEFAULT '100' COMMENT '试题排序，值越大排越前面',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='试题表';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `examquestion`; -- 如果表examquestion存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `examquestion` ( -- 创建名为examquestion的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `paperid` bigint(20) NOT NULL COMMENT '所属试卷id（外键）', -- 定义paperid字段，类型为bigint(20)，不能为空，注释为所属试卷id（外键）
+ `papername` varchar(200) NOT NULL COMMENT '试卷名称', -- 定义papername字段，类型为varchar(200)，不能为空，注释为试卷名称
+ `questionname` varchar(200) NOT NULL COMMENT '试题名称', -- 定义questionname字段，类型为varchar(200)，不能为空，注释为试题名称
+ `options` longtext COMMENT '选项，json字符串', -- 定义options字段，类型为longtext，注释为选项，json字符串
+ `score` bigint(20) DEFAULT '0' COMMENT '分值', -- 定义score字段，类型为bigint(20)，默认值为0，注释为分值
+ `answer` varchar(200) DEFAULT NULL COMMENT '正确答案', -- 定义answer字段，类型为varchar(200)，默认值为null，注释为正确答案
+ `analysis` longtext COMMENT '答案解析', -- 定义analysis字段，类型为longtext，注释为答案解析
+ `type` bigint(20) DEFAULT '0' COMMENT '试题类型，0：单选题 1：多选题 2：判断题 3：填空题（暂不考虑多项填空）', -- 定义type字段，类型为bigint(20)，默认值为0，注释为试题类型
+ `sequence` bigint(20) DEFAULT '100' COMMENT '试题排序，值越大排越前面', -- 定义sequence字段，类型为bigint(20)，默认值为100，注释为试题排序
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='试题表'; -- 设置表的存储引擎为InnoDB，字符集为utf8，注释为试题表
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `examquestion`
+-- Dumping data for table `examquestion` -- 说明接下来是向表examquestion中插入数据的操作
--
-LOCK TABLES `examquestion` WRITE;
-/*!40000 ALTER TABLE `examquestion` DISABLE KEYS */;
-/*!40000 ALTER TABLE `examquestion` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `examquestion` WRITE; -- 对表examquestion进行写锁定
+/*!40000 ALTER TABLE `examquestion` DISABLE KEYS */; -- 禁用表examquestion的索引以加快数据插入速度
+/*!40000 ALTER TABLE `examquestion` ENABLE KEYS */; -- 重新启用表examquestion的索引
+UNLOCK TABLES; -- 解锁表examquestion
--
--- Table structure for table `examrecord`
+-- Table structure for table `examrecord` -- 说明接下来是表examrecord的表结构定义
--
DROP TABLE IF EXISTS `examrecord`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `examrecord` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `userid` bigint(20) NOT NULL COMMENT '用户id',
- `username` varchar(200) DEFAULT NULL COMMENT '用户名',
- `paperid` bigint(20) NOT NULL COMMENT '试卷id（外键）',
- `papername` varchar(200) NOT NULL COMMENT '试卷名称',
- `questionid` bigint(20) NOT NULL COMMENT '试题id（外键）',
- `questionname` varchar(200) NOT NULL COMMENT '试题名称',
- `options` longtext COMMENT '选项，json字符串',
- `score` bigint(20) DEFAULT '0' COMMENT '分值',
- `answer` varchar(200) DEFAULT NULL COMMENT '正确答案',
- `analysis` longtext COMMENT '答案解析',
- `myscore` bigint(20) NOT NULL DEFAULT '0' COMMENT '试题得分',
- `myanswer` varchar(200) DEFAULT NULL COMMENT '考生答案',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='考试记录表';
-/*!40101 SET character_set_client = @saved_cs_client */;
-
---
--- Dumping data for table `examrecord`
---
-
-LOCK TABLES `examrecord` WRITE;
-/*!40000 ALTER TABLE `examrecord` DISABLE KEYS */;
-/*!40000 ALTER TABLE `examrecord` ENABLE KEYS */;
-UNLOCK TABLES;
-
---
--- Table structure for table `forum`
---
-
-DROP TABLE IF EXISTS `forum`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `forum` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `title` varchar(200) DEFAULT NULL COMMENT '帖子标题',
- `content` longtext NOT NULL COMMENT '帖子内容',
- `parentid` bigint(20) DEFAULT NULL COMMENT '父节点id',
- `userid` bigint(20) NOT NULL COMMENT '用户id',
- `username` varchar(200) DEFAULT NULL COMMENT '用户名',
- `isdone` varchar(200) DEFAULT NULL COMMENT '状态',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=127 DEFAULT CHARSET=utf8 COMMENT='学习交流';
-/*!40101 SET character_set_client = @saved_cs_client */;
-
---
--- Dumping data for table `forum`
---
-
-LOCK TABLES `forum` WRITE;
-/*!40000 ALTER TABLE `forum` DISABLE KEYS */;
-INSERT INTO `forum` VALUES (121,'2021-05-09 07:46:56','帖子标题1','帖子内容1',1,1,'用户名1','开放'),(122,'2021-05-09 07:46:56','帖子标题2','帖子内容2',2,2,'用户名2','开放'),(123,'2021-05-09 07:46:56','帖子标题3','帖子内容3',3,3,'用户名3','开放'),(124,'2021-05-09 07:46:56','帖子标题4','帖子内容4',4,4,'用户名4','开放'),(125,'2021-05-09 07:46:56','帖子标题5','帖子内容5',5,5,'用户名5','开放'),(126,'2021-05-09 07:46:56','帖子标题6','帖子内容6',6,6,'用户名6','开放');
-/*!40000 ALTER TABLE `forum` ENABLE KEYS */;
-UNLOCK TABLES;
-
---
--- Table structure for table `goumaidekecheng`
---
-
-DROP TABLE IF EXISTS `goumaidekecheng`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `goumaidekecheng` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `kechengmingcheng` varchar(200) DEFAULT NULL COMMENT '课程名称',
- `leixing` varchar(200) DEFAULT NULL COMMENT '类型',
- `xueke` varchar(200) DEFAULT NULL COMMENT '学科',
- `feiyong` varchar(200) DEFAULT NULL COMMENT '费用',
- `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号',
- `goumaishijian` datetime DEFAULT NULL COMMENT '购买时间',
- `sfsh` varchar(200) DEFAULT '否' COMMENT '是否审核',
- `shhf` longtext COMMENT '审核回复',
- `ispay` varchar(200) DEFAULT '未支付' COMMENT '是否支付',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=57 DEFAULT CHARSET=utf8 COMMENT='购买的课程';
-/*!40101 SET character_set_client = @saved_cs_client */;
-
---
--- Dumping data for table `goumaidekecheng`
+ --
+-- Table structure for table `examrecord` -- 说明接下来是表examrecord的表结构定义
--
-LOCK TABLES `goumaidekecheng` WRITE;
-/*!40000 ALTER TABLE `goumaidekecheng` DISABLE KEYS */;
-INSERT INTO `goumaidekecheng` VALUES (51,'2021-05-09 07:46:56','课程名称1','类型1','学科1','费用1','用户账号1','2021-05-09 15:46:56','是','','未支付'),(52,'2021-05-09 07:46:56','课程名称2','类型2','学科2','费用2','用户账号2','2021-05-09 15:46:56','是','','未支付'),(53,'2021-05-09 07:46:56','课程名称3','类型3','学科3','费用3','用户账号3','2021-05-09 15:46:56','是','','未支付'),(54,'2021-05-09 07:46:56','课程名称4','类型4','学科4','费用4','用户账号4','2021-05-09 15:46:56','是','','未支付'),(55,'2021-05-09 07:46:56','课程名称5','类型5','学科5','费用5','用户账号5','2021-05-09 15:46:56','是','','未支付'),(56,'2021-05-09 07:46:56','课程名称6','类型6','学科6','费用6','用户账号6','2021-05-09 15:46:56','是','','未支付');
-/*!40000 ALTER TABLE `goumaidekecheng` ENABLE KEYS */;
-UNLOCK TABLES;
-
---
--- Table structure for table `kechengleixing`
---
-
-DROP TABLE IF EXISTS `kechengleixing`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `kechengleixing` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `leixing` varchar(200) DEFAULT NULL COMMENT '类型',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=37 DEFAULT CHARSET=utf8 COMMENT='课程类型';
-/*!40101 SET character_set_client = @saved_cs_client */;
-
---
--- Dumping data for table `kechengleixing`
---
-
-LOCK TABLES `kechengleixing` WRITE;
-/*!40000 ALTER TABLE `kechengleixing` DISABLE KEYS */;
-INSERT INTO `kechengleixing` VALUES (31,'2021-05-09 07:46:56','类型1'),(32,'2021-05-09 07:46:56','类型2'),(33,'2021-05-09 07:46:56','类型3'),(34,'2021-05-09 07:46:56','类型4'),(35,'2021-05-09 07:46:56','类型5'),(36,'2021-05-09 07:46:56','类型6');
-/*!40000 ALTER TABLE `kechengleixing` ENABLE KEYS */;
-UNLOCK TABLES;
-
---
--- Table structure for table `kechengxinxi`
---
-
-DROP TABLE IF EXISTS `kechengxinxi`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `kechengxinxi` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `kechengmingcheng` varchar(200) DEFAULT NULL COMMENT '课程名称',
- `leixing` varchar(200) DEFAULT NULL COMMENT '类型',
- `xueke` varchar(200) DEFAULT NULL COMMENT '学科',
- `shipin` varchar(200) DEFAULT NULL COMMENT '视频',
- `laoshixingming` varchar(200) DEFAULT NULL COMMENT '老师姓名',
- `feiyong` varchar(200) DEFAULT NULL COMMENT '费用',
- `kechengtupian` varchar(200) DEFAULT NULL COMMENT '课程图片',
- `fabushijian` date DEFAULT NULL COMMENT '发布时间',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8 COMMENT='课程信息';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `examrecord`; -- 如果表examrecord存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `examrecord` ( -- 创建名为examrecord的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `userid` bigint(20) NOT NULL COMMENT '用户id', -- 定义userid字段，类型为bigint(20)，不能为空，注释为用户id
+ `username` varchar(200) DEFAULT NULL COMMENT '用户名', -- 定义username字段，类型为varchar(200)，默认值为null，注释为用户名
+ `paperid` bigint(20) NOT NULL COMMENT '试卷id（外键）', -- 定义paperid字段，类型为bigint(20)，不能为空，注释为试卷id（外键）
+ `papername` varchar(200) NOT NULL COMMENT '试卷名称', -- 定义papername字段，类型为varchar(200)，不能为空，注释为试卷名称
+ `questionid` bigint(20) NOT NULL COMMENT '试题id（外键）', -- 定义questionid字段，类型为bigint(20)，不能为空，注释为试题id（外键）
+ `questionname` varchar(200) NOT NULL COMMENT '试题名称', -- 定义questionname字段，类型为varchar(200)，不能为空，注释为试题名称
+ `options` longtext COMMENT '选项，json字符串', -- 定义options字段，类型为longtext，注释为选项，json字符串
+ `score` bigint(20) DEFAULT '0' COMMENT '分值', -- 定义score字段，类型为bigint(20)，默认值为0，注释为分值
+ `answer` varchar(200) DEFAULT NULL COMMENT '正确答案', -- 定义answer字段，类型为varchar(200)，默认值为null，注释为正确答案
+ `analysis` longtext COMMENT '答案解析', -- 定义analysis字段，类型为longtext，注释为答案解析
+ `myscore` bigint(20) NOT NULL DEFAULT '0' COMMENT '试题得分', -- 定义myscore字段，类型为bigint(20)，不能为空，默认值为0，注释为试题得分
+ `myanswer` varchar(200) DEFAULT NULL COMMENT '考生答案', -- 定义myanswer字段，类型为varchar(200)，默认值为null，注释为考生答案
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='考试记录表'; -- 设置表的存储引擎为InnoDB，字符集为utf8，注释为考试记录表
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `kechengxinxi`
+-- Dumping data for table `examrecord` -- 说明接下来是向表examrecord中插入数据的操作
--
-LOCK TABLES `kechengxinxi` WRITE;
-/*!40000 ALTER TABLE `kechengxinxi` DISABLE KEYS */;
-INSERT INTO `kechengxinxi` VALUES (21,'2021-05-09 07:46:56','课程名称1','类型1','学科1','','老师姓名1','费用1','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian1.jpg','2021-05-09'),(22,'2021-05-09 07:46:56','课程名称2','类型2','学科2','','老师姓名2','费用2','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian2.jpg','2021-05-09'),(23,'2021-05-09 07:46:56','课程名称3','类型3','学科3','','老师姓名3','费用3','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian3.jpg','2021-05-09'),(24,'2021-05-09 07:46:56','课程名称4','类型4','学科4','','老师姓名4','费用4','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian4.jpg','2021-05-09'),(25,'2021-05-09 07:46:56','课程名称5','类型5','学科5','','老师姓名5','费用5','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian5.jpg','2021-05-09'),(26,'2021-05-09 07:46:56','课程名称6','类型6','学科6','','老师姓名6','费用6','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian6.jpg','2021-05-09');
-/*!40000 ALTER TABLE `kechengxinxi` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `examrecord` WRITE; -- 对表examrecord进行写锁定
+/*!40000 ALTER TABLE `examrecord` DISABLE KEYS */; -- 禁用表examrecord的索引以加快数据插入速度
+/*!40000 ALTER TABLE `examrecord` ENABLE KEYS */; -- 重新启用表examrecord的索引
+UNLOCK TABLES; -- 解锁表examrecord
--
--- Table structure for table `messages`
+-- Table structure for table `forum` -- 说明接下来是表forum的表结构定义
--
-DROP TABLE IF EXISTS `messages`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `messages` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `userid` bigint(20) NOT NULL COMMENT '留言人id',
- `username` varchar(200) DEFAULT NULL COMMENT '用户名',
- `content` longtext NOT NULL COMMENT '留言内容',
- `reply` longtext COMMENT '回复内容',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=187 DEFAULT CHARSET=utf8 COMMENT='留言板';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `forum`; -- 如果表forum存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `forum` ( -- 创建名为forum的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `title` varchar(200) DEFAULT NULL COMMENT '帖子标题', -- 定义title字段，类型为varchar(200)，默认值为null，注释为帖子标题
+ `content` longtext NOT NULL COMMENT '帖子内容', -- 定义content字段，类型为longtext，不能为空，注释为帖子内容
+ `parentid` bigint(20) DEFAULT NULL COMMENT '父节点id', -- 定义parentid字段，类型为bigint(20)，默认值为null，注释为父节点id
+ `userid` bigint(20) NOT NULL COMMENT '用户id', -- 定义userid字段，类型为bigint(20)，不能为空，注释为用户id
+ `username` varchar(200) DEFAULT NULL COMMENT '用户名', -- 定义username字段，类型为varchar(200)，默认值为null，注释为用户名
+ `isdone` varchar(200) DEFAULT NULL COMMENT '状态', -- 定义isdone字段，类型为varchar(200)，默认值为null，注释为状态
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB AUTO_INCREMENT=127 DEFAULT CHARSET=utf8 COMMENT='学习交流'; -- 设置表的存储引擎为InnoDB，自动递增起始值为127，字符集为utf8，注释为学习交流
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
+
+--
+-- Dumping data for table `forum` -- 说明接下来是向表forum中插入数据的操作
+--
+
+LOCK TABLES `forum` WRITE; -- 对表forum进行写锁定
+/*!40000 ALTER TABLE `forum` DISABLE KEYS */; -- 禁用表forum的索引以加快数据插入速度
+INSERT INTO `forum` VALUES (121,'2021-05-09 07:46:56','帖子标题1','帖子内容1',1,1,'用户名1','开放'),(122,'2021-05-09 07:46:56','帖子标题2','帖子内容2',2,2,'用户名2','开放'),(123,'2021-05-09 07:46:56','帖子标题3','帖子内容3',3,3,'用户名3','开放'),(124,'2021-05-09 07:46:56','帖子标题4','帖子内容4',4,4,'用户名4','开放'),(125,'2021-05-09 07:46:56','帖子标题5','帖子内容5',5,5,'用户名5','开放'),(126,'2021-05-09 07:46:56','帖子标题6','帖子内容6',6,6,'用户名6','开放'); -- 向表forum中插入多条记录
+/*!40000 ALTER TABLE `forum` ENABLE KEYS */; -- 重新启用表forum的索引
+UNLOCK TABLES; -- 解锁表forum
--
--- Dumping data for table `messages`
---
-
-LOCK TABLES `messages` WRITE;
-/*!40000 ALTER TABLE `messages` DISABLE KEYS */;
-INSERT INTO `messages` VALUES (181,'2021-05-09 07:46:56',1,'用户名1','留言内容1','回复内容1'),(182,'2021-05-09 07:46:56',2,'用户名2','留言内容2','回复内容2'),(183,'2021-05-09 07:46:56',3,'用户名3','留言内容3','回复内容3'),(184,'2021-05-09 07:46:56',4,'用户名4','留言内容4','回复内容4'),(185,'2021-05-09 07:46:56',5,'用户名5','留言内容5','回复内容5'),(186,'2021-05-09 07:46:56',6,'用户名6','留言内容6','回复内容6');
-/*!40000 ALTER TABLE `messages` ENABLE KEYS */;
-UNLOCK TABLES;
+-- Table structure for table `goumaidekecheng` -- 说明接下来是表goumaidekecheng的表结构定义
+--
+
+DROP TABLE IF EXISTS `goumaidekecheng`; -- 如果表goumaidekecheng存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `goumaidekecheng` ( -- 创建名为goumaidekecheng的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `kechengmingcheng` varchar(200) DEFAULT NULL COMMENT '课程名称', -- 定义kechengmingcheng字段，类型为varchar(200)，默认值为null，注释为课程名称
+ `leixing` varchar(200) DEFAULT NULL COMMENT '类型', -- 定义leixing字段，类型为varchar(200)，默认值为null，注释为类型
+ `xueke` varchar(200) DEFAULT NULL COMMENT '学科', -- 定义xueke字段，类型为varchar(200)，默认值为null，注释为学科
+ `feiyong` varchar(200) DEFAULT NULL COMMENT '费用', -- 定义feiyong字段，类型为varchar(200)，默认值为null，注释为费用
+ `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号', -- 定义yonghuzhanghao字段，类型为varchar(200)，默认值为null，注释为用户账号
+ `goumaishijian` datetime DEFAULT NULL COMMENT '购买时间', -- 定义goumaishijian字段，类型为datetime，默认值为null，注释为购买时间
+ `sfsh` varchar(200) DEFAULT '否' COMMENT '是否审核', -- 定义sfsh字段，类型为varchar(200)，默认值为'否'，注释为是否审核
+ `shhf` longtext COMMENT '审核回复', -- 定义shhf字段，类型为longtext，注释为审核回复
+ `ispay` varchar(200) DEFAULT '未支付' COMMENT '是否支付', -- 定义ispay字段，类型为varchar(200)，默认值为'未支付'，注释为是否支付
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB AUTO_INCREMENT=57 DEFAULT CHARSET=utf8 COMMENT='购买的课程'; -- 设置表的存储引擎为InnoDB，自动递增起始值为57，字符集为utf8，注释为购买的课程
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Table structure for table `news`
+-- Dumping data for table `goumaidekecheng` -- 说明接下来是向表goumaidekecheng中插入数据的操作
--
-DROP TABLE IF EXISTS `news`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `news` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `title` varchar(200) NOT NULL COMMENT '标题',
- `introduction` longtext COMMENT '简介',
- `picture` varchar(200) NOT NULL COMMENT '图片',
- `content` longtext NOT NULL COMMENT '内容',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=177 DEFAULT CHARSET=utf8 COMMENT='教育资讯';
-/*!40101 SET character_set_client = @saved_cs_client */;
+LOCK TABLES `goumaidekecheng` WRITE; -- 对表goumaidekecheng进行写锁定
+/*!40000 ALTER TABLE `goumaidekecheng` DISABLE KEYS */; -- 禁用表goumaidekecheng的索引以加快数据插入速度
+INSERT INTO `goumaidekecheng` VALUES (51,'2021-05-09 07:46:56','课程名称1','类型1','学科1','费用1','用户账号1','2021-05-09 15:46:56','是','','未支付'),(52,'2021-05-09 07:46:56','课程名称2','类型2','学科2','费用2','用户账号2','2021-05-09 15:46:56','是','','未支付'),(53,'2021-05-09 07:46:56','课程名称3','类型3','学科3','费用3','用户账号3','2021-05-09 15:46:56','是','','未支付'),(54,'2021-05-09 07:46:56','课程名称4','类型4','学科4','费用4','用户账号4','2021-05-09 15:46:56','是','','未支付'),(55,'2021-05-09 07:46:56','课程名称5','类型5','学科5','费用5','用户账号5','2021-05-09 15:46:56','是','','未支付'),(56,'2021-05-09 07:46:56','课程名称6','类型6','学科6','费用6','用户账号6','2021-05-09 15:46:56','是','','未支付'); -- 向表goumaidekecheng中插入多条记录
+/*!40000 ALTER TABLE `goumaidekecheng` ENABLE KEYS */; -- 重新启用表goumaidekecheng的索引
+UNLOCK TABLES; -- 解锁表goumaidekecheng
--
--- Dumping data for table `news`
+-- Table structure for table `kechengleixing` -- 说明接下来是表kechengleixing的表结构定义
--
-LOCK TABLES `news` WRITE;
-/*!40000 ALTER TABLE `news` DISABLE KEYS */;
-INSERT INTO `news` VALUES (171,'2021-05-09 07:46:56','标题1','简介1','http://localhost:8080/springbootus5uu/upload/news_picture1.jpg','内容1'),(172,'2021-05-09 07:46:56','标题2','简介2','http://localhost:8080/springbootus5uu/upload/news_picture2.jpg','内容2'),(173,'2021-05-09 07:46:56','标题3','简介3','http://localhost:8080/springbootus5uu/upload/news_picture3.jpg','内容3'),(174,'2021-05-09 07:46:56','标题4','简介4','http://localhost:8080/springbootus5uu/upload/news_picture4.jpg','内容4'),(175,'2021-05-09 07:46:56','标题5','简介5','http://localhost:8080/springbootus5uu/upload/news_picture5.jpg','内容5'),(176,'2021-05-09 07:46:56','标题6','简介6','http://localhost:8080/springbootus5uu/upload/news_picture6.jpg','内容6');
-/*!40000 ALTER TABLE `news` ENABLE KEYS */;
-UNLOCK TABLES;
+DROP TABLE IF EXISTS `kechengleixing`; -- 如果表kechengleixing存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `kechengleixing` ( -- 创建名为kechengleixing的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `leixing` varchar(200) DEFAULT NULL COMMENT '类型', -- 定义leixing字段，类型为varchar(200)，默认值为null，注释为类型
+ PRIMARY KEY (`id`) -- 定义id字段为主键
+) ENGINE=InnoDB AUTO_INCREMENT=37 DEFAULT CHARSET=utf8 COMMENT='课程类型'; -- 设置表的存储引擎为InnoDB，自动递增起始值为37，字符集为utf8，注释为课程类型
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Table structure for table `shipindianbo`
+-- Dumping data for table `kechengleixing` -- 说明接下来是向表kechengleixing中插入数据的操作
--
-DROP TABLE IF EXISTS `shipindianbo`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `shipindianbo` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `shipinmingcheng` varchar(200) DEFAULT NULL COMMENT '视频名称',
- `shipin` varchar(200) DEFAULT NULL COMMENT '视频',
- `shipinjianjie` longtext COMMENT '视频简介',
- `laiyuan` varchar(200) DEFAULT NULL COMMENT '来源',
- `shangchuanshijian` datetime DEFAULT NULL COMMENT '上传时间',
- `fengmian` varchar(200) DEFAULT NULL COMMENT '封面',
- `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号',
- `userid` bigint(20) DEFAULT NULL COMMENT '用户id',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=77 DEFAULT CHARSET=utf8 COMMENT='视频点播';
-/*!40101 SET character_set_client = @saved_cs_client */;
+LOCK TABLES `kechengleixing` WRITE; -- 对表kechengleixing进行写锁定
+/*!40000 ALTER TABLE `kechengleixing` DISABLE KEYS */; -- 禁用表kechengleixing的索引以加快数据插入速度
+INSERT INTO `kechengleixing` VALUES (31,'2021-05-09 07:46:56','类型1'),(32,'2021-05-09 07:46:56','类型2'),(33,'2021-05-09 07:46:56','类型3'),(34,'2021-05-09 07:46:56','类型4'),(35,'2021-05-09 07:46:56','类型5'),(36,'2021-05-09 07:46:56','类型6'); -- 向表kechengleixing中插入多条记录
+/*!40000 ALTER TABLE `kechengleixing` ENABLE KEYS */; -- 重新启用表kechengleixing的索引
+UNLOCK TABLES; -- 解锁表kechengleixing
--
--- Dumping data for table `shipindianbo`
+-- Table structure for table `kechengxinxi` -- 说明接下来是表kechengxinxi的表结构定义
--
-LOCK TABLES `shipindianbo` WRITE;
-/*!40000 ALTER TABLE `shipindianbo` DISABLE KEYS */;
-INSERT INTO `shipindianbo` VALUES (71,'2021-05-09 07:46:56','视频名称1','http://localhost:8080/springbootus5uu/upload/1620547330699.mp4','视频简介1','来源1','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian1.jpg','用户1',1),(72,'2021-05-09 07:46:56','视频名称2','','视频简介2','来源2','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian2.jpg','用户账号2',2),(73,'2021-05-09 07:46:56','视频名称3','','视频简介3','来源3','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian3.jpg','用户账号3',3),(74,'2021-05-09 07:46:56','视频名称4','','视频简介4','来源4','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian4.jpg','用户账号4',4),(75,'2021-05-09 07:46:56','视频名称5','','视频简介5','来源5','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian5.jpg','用户账号5',5),(76,'2021-05-09 07:46:56','视频名称6','','视频简介6','来源6','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian6.jpg','用户账号6',6);
-/*!40000 ALTER TABLE `shipindianbo` ENABLE KEYS */;
-UNLOCK TABLES;
+DROP TABLE IF EXISTS `kechengxinxi`; -- 如果表kechengxinxi存在则删除它
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为utf8
+CREATE TABLE `kechengxinxi` ( -- 创建名为kechengxinxi的表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义id字段，类型为bigint(20)，不能为空，自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义addtime字段，类型为timestamp，不能为空，默认值为当前时间戳，注释为创建时间
+ `kechengmingcheng` varchar(200) DEFAULT NULL COMMENT '课程名称', -- 定义kechengmingcheng字段，类型为varchar(200)，默认值为null，注释为课程名称
+ `leixing` varchar(200) DEFAULT NULL COMMENT '类型', -- 定义leixing字段，类型为varchar(200)，默认值为null，注释为类型
+ `xueke` varchar(200) DEFAULT NULL COMMENT '学科', -- 定义xueke字段，类型为varchar(200)，默认值为null，注释为学科
+ `shipin` varchar(200) DEFAULT NULL COMMENT '视频', -- 定义shipin字段，类型为varchar
---
--- Table structure for table `storeup`
+ --
+-- Table structure for table `kechengxinxi` -- 表明接下来是对 `kechengxinxi` 表结构的定义
--
-DROP TABLE IF EXISTS `storeup`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `storeup` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `userid` bigint(20) NOT NULL COMMENT '用户id',
- `refid` bigint(20) DEFAULT NULL COMMENT '收藏id',
- `tablename` varchar(200) DEFAULT NULL COMMENT '表名',
- `name` varchar(200) NOT NULL COMMENT '收藏名称',
- `picture` varchar(200) NOT NULL COMMENT '收藏图片',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='收藏表';
-/*!40101 SET character_set_client = @saved_cs_client */;
+ DROP TABLE IF EXISTS `kechengxinxi`; -- 若 `kechengxinxi` 表存在，则将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `kechengxinxi` ( -- 创建 `kechengxinxi` 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 `id` 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 `addtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `kechengmingcheng` varchar(200) DEFAULT NULL COMMENT '课程名称', -- 定义 `kechengmingcheng` 字段，类型为 varchar(200)，默认值为 NULL，注释为课程名称
+ `leixing` varchar(200) DEFAULT NULL COMMENT '类型', -- 定义 `leixing` 字段，类型为 varchar(200)，默认值为 NULL，注释为类型
+ `xueke` varchar(200) DEFAULT NULL COMMENT '学科', -- 定义 `xueke` 字段，类型为 varchar(200)，默认值为 NULL，注释为学科
+ `shipin` varchar(200) DEFAULT NULL COMMENT '视频', -- 定义 `shipin` 字段，类型为 varchar(200)，默认值为 NULL，注释为视频
+ `laoshixingming` varchar(200) DEFAULT NULL COMMENT '老师姓名', -- 定义 `laoshixingming` 字段，类型为 varchar(200)，默认值为 NULL，注释为老师姓名
+ `feiyong` varchar(200) DEFAULT NULL COMMENT '费用', -- 定义 `feiyong` 字段，类型为 varchar(200)，默认值为 NULL，注释为费用
+ `kechengtupian` varchar(200) DEFAULT NULL COMMENT '课程图片', -- 定义 `kechengtupian` 字段，类型为 varchar(200)，默认值为 NULL，注释为课程图片
+ `fabushijian` date DEFAULT NULL COMMENT '发布时间', -- 定义 `fabushijian` 字段，类型为 date，默认值为 NULL，注释为发布时间
+ PRIMARY KEY (`id`) -- 将 `id` 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8 COMMENT='课程信息'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 27，字符集为 UTF-8，注释为课程信息
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `storeup`
+-- Dumping data for table `kechengxinxi` -- 表示接下来是向 `kechengxinxi` 表中插入数据
--
-LOCK TABLES `storeup` WRITE;
-/*!40000 ALTER TABLE `storeup` DISABLE KEYS */;
-/*!40000 ALTER TABLE `storeup` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `kechengxinxi` WRITE; -- 对 `kechengxinxi` 表进行写锁定
+/*!40000 ALTER TABLE `kechengxinxi` DISABLE KEYS */; -- 禁用 `kechengxinxi` 表的索引以加快数据插入速度
+INSERT INTO `kechengxinxi` VALUES (21,'2021-05-09 07:46:56','课程名称1','类型1','学科1','','老师姓名1','费用1','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian1.jpg','2021-05-09'),
+ (22,'2021-05-09 07:46:56','课程名称2','类型2','学科2','','老师姓名2','费用2','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian2.jpg','2021-05-09'),
+ (23,'2021-05-09 07:46:56','课程名称3','类型3','学科3','','老师姓名3','费用3','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian3.jpg','2021-05-09'),
+ (24,'2021-05-09 07:46:56','课程名称4','类型4','学科4','','老师姓名4','费用4','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian4.jpg','2021-05-09'),
+ (25,'2021-05-09 07:46:56','课程名称5','类型5','学科5','','老师姓名5','费用5','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian5.jpg','2021-05-09'),
+ (26,'2021-05-09 07:46:56','课程名称6','类型6','学科6','','老师姓名6','费用6','http://localhost:8080/springbootus5uu/upload/kechengxinxi_kechengtupian6.jpg','2021-05-09'); -- 向 `kechengxinxi` 表插入多条记录
+/*!40000 ALTER TABLE `kechengxinxi` ENABLE KEYS */; -- 重新启用 `kechengxinxi` 表的索引
+UNLOCK TABLES; -- 解锁 `kechengxinxi` 表
--
--- Table structure for table `token`
+-- Table structure for table `messages` -- 表明接下来是对 `messages` 表结构的定义
--
-DROP TABLE IF EXISTS `token`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `token` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `userid` bigint(20) NOT NULL COMMENT '用户id',
- `username` varchar(100) NOT NULL COMMENT '用户名',
- `tablename` varchar(100) DEFAULT NULL COMMENT '表名',
- `role` varchar(100) DEFAULT NULL COMMENT '角色',
- `token` varchar(200) NOT NULL COMMENT '密码',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '新增时间',
- `expiratedtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '过期时间',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='token表';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `messages`;
+-- 若 `messages` 表存在，则将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `messages` ( -- 创建 `messages` 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 `id` 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 `addtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `userid` bigint(20) NOT NULL COMMENT '留言人id', -- 定义 `userid` 字段，类型为 bigint(20)，非空，注释为留言人 id
+ `username` varchar(200) DEFAULT NULL COMMENT '用户名', -- 定义 `username` 字段，类型为 varchar(200)，默认值为 NULL，注释为用户名
+ `content` longtext NOT NULL COMMENT '留言内容', -- 定义 `content` 字段，类型为 longtext，非空，注释为留言内容
+ `reply` longtext COMMENT '回复内容', -- 定义 `reply` 字段，类型为 longtext，注释为回复内容
+ PRIMARY KEY (`id`) -- 将 `id` 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=187 DEFAULT CHARSET=utf8 COMMENT='留言板'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 187，字符集为 UTF-8，注释为留言板
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
+
+--
+-- Dumping data for table `messages` -- 表示接下来是向 `messages` 表中插入数据
+--
+
+LOCK TABLES `messages` WRITE; -- 对 `messages` 表进行写锁定
+/*!40000 ALTER TABLE `messages` DISABLE KEYS */; -- 禁用 `messages` 表的索引以加快数据插入速度
+INSERT INTO `messages` VALUES (181,'2021-05-09 07:46:56',1,'用户名1','留言内容1','回复内容1'),
+ (182,'2021-05-09 07:46:56',2,'用户名2','留言内容2','回复内容2'),
+ (183,'2021-05-09 07:46:56',3,'用户名3','留言内容3','回复内容3'),
+ (184,'2021-05-09 07:46:56',4,'用户名4','留言内容4','回复内容4'),
+ (185,'2021-05-09 07:46:56',5,'用户名5','留言内容5','回复内容5'),
+ (186,'2021-05-09 07:46:56',6,'用户名6','留言内容6','回复内容6'); -- 向 `messages` 表插入多条记录
+/*!40000 ALTER TABLE `messages` ENABLE KEYS */; -- 重新启用 `messages` 表的索引
+UNLOCK TABLES; -- 解锁 `messages` 表
+
+--
+-- Table structure for table `news` -- 表明接下来是对 `news` 表结构的定义
+--
+
+DROP TABLE IF EXISTS `news`; -- 若 `news` 表存在，则将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `news` ( -- 创建 `news` 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 `id` 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 `addtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `title` varchar(200) NOT NULL COMMENT '标题', -- 定义 `title` 字段，类型为 varchar(200)，非空，注释为标题
+ `introduction` longtext COMMENT '简介', -- 定义 `introduction` 字段，类型为 longtext，注释为简介
+ `picture` varchar(200) NOT NULL COMMENT '图片', -- 定义 `picture` 字段，类型为 varchar(200)，非空，注释为图片
+ `content` longtext NOT NULL COMMENT '内容', -- 定义 `content` 字段，类型为 longtext，非空，注释为内容
+ PRIMARY KEY (`id`) -- 将 `id` 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=177 DEFAULT CHARSET=utf8 COMMENT='教育资讯'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 177，字符集为 UTF-8，注释为教育资讯
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
+
+--
+-- Dumping data for table `news` -- 表示接下来是向 `news` 表中插入数据
+--
+
+LOCK TABLES `news` WRITE; -- 对 `news` 表进行写锁定
+/*!40000 ALTER TABLE `news` DISABLE KEYS */; -- 禁用 `news` 表的索引以加快数据插入速度
+INSERT INTO `news` VALUES (171,'2021-05-09 07:46:56','标题1','简介1','http://localhost:8080/springbootus5uu/upload/news_picture1.jpg','内容1'),
+ (172,'2021-05-09 07:46:56','标题2','简介2','http://localhost:8080/springbootus5uu/upload/news_picture2.jpg','内容2'),
+ (173,'2021-05-09 07:46:56','标题3','简介3','http://localhost:8080/springbootus5uu/upload/news_picture3.jpg','内容3'),
+ (174,'2021-05-09 07:46:56','标题4','简介4','http://localhost:8080/springbootus5uu/upload/news_picture4.jpg','内容4'),
+ (175,'2021-05-09 07:46:56','标题5','简介5','http://localhost:8080/springbootus5uu/upload/news_picture5.jpg','内容5'),
+ (176,'2021-05-09 07:46:56','标题6','简介6','http://localhost:8080/springbootus5uu/upload/news_picture6.jpg','内容6'); -- 向 `news` 表插入多条记录
+/*!40000 ALTER TABLE `news` ENABLE KEYS */; -- 重新启用 `news` 表的索引
+UNLOCK TABLES; -- 解锁 `news` 表
--
--- Dumping data for table `token`
+-- Table structure for table `shipindianbo` -- 表明接下来是对 `shipindianbo` 表结构的定义
+--
+
+DROP TABLE IF EXISTS `shipindianbo`; -- 若 `shipindianbo` 表存在，则将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `shipindianbo` ( -- 创建 `shipindianbo` 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 `id` 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 `addtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `shipinmingcheng` varchar(200) DEFAULT NULL COMMENT '视频名称', -- 定义 `shipinmingcheng` 字段，类型为 varchar(200)，默认值为 NULL，注释为视频名称
+ `shipin` varchar(200) DEFAULT NULL COMMENT '视频', -- 定义 `shipin` 字段，类型为 varchar(200)，默认值为 NULL，注释为视频
+ `shipinjianjie` longtext COMMENT '视频简介', -- 定义 `shipinjianjie` 字段，类型为 longtext，注释为视频简介
+ `laiyuan` varchar(200) DEFAULT NULL COMMENT '来源', -- 定义 `laiyuan` 字段，类型为 varchar(200)，默认值为 NULL，注释为来源
+ `shangchuanshijian` datetime DEFAULT NULL COMMENT '上传时间', -- 定义 `shangchuanshijian` 字段，类型为 datetime，默认值为 NULL，注释为上传时间
+ `fengmian` varchar(200) DEFAULT NULL COMMENT '封面', -- 定义 `fengmian` 字段，类型为 varchar(200)，默认值为 NULL，注释为封面
+ `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号', -- 定义 `yonghuzhanghao` 字段，类型为 varchar(200)，默认值为 NULL，注释为用户账号
+ `userid` bigint(20) DEFAULT NULL COMMENT '用户id', -- 定义 `userid` 字段，类型为 bigint(20)，默认值为 NULL，注释为用户 id
+ PRIMARY KEY (`id`) -- 将 `id` 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=77 DEFAULT CHARSET=utf8 COMMENT='视频点播'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 77，字符集为 UTF-8，注释为视频点播
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
+
+--
+-- Dumping data for table `shipindianbo` -- 表示接下来是向 `shipindianbo` 表中插入数据
--
-LOCK TABLES `token` WRITE;
-/*!40000 ALTER TABLE `token` DISABLE KEYS */;
-INSERT INTO `token` VALUES (1,11,'用户1','yonghu','用户','lmyhs373nwl5bgxuaqqaov03fo3mr4ci','2021-05-09 07:48:33','2021-05-09 09:02:33'),(2,1,'abo','users','管理员','o4g7kcsm6le2m4rz9iui659gd9ck4qqh','2021-05-09 07:49:17','2021-05-09 08:49:17');
-/*!40000 ALTER TABLE `token` ENABLE KEYS */;
-UNLOCK TABLES;
-
---
--- Table structure for table `users`
---
+LOCK TABLES `shipindianbo` WRITE; -- 对 `shipindianbo` 表进行写锁定
+/*!40000 ALTER TABLE `shipindianbo` DISABLE KEYS */; -- 禁用 `shipindianbo` 表的索引以加快数据插入速度
+INSERT INTO `shipindianbo` VALUES (71,'2021-05-09 07:46:56','视频名称1','http://localhost:8080/springbootus5uu/upload/1620547330699.mp4','视频简介1','来源1','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian1.jpg','用户1',1),
+ (72,'2021-05-09 07:46:56','视频名称2','','视频简介2','来源2','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian2.jpg','用户账号2',2),
+ (73,'2021-05-09 07:46:56','视频名称3','','视频简介3','来源3','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian3.jpg','用户账号3',3),
+ (74,'2021-05-09 07:46:56','视频名称4','','视频简介4','来源4','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian4.jpg','用户账号4',4),
+ (75,'2021-05-09 07:46:56','视频名称5','','视频简介5','来源5','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian5.jpg','用户账号5',5),
+ (76,'2021-05-09 07:46:56','视频名称6','','视频简介6','来源6','2021-05-09 15:46:56','http://localhost:8080/springbootus5uu/upload/shipindianbo_fengmian6.jpg','用户账号6',6); -- 向 `shipindianbo` 表插入多条记录
+/*!40000 ALTER TABLE `shipindianbo` ENABLE KEYS */; -- 重新启用 `shipindianbo` 表的索引
+UNLOCK TABLES; -- 解锁 `shipindianbo` 表
+
+--
+-- Table structure for table `storeup` -- 表明接下来是对 `storeup` 表结构的定义
+--
-DROP TABLE IF EXISTS `users`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `users` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `username` varchar(100) NOT NULL COMMENT '用户名',
- `password` varchar(100) NOT NULL COMMENT '密码',
- `role` varchar(100) DEFAULT '管理员' COMMENT '角色',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '新增时间',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='用户表';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `storeup`; -- 若 `storeup` 表存在，则将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `storeup` ( -- 创建 `storeup` 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 `id` 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 `addtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `userid` bigint(20) NOT NULL COMMENT '用户id', -- 定义 `userid` 字段，类型为 bigint(20)，非空，注释为用户 id
+ `refid` bigint(20) DEFAULT NULL COMMENT '收藏id', -- 定义 `refid` 字段，类型为 bigint(20)，默认值为 NULL，注释为收藏 id
+ `tablename` varchar(200) DEFAULT NULL COMMENT '表名', -- 定义 `tablename` 字段，类型为 varchar(200)，默认值为 NULL，注释为表名
+ `name` varchar(200) NOT NULL COMMENT '收藏名称', -- 定义 `name` 字段，类型为 varchar(200)，非空，注释为收藏名称
+ `picture` varchar(200) NOT NULL COMMENT '收藏图片', -- 定义 `picture` 字段，类型为 varchar(200)，非空，注释为收藏图片
+ PRIMARY KEY (`id`) -- 将 `id` 字段设为主键
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='收藏表'; -- 设置表的存储引擎为 InnoDB，字符集为 UTF-8，注释为收藏表
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `users`
+-- Dumping data for table `storeup` -- 表示接下来是向 `storeup` 表中插入数据
--
-LOCK TABLES `users` WRITE;
-/*!40000 ALTER TABLE `users` DISABLE KEYS */;
-INSERT INTO `users` VALUES (1,'abo','abo','管理员','2021-05-09 07:46:56');
-/*!40000 ALTER TABLE `users` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `storeup` WRITE; -- 对 `storeup` 表进行写锁定
+/*!40000 ALTER TABLE `storeup` DISABLE KEYS */; -- 禁用 `storeup` 表的索引以加快数据插入速度
+/*!40000 ALTER TABLE `storeup` ENABLE KEYS */; -- 重新启用 `storeup` 表的索引
+UNLOCK TABLES; -- 解锁 `storeup` 表
--
--- Table structure for table `wodebiji`
+-- Table structure for table `token` -- 表明接下来是对 `token` 表结构的定义
--
-DROP TABLE IF EXISTS `wodebiji`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `wodebiji` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `biaoti` varchar(200) DEFAULT NULL COMMENT '标题',
- `neirong` longtext COMMENT '内容',
- `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=87 DEFAULT CHARSET=utf8 COMMENT='我的笔记';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `token`; -- 若 `token` 表存在，则将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `token` ( -- 创建 `token` 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 `id` 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `userid` bigint(20) NOT NULL COMMENT '用户id', -- 定义 `userid` 字段，类型为 bigint(20)，非空，注释为用户 id
+ `username` varchar(100) NOT NULL COMMENT '用户名', -- 定义 `username` 字段，类型为 varchar(100)，非空，注释为用户名
+ `tablename` varchar(100) DEFAULT NULL COMMENT '表名', -- 定义 `tablename` 字段，类型为 varchar(100)，默认值为 NULL，注释为表名
+ `role` varchar(100) DEFAULT NULL COMMENT '角色', -- 定义 `role` 字段，类型为 varchar(100)，默认值为 NULL，注释为角色
+ `token` varchar(200) NOT NULL COMMENT '密码', -- 定义 `token` 字段，类型为 varchar(200)，非空，注释为密码
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '新增时间', -- 定义 `addtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为新增时间
+ `expiratedtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '过期时间', -- 定义 `expiratedtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为过期时间
+ PRIMARY KEY (`id`) -- 将 `id` 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='token表'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 3，字符集为 UTF-8，注释为 token 表
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `wodebiji`
+-- Dumping data for table `token` -- 表示接下来是向 `token` 表中插入数据
--
-LOCK TABLES `wodebiji` WRITE;
-/*!40000 ALTER TABLE `wodebiji` DISABLE KEYS */;
-INSERT INTO `wodebiji` VALUES (81,'2021-05-09 07:46:56','标题1','内容1','用户账号1'),(82,'2021-05-09 07:46:56','标题2','内容2','用户账号2'),(83,'2021-05-09 07:46:56','标题3','内容3','用户账号3'),(84,'2021-05-09 07:46:56','标题4','内容4','用户账号4'),(85,'2021-05-09 07:46:56','标题5','内容5','用户账号5'),(86,'2021-05-09 07:46:56','标题6','内容6','用户账号6');
-/*!40000 ALTER TABLE `wodebiji` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `token` WRITE; -- 对 `token` 表进行写锁定
+/*!40000 ALTER TABLE `token` DISABLE KEYS */; -- 禁用 `token` 表的索引以加快数据插入速度
+INSERT INTO `token` VALUES (1,11,'用户1','yonghu','用户','lmyhs373nwl5bgxuaqqaov03fo3mr4ci','2021-05-09 07:48:33','2021-05-09 09:02:33'),
+ (2,1,'abo','users','管理员','o4g7kcsm6le2m4rz9iui659gd9ck4qqh','2021-05-09 07:49:17','2021-05-09 08:49:17'); -- 向 `token` 表插入多条记录
+/*!40000 ALTER TABLE `token` ENABLE KEYS */; -- 重新启用 `token` 表的索引
+UNLOCK TABLES; -- 解锁 `token` 表
--
--- Table structure for table `wodekecheng`
+-- Table structure for table `users` -- 表明接下来是对 `users` 表结构的定义
--
-DROP TABLE IF EXISTS `wodekecheng`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `wodekecheng` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `kechengmingcheng` varchar(200) DEFAULT NULL COMMENT '课程名称',
- `zhangjie` varchar(200) DEFAULT NULL COMMENT '章节',
- `wenjian` varchar(200) DEFAULT NULL COMMENT '文件',
- `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=97 DEFAULT CHARSET=utf8 COMMENT='我的课程';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `users`; -- 若 `users` 表存在，则将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `users` ( -- 创建 `users` 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 `id` 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `username` varchar(100) NOT NULL COMMENT '用户名', -- 定义 `username` 字段，类型为 varchar(100)，非空，注释为用户名
+ `password` varchar(100) NOT NULL COMMENT '密码', -- 定义 `password` 字段，类型为 varchar(100)，非空，注释为密码
+ `role` varchar(100) DEFAULT '管理员' COMMENT '角色', -- 定义 `role` 字段，类型为 varchar(100)，默认值为 '管理员'，注释为角色
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '新增时间', -- 定义 `addtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为新增时间
+ PRIMARY KEY (`id`) -- 将 `id` 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='用户表'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 2，字符集为 UTF-8，注释为用户表
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `wodekecheng`
+-- Dumping data for table `users` -- 表示接下来是向 `users` 表中插入数据
--
-LOCK TABLES `wodekecheng` WRITE;
-/*!40000 ALTER TABLE `wodekecheng` DISABLE KEYS */;
-INSERT INTO `wodekecheng` VALUES (91,'2021-05-09 07:46:56','课程名称1','章节1','','用户账号1'),(92,'2021-05-09 07:46:56','课程名称2','章节2','','用户账号2'),(93,'2021-05-09 07:46:56','课程名称3','章节3','','用户账号3'),(94,'2021-05-09 07:46:56','课程名称4','章节4','','用户账号4'),(95,'2021-05-09 07:46:56','课程名称5','章节5','','用户账号5'),(96,'2021-05-09 07:46:56','课程名称6','章节6','','用户账号6');
-/*!40000 ALTER TABLE `wodekecheng` ENABLE KEYS */;
-UNLOCK TABLES;
+LOCK TABLES `users` WRITE; -- 对 `users` 表进行写锁定
+/*!40000 ALTER TABLE `users` DISABLE KEYS */; -- 禁用 `users` 表的索引以加快数据插入速度
+INSERT INTO `users` VALUES (1,'abo','abo','管理员','2021-05-09 07:46:56'); -- 向 `users` 表插入一条记录
+/*!40000 ALTER TABLE `users` ENABLE KEYS */; -- 重新启用 `users` 表的索引
+UNLOCK TABLES; -- 解锁 `users` 表
--
--- Table structure for table `xiaoxitongzhi`
+-- Table structure for table `wodebiji` -- 表明接下来是对 `wodebiji` 表结构的定义
--
-DROP TABLE IF EXISTS `xiaoxitongzhi`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `xiaoxitongzhi` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `tongzhibiaoti` varchar(200) DEFAULT NULL COMMENT '通知标题',
- `tongzhineirong` longtext COMMENT '通知内容',
- `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号',
- `fasongshijian` datetime DEFAULT NULL COMMENT '发送时间',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=107 DEFAULT CHARSET=utf8 COMMENT='消息通知';
-/*!40101 SET character_set_client = @saved_cs_client */;
+DROP TABLE IF EXISTS `wodebiji`; -- 若 `wodebiji` 表存在，则将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `wodebiji` ( -- 创建 `wodebiji` 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 `id` 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 `addtime` 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `biaoti` varchar(200) DEFAULT NULL COMMENT '标题', -- 定义 `biaoti` 字段，类型为 varchar(200)，默认值为 NULL，注释为标题
+ `neirong` longtext COMMENT '内容', -- 定义 `neirong` 字段，类型为 longtext，注释为内容
+ `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号', -- 定义 `yonghuzhanghao` 字段，类型为 varchar(200)，默认值为 NULL，注释为用户账号
+ PRIMARY KEY (`id`) -- 将 `id` 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=87 DEFAULT CHARSET=utf8 COMMENT='我的笔记'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 87，字符集为 UTF-8，注释为我的笔记
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
--
--- Dumping data for table `xiaoxitongzhi`
+-- Dumping data for table `wodebiji` -- 表示接下来是向 `wodebiji` 表中插入数据
--
-LOCK TABLES `xiaoxitongzhi` WRITE;
-/*!40000 ALTER TABLE `xiaoxitongzhi` DISABLE KEYS */;
-INSERT INTO `xiaoxitongzhi` VALUES (101,'2021-05-09 07:46:56','通知标题1','通知内容1','用户账号1','2021-05-09 15:46:56'),(102,'2021-05-09 07:46:56','通知标题2','通知内容2','用户账号2','2021-05-09 15:46:56'),(103,'2021-05-09 07:46:56','通知标题3','通知内容3','用户账号3','2021-05-09 15:46:56'),(104,'2021-05-09 07:46:56','通知标题4','通知内容4','用户账号4','2021-05-09 15:46:56'),(105,'2021-05-09 07:46:56','通知标题5','通知内容5','用户账号5','2021-05-09 15:46:56'),(106,'2021-05-09 07:46:56','通知标题6','通知内容6','用户账号6','2021-05-09 15:46:56');
-/*!40000 ALTER TABLE `xiaoxitongzhi` ENABLE KEYS */;
-UNLOCK TABLES;
-
--
--- Table structure for table `xueke`
+-- Table structure for table `wodebiji` -- 说明接下来是定义 wodebiji 表的结构
--
-DROP TABLE IF EXISTS `xueke`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `xueke` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `xueke` varchar(200) DEFAULT NULL COMMENT '学科',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=47 DEFAULT CHARSET=utf8 COMMENT='学科';
-/*!40101 SET character_set_client = @saved_cs_client */;
-
+DROP TABLE IF EXISTS `wodebiji`; -- 如果 wodebiji 表已存在，就将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `wodebiji` ( -- 创建 wodebiji 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 id 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 addtime 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `biaoti` varchar(200) DEFAULT NULL COMMENT '标题', -- 定义 biaoti 字段，类型为 varchar(200)，默认值为 NULL，注释为标题
+ `neirong` longtext COMMENT '内容', -- 定义 neirong 字段，类型为 longtext，注释为内容
+ `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号', -- 定义 yonghuzhanghao 字段，类型为 varchar(200)，默认值为 NULL，注释为用户账号
+ PRIMARY KEY (`id`) -- 将 id 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=87 DEFAULT CHARSET=utf8 COMMENT='我的笔记'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 87，字符集为 UTF-8，注释为我的笔记
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
+
--
--- Dumping data for table `xueke`
---
-
-LOCK TABLES `xueke` WRITE;
-/*!40000 ALTER TABLE `xueke` DISABLE KEYS */;
-INSERT INTO `xueke` VALUES (41,'2021-05-09 07:46:56','学科1'),(42,'2021-05-09 07:46:56','学科2'),(43,'2021-05-09 07:46:56','学科3'),(44,'2021-05-09 07:46:56','学科4'),(45,'2021-05-09 07:46:56','学科5'),(46,'2021-05-09 07:46:56','学科6');
-/*!40000 ALTER TABLE `xueke` ENABLE KEYS */;
-UNLOCK TABLES;
-
+-- Dumping data for table `wodebiji` -- 说明接下来是向 wodebiji 表中插入数据
--
--- Table structure for table `yonghu`
--
-
-DROP TABLE IF EXISTS `yonghu`;
-/*!40101 SET @saved_cs_client = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `yonghu` (
- `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
- `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
- `yonghuzhanghao` varchar(200) NOT NULL COMMENT '用户账号',
- `mima` varchar(200) NOT NULL COMMENT '密码',
- `yonghuxingming` varchar(200) NOT NULL COMMENT '用户姓名',
- `xingbie` varchar(200) DEFAULT NULL COMMENT '性别',
- `shouji` varchar(200) DEFAULT NULL COMMENT '手机',
- `youxiang` varchar(200) DEFAULT NULL COMMENT '邮箱',
- `touxiang` varchar(200) DEFAULT NULL COMMENT '头像',
- PRIMARY KEY (`id`),
- UNIQUE KEY `yonghuzhanghao` (`yonghuzhanghao`)
-) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8 COMMENT='用户';
-/*!40101 SET character_set_client = @saved_cs_client */;
-
+LOCK TABLES `wodebiji` WRITE; -- 对 wodebiji 表进行写锁定
+/*!40000 ALTER TABLE `wodebiji` DISABLE KEYS */; -- 禁用 wodebiji 表的索引以加快数据插入速度
+INSERT INTO `wodebiji` VALUES
+ (81,'2021-05-09 07:46:56','标题1','内容1','用户账号1'),
+ (82,'2021-05-09 07:46:56','标题2','内容2','用户账号2'),
+ (83,'2021-05-09 07:46:56','标题3','内容3','用户账号3'),
+ (84,'2021-05-09 07:46:56','标题4','内容4','用户账号4'),
+ (85,'2021-05-09 07:46:56','标题5','内容5','用户账号5'),
+ (86,'2021-05-09 07:46:56','标题6','内容6','用户账号6'); -- 向 wodebiji 表插入多条记录
+/*!40000 ALTER TABLE `wodebiji` ENABLE KEYS */; -- 重新启用 wodebiji 表的索引
+UNLOCK TABLES; -- 解锁 wodebiji 表
+
--
--- Dumping data for table `yonghu`
+-- Table structure for table `yonghu` -- 说明接下来是定义 yonghu 表的结构
--
-LOCK TABLES `yonghu` WRITE;
-/*!40000 ALTER TABLE `yonghu` DISABLE KEYS */;
-INSERT INTO `yonghu` VALUES (11,'2021-05-09 07:46:56','用户1','123456','用户姓名1','男','13823888881','773890001@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_touxiang1.jpg'),(12,'2021-05-09 07:46:56','用户2','123456','用户姓名2','男','13823888882','773890002@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_touxiang2.jpg'),(13,'2021-05-09 07:46:56','用户3','123456','用户姓名3','男','13823888883','773890003@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_touxiang3.jpg'),(14,'2021-05-09 07:46:56','用户4','123456','用户姓名4','男','13823888884','773890004@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_touxiang4.jpg'),(15,'2021-05-09 07:46:56','用户5','123456','用户姓名5','男','13823888885','773890005@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_touxiang5.jpg'),(16,'2021-05-09 07:46:56','用户6','123456','用户姓名6','男','13823888886','773890006@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_touxiang6.jpg');
-/*!40000 ALTER TABLE `yonghu` ENABLE KEYS */;
-UNLOCK TABLES;
-
---
--- Table structure for table `zhiyeguihua`
+DROP TABLE IF EXISTS `yonghu`; -- 如果 yonghu 表已存在，就将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `yonghu` ( -- 创建 yonghu 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 id 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 addtime 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号', -- 定义 yonghuzhanghao 字段，类型为 varchar(200)，默认值为 NULL，注释为用户账号
+ `mima` varchar(200) DEFAULT NULL COMMENT '密码', -- 定义 mima 字段，类型为 varchar(200)，默认值为 NULL，注释为密码
+ `xingming` varchar(200) DEFAULT NULL COMMENT '姓名', -- 定义 xingming 字段，类型为 varchar(200)，默认值为 NULL，注释为姓名
+ `xingbie` varchar(200) DEFAULT NULL COMMENT '性别', -- 定义 xingbie 字段，类型为 varchar(200)，默认值为 NULL，注释为性别
+ `nianling` int(11) DEFAULT NULL COMMENT '年龄', -- 定义 nianling 字段，类型为 int(11)，默认值为 NULL，注释为年龄
+ `shouji` varchar(200) DEFAULT NULL COMMENT '手机', -- 定义 shouji 字段，类型为 varchar(200)，默认值为 NULL，注释为手机
+ `youxiang` varchar(200) DEFAULT NULL COMMENT '邮箱', -- 定义 youxiang 字段，类型为 varchar(200)，默认值为 NULL，注释为邮箱
+ `zhaopian` varchar(200) DEFAULT NULL COMMENT '照片', -- 定义 zhaopian 字段，类型为 varchar(200)，默认值为 NULL，注释为照片
+ PRIMARY KEY (`id`) -- 将 id 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8 COMMENT='用户'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 12，字符集为 UTF-8，注释为用户
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
+
+--
+-- Dumping data for table `yonghu` -- 说明接下来是向 yonghu 表中插入数据
+--
+
+LOCK TABLES `yonghu` WRITE; -- 对 yonghu 表进行写锁定
+/*!40000 ALTER TABLE `yonghu` DISABLE KEYS */; -- 禁用 yonghu 表的索引以加快数据插入速度
+INSERT INTO `yonghu` VALUES
+ (1,'用户账号1','密码1','姓名1','男',20,'13800138001','123456@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_zhaopian1.jpg'),
+ (2,'用户账号2','密码2','姓名2','女',22,'13900139001','234567@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_zhaopian2.jpg'),
+ (3,'用户账号3','密码3','姓名3','男',25,'13700137001','345678@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_zhaopian3.jpg'),
+ (4,'用户账号4','密码4','姓名4','女',21,'13600136001','456789@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_zhaopian4.jpg'),
+ (5,'用户账号5','密码5','姓名5','男',23,'13500135001','567890@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_zhaopian5.jpg'),
+ (6,'用户账号6','密码6','姓名6','女',24,'13400134001','678901@qq.com','http://localhost:8080/springbootus5uu/upload/yonghu_zhaopian6.jpg'); -- 向 yonghu 表插入多条记录
+/*!40000 ALTER TABLE `yonghu` ENABLE KEYS */; -- 重新启用 yonghu 表的索引
+UNLOCK TABLES; -- 解锁 yonghu 表
+
+--
+-- Table structure for table `yuyuekecheng` -- 说明接下来是定义 yuyuekecheng 表的结构
+--
+
+DROP TABLE IF EXISTS `yuyuekecheng`; -- 如果 yuyuekecheng 表已存在，就将其删除
+/*!40101 SET @saved_cs_client = @@character_set_client */; -- 保存当前的字符集客户端设置
+/*!40101 SET character_set_client = utf8 */; -- 设置字符集客户端为 UTF-8
+CREATE TABLE `yuyuekecheng` ( -- 创建 yuyuekecheng 表
+ `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', -- 定义 id 字段，类型为 bigint(20)，非空且自动递增，注释为主键
+ `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', -- 定义 addtime 字段，类型为 timestamp，非空，默认值为当前时间戳，注释为创建时间
+ `kechengmingcheng` varchar(200) DEFAULT NULL COMMENT '课程名称', -- 定义 kechengmingcheng 字段，类型为 varchar(200)，默认值为 NULL，注释为课程名称
+ `leixing` varchar(200) DEFAULT NULL COMMENT '类型', -- 定义 leixing 字段，类型为 varchar(200)，默认值为 NULL，注释为类型
+ `xueke` varchar(200) DEFAULT NULL COMMENT '学科', -- 定义 xueke 字段，类型为 varchar(200)，默认值为 NULL，注释为学科
+ `feiyong` varchar(200) DEFAULT NULL COMMENT '费用', -- 定义 feiyong 字段，类型为 varchar(200)，默认值为 NULL，注释为费用
+ `yonghuzhanghao` varchar(200) DEFAULT NULL COMMENT '用户账号', -- 定义 yonghuzhanghao 字段，类型为 varchar(200)，默认值为 NULL，注释为用户账号
+ `yuyueshijian` datetime DEFAULT NULL COMMENT '预约时间', -- 定义 yuyueshijian 字段，类型为 datetime，默认值为 NULL，注释为预约时间
+ `sfsh` varchar(200) DEFAULT '否' COMMENT '是否审核', -- 定义 sfsh 字段，类型为 varchar(200)，默认值为 '否'，注释为是否审核
+ `shhf` longtext COMMENT '审核回复', -- 定义 shhf 字段，类型为 longtext，注释为审核回复
+ PRIMARY KEY (`id`) -- 将 id 字段设为主键
+) ENGINE=InnoDB AUTO_INCREMENT=37 DEFAULT CHARSET=utf8 COMMENT='预约课程'; -- 设置表的存储引擎为 InnoDB，自动递增起始值为 37，字符集为 UTF-8，注释为预约课程
+/*!40101 SET character_set_client = @saved_cs_client */; -- 恢复之前保存的字符集客户端设置
+
+--
+-- Dumping data for table `yuyuekecheng` -- 说明接下来是向 yuyuekecheng 表中插入数据
+--
+
+LOCK TABLES `yuyuekecheng` WRITE; -- 对 yuyuekecheng 表进行写锁定
+/*!40000 ALTER TABLE `yuyuekecheng` DISABLE KEYS */; -- 禁用 yuyuekecheng 表的索引以加快数据插入速度
+INSERT INTO `yuyuekecheng` VALUES
+ (31,'2021-05-09 07:46:56','课程名称1','类型1','学科1','费用1','用户账号1','2021-05-09 15:46:56','是',''),
+ (32,'2021-05-09 07:46:56','课程名称2','类型2','学科2','费用2','用户账号2','2021-05-09 15:46:56','是',''),
+ (33,'2021-05-09 07:46:56','课程名称3','类型3','学科3','费用3','用户账号3','2021-05-09 15:46:56','是',''),
+ (34,'2021-05-09 07:46:56','课程名称4','类型4','学科4','费用4','用户账号4','2021-05-09 15:46:56','是',''),
+ (35,'2021-05-09 07:46:56','课程名称5','类型5','学科5','费用5','用户账号5','2021-05-09 15:46:56','是',''),
+ (36,'2021-05-09 07:46:56','课程名称6','类型6','学科6','费用6','用户账号6','2021-05-09 15:46:56','是',''); -- 向 yuyuekecheng 表插入多条记录
+/*!40000 ALTER TABLE `yuyuekecheng` ENABLE KEYS */; -- 重新启用 yuyuekecheng 表的索引
+UNLOCK TABLES; -- 解锁 yuyuekecheng 表
--
DROP TABLE IF EXISTS `zhiyeguihua`;
diff --git a/mvnw b/mvnw
index 21d3ee8..3374c5e 100644
--- a/mvnw
+++ b/mvnw
@@ -1,4 +1,6 @@
#!/bin/sh
+# 声明这是一个 shell 脚本，指定使用 /bin/sh 作为解释器
+
# ----------------------------------------------------------------------------
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
@@ -17,6 +19,7 @@
# specific language governing permissions and limitations
# under the License.
# ----------------------------------------------------------------------------
+# 以上是关于该脚本遵循的 Apache 许可证相关信息，说明版权归属、使用条件等
# ----------------------------------------------------------------------------
# Maven2 Start Up Batch script
@@ -33,278 +36,1122 @@
# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
# MAVEN_SKIP_RC - flag to disable loading of mavenrc files
# ----------------------------------------------------------------------------
+# 以上是关于该脚本的描述，说明这是 Maven2 的启动脚本，以及所需和可选的环境变量
if [ -z "$MAVEN_SKIP_RC" ] ; then
-
+ # 如果 MAVEN_SKIP_RC 环境变量为空（即未设置）
if [ -f /etc/mavenrc ] ; then
+ # 如果 /etc/mavenrc 文件存在
. /etc/mavenrc
+ # 执行 /etc/mavenrc 文件中的命令（通常用于设置环境变量等）
fi
if [ -f "$HOME/.mavenrc" ] ; then
+ # 如果用户主目录下的 .mavenrc 文件存在
. "$HOME/.mavenrc"
+ # 执行该文件中的命令
fi
-
fi
# OS specific support. $var _must_ be set to either true or false.
cygwin=false;
+# 定义变量 cygwin 并初始化为 false，表示是否是 Cygwin 系统
darwin=false;
+# 定义变量 darwin 并初始化为 false，表示是否是 Darwin（Mac OS）系统
mingw=false
+# 定义变量 mingw 并初始化为 false，表示是否是 MinGW 系统
case "`uname`" in
+ # 根据系统的 uname 命令输出进行匹配
CYGWIN*) cygwin=true ;;
+ # 如果 uname 输出以 CYGWIN 开头，设置 cygwin 为 true
MINGW*) mingw=true;;
+ # 如果 uname 输出以 MINGW 开头，设置 mingw 为 true
Darwin*) darwin=true
+ # 如果是 Darwin 系统，设置 darwin 为 true
# Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
# See https://developer.apple.com/library/mac/qa/qa1170/_index.html
if [ -z "$JAVA_HOME" ]; then
+ # 如果 JAVA_HOME 环境变量未设置
if [ -x "/usr/libexec/java_home" ]; then
+ # 如果 /usr/libexec/java_home 可执行
export JAVA_HOME="`/usr/libexec/java_home`"
+ # 使用 /usr/libexec/java_home 命令获取 JDK 路径并设置 JAVA_HOME 环境变量
else
export JAVA_HOME="/Library/Java/Home"
+ # 否则，设置 JAVA_HOME 为默认的 Mac OS 上 Java 安装路径
fi
fi
;;
esac
if [ -z "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量未设置
if [ -r /etc/gentoo-release ] ; then
+ # 如果 /etc/gentoo-release 文件可读（通常在 Gentoo 系统上）
JAVA_HOME=`java-config --jre-home`
+ # 使用 java-config --jre-home 命令获取 JDK 路径并设置 JAVA_HOME
fi
fi
if [ -z "$M2_HOME" ] ; then
+ # 如果 M2_HOME 环境变量未设置
## resolve links - $0 may be a link to maven's home
PRG="$0"
+ # 将当前脚本的路径赋值给 PRG 变量
# need this for relative symlinks
while [ -h "$PRG" ] ; do
+ # 当 PRG 是一个符号链接时
ls=`ls -ld "$PRG"`
+ # 使用 ls -ld 命令获取符号链接的详细信息并赋值给 ls 变量
link=`expr "$ls" : '.*-> \(.*\)$'`
+ # 使用 expr 命令从 ls 变量中提取符号链接指向的目标路径并赋值给 link 变量
if expr "$link" : '/.*' > /dev/null; then
+ # 如果 link 是一个绝对路径
PRG="$link"
+ # 将 PRG 设置为链接的目标路径
else
PRG="`dirname "$PRG"`/$link"
+ # 否则，根据当前 PRG 的目录和链接目标计算出完整路径并赋值给 PRG
fi
done
saveddir=`pwd`
+ # 保存当前工作目录到 saveddir 变量
M2_HOME=`dirname "$PRG"`/..
+ # 根据 PRG 计算出 Maven 安装目录的路径并赋值给 M2_HOME
# make it fully qualified
M2_HOME=`cd "$M2_HOME" && pwd`
+ # 进入 M2_HOME 目录并获取其绝对路径，更新 M2_HOME
cd "$saveddir"
+ # 切换回之前保存的工作目录
+
# echo Using m2 at $M2_HOME
+ # （注释掉的行，原本可能用于输出使用的 M2_HOME 路径）
fi
# For Cygwin, ensure paths are in UNIX format before anything is touched
if $cygwin ; then
+ # 如果是 Cygwin 系统
[ -n "$M2_HOME" ] &&
M2_HOME=`cygpath --unix "$M2_HOME"`
+ # 如果 M2_HOME 不为空，将其转换为 UNIX 格式路径
[ -n "$JAVA_HOME" ] &&
JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+ # 如果 JAVA_HOME 不为空，将其转换为 UNIX 格式路径
[ -n "$CLASSPATH" ] &&
CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+ # 如果 CLASSPATH 不为空，将其转换为 UNIX 格式路径
fi
# For Mingw, ensure paths are in UNIX format before anything is touched
if $mingw ; then
+ # 如果是 MinGW 系统
[ -n "$M2_HOME" ] &&
M2_HOME="`(cd "$M2_HOME"; pwd)`"
+ # 如果 M2_HOME 不为空，进入该目录并获取其绝对路径（转换为 UNIX 格式）
[ -n "$JAVA_HOME" ] &&
JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+ # 如果 JAVA_HOME 不为空，进入该目录并获取其绝对路径（转换为 UNIX 格式）
fi
if [ -z "$JAVA_HOME" ]; then
+ # 如果 JAVA_HOME 环境变量未设置
javaExecutable="`which javac`"
+ # 使用 which 命令查找 javac 可执行文件的路径并赋值给 javaExecutable 变量
if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+ # 如果找到了 javac 可执行文件且不是 "no"（即有效路径）
# readlink(1) is not available as standard on Solaris 10.
readLink=`which readlink`
+ # 使用 which 命令查找 readlink 命令的路径并赋值给 readLink 变量
if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+ # 如果找到了 readlink 命令且不是 "no"（即有效路径）
if $darwin ; then
+ # 如果是 Darwin 系统
javaHome="`dirname \"$javaExecutable\"`"
+ # 获取 javac 可执行文件所在目录并赋值给 javaHome 变量
javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
+ # 进入 javaHome 目录并获取其绝对路径，再加上 javac 文件名，更新 javaExecutable
else
javaExecutable="`readlink -f \"$javaExecutable\"`"
+ # 否则（非 Darwin 系统），使用 readlink -f 命令获取 javac 可执行文件的绝对路径并更新 javaExecutable
fi
javaHome="`dirname \"$javaExecutable\"`"
+ # 获取更新后的 javaExecutable 所在目录并赋值给 javaHome 变量
javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+ # 从 javaHome 变量中提取 bin 目录的上一级目录路径并赋值给 javaHome 变量
JAVA_HOME="$javaHome"
+ # 将计算出的 JDK 路径设置为 JAVA_HOME 环境变量
export JAVA_HOME
+ # 导出 JAVA_HOME 环境变量
fi
fi
fi
if [ -z "$JAVACMD" ] ; then
+ # 如果 JAVACMD 变量未设置
if [ -n "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量不为空
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
- # IBM's JDK on AIX uses strange locations for the executables
+ # 如果 JAVA_HOME/jre/sh/java 可执行（IBM 的 JDK 在 AIX 上的特殊路径）
JAVACMD="$JAVA_HOME/jre/sh/java"
+ # 设置 JAVACMD 为该路径
else
JAVACMD="$JAVA_HOME/bin/java"
+ # 否则，设置 JAVACMD 为标准的 JAVA_HOME/bin/java 路径
fi
else
JAVACMD="`which java`"
+ # 如果 JAVA_HOME 未设置，使用 which 命令查找 java 可执行文件的路径并设置为 JAVACMD
fi
fi
if [ ! -x "$JAVACMD" ] ; then
+ # 如果 JAVACMD 不是可执行文件
echo "Error: JAVA_HOME is not defined correctly." >&2
+ # 向标准错误输出流输出错误信息，提示 JAVA_HOME 定义不正确
echo " We cannot execute $JAVACMD" >&2
+ # 向标准错误输出流输出无法执行 JAVACMD 的信息
exit 1
+ # 以错误状态码 1 退出脚本
fi
if [ -z "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量未设置
echo "Warning: JAVA_HOME environment variable is not set."
+ # 输出警告信息，提示 JAVA_HOME 环境变量未设置
fi
CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+# 设置 CLASSWORLDS_LAUNCHER 变量为指定的类名，用于启动类加载器
# traverses directory structure from process work directory to filesystem root
# first directory with .mvn subdirectory is considered project base directory
find_maven_basedir() {
+ # 定义函数 find_maven_basedir，用于查找 Maven 项目的基础目录
if [ -z "$1" ]
then
+ # 如果函数的第一个参数为空
echo "Path not specified to find_maven_basedir"
+ # 输出错误信息，提示未指定路径
return 1
+ # 以错误状态码 1 返回
fi
basedir="$1"
+ # 将函数的第一个参数赋值给 basedir 变量
wdir="$1"
+ # 将函数的第一个参数赋值给 wdir 变量
while [ "$wdir" != '/' ] ; do
+ # 当 wdir 不是根目录时
if [ -d "$wdir"/.mvn ] ; then
+ # 如果 wdir 目录下存在 .mvn 子目录
basedir=$wdir
+ # 将 basedir 设置为 wdir
break
+ # 跳出循环
fi
# workaround for JBEAP-8937 (on Solaris 10/Sparc)
if [ -d "${wdir}" ]; then
wdir=`cd "$wdir/.."; pwd`
+ # 如果 wdir 是一个目录，进入上一级目录并获取其路径，更新 wdir
fi
# end of workaround
done
echo "${basedir}"
+ # 输出找到的 Maven 项目基础目录路径
}
# concatenates all lines of a file
concat_lines() {
+ # 定义函数 concat_lines，用于连接文件的所有行
+
if [ -f "$1" ]; then
+ # 如果函数的第一个参数是一个文件
echo "$(tr -s '\n' ' ' < "$1")"
+ # 使用 tr 命令将文件中的换行符替换为空格，并输出连接后的内容
fi
}
BASE_DIR=`find_maven_basedir "$(pwd)"`
+# 调用 find_maven_basedir 函数，传入当前工作目录路径，获取 Maven 项目基础目录并赋值给 BASE_DIR 变量
if [ -z "$BASE_DIR" ]; then
+ # 如果 BASE_DIR 为空
exit 1;
+ # 以错误状态码 1 退出脚本
fi
##########################################################################################
# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
# This allows using the maven wrapper in projects that prohibit checking in binary data.
##########################################################################################
+# 以下是关于自动从 Maven 中央仓库下载 maven-wrapper.jar 的扩展部分说明
+
if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then
+ # 如果在 Maven 项目基础目录下的 .mvn/wrapper 目录中存在可读取的 maven-wrapper.jar 文件
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Found .mvn/wrapper/maven-wrapper.jar"
+ # 输出找到 maven-wrapper.jar 文件的信息
+ fi
+else
+ # 如果不存在 maven-wrapper.jar 文件
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
+ # 输出未找到文件并开始下载的信息
+ fi
+ if [ -n "$MVNW_REPOURL" ]; then
+ # 如果 MVNW_REPOURL 环境变量不为空
+ jarUrl="$MVNW_REPOURL/io/takari/maven-wrapper/0.5.5/maven-wrapper-0.5.5.jar"
+ # 设置 jarUrl 为指定仓库路径下的 maven-wrapper.jar 文件路径
+ else
+ jarUrl="https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.5/maven-wrapper-0.5.5.jar"
+ # 否则，设置 jarUrl 为 Maven 中央仓库的 maven-wrapper.jar 文件路径
+ fi
+ while IFS="=" read key value; do
+ # 按行读取文件内容，以 = 分割为键值对
+ case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
+ # 如果键为 wrapperUrl，将值赋给 jarUrl 并跳出循环
+ esac
+ done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
+ # 从 .mvn/wrapper/maven-wrapper.properties 文件中读取内容进行处理
+
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Downloading from: $jarUrl"
+ # 输出从哪个路径下载 maven-wrapper.jar 文件的信息
+ fi
+ wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
+ # 设置 wrapperJarPath 为要下载到的本地路径
+
+ if $cygwin; then
+ # 如果是 Cygwin 系统
+ wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
+ # 将 wrapperJarPath 转换为 Windows 格式路径
+ fi
+
+ if command -v wget > /dev/null; then
+ # 如果 wget 命令存在
if [ "$MVNW_VERBOSE" = true ]; then
- echo "Found .mvn/wrapper/maven-wrapper.jar"
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Found wget ... using wget"
+ # 输出找到 wget 命令并将使用它下载的信息
+ fi
+ if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+ # 如果 MVNW_USERNAME 或 MVNW_PASSWORD 环境变量为空
+ wget "$jarUrl" -O "$wrapperJarPath"
+ # 使用 wget 命令从 jarUrl 下载文件并保存到 wrapperJarPath
+ else
+ wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath"
+ # 如果有用户名和密码，使用它们进行认证后下载文件
+ fi
+ elif command -v curl > /dev/null; then
+ # 如果 wget 不可用但 curl 命令存在
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Found curl ... using curl"
+ # 输出找到 curl 命令并将使用它下载的信息
+ fi
+ if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+ # 如果 MVNW_USERNAME 或 MVNW_PASSWORD 环境变量为空
+ curl -o "$wrapperJarPath" "$jarUrl" -f
+ # 使用 curl 命令从 jarUrl 下载文件并保存到 wrapperJarPath，-f 表示失败时不显示进度条
+ else
+ curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
+ # 如果有用户名和密码，使用它们进行认证后下载文件
+ fi
+ else
+ # 如果 wget 和 curl 都不可用
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Falling back to using Java to download"
+ # 输出将使用 Java 进行下载的信息
+ fi
+ javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
+ # 设置 javaClass 为 MavenWrapperDownloader.java 文件的路径
+
+ # For Cygwin, switch paths to Windows format before running javac
+ if $cygwin; then
+ # 如果是 Cygwin 系统
+ javaClass=`cygpath --path --windows "$javaClass"`
+ # 将 javaClass 路径转换为 Windows 格式
+ fi
+
+ if [ -e "$javaClass" ]; then
+ # 如果 MavenWrapperDownloader.java 文件存在
+ if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+ # 如果 MavenWrapperDownloader.class 文件不存在
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo " - Compiling MavenWrapperDownloader.java ..."
+ # 输出正在编译 MavenWrapperDownloader.java 文件的信息
+ fi
+ # Compiling the Java class
+ ("$JAVA_HOME/bin/javac" "$javaClass")
+ # 使用 javac 命令编译 MavenWrapperDownloader.java 文件
+ fi
+ if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+ # 如果编译后的 MavenWrapperDownloader.class 文件存在
+ # Running the downloader
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo " - Running MavenWrapperDownloader.java ..."
+ # 输出正在运行 MavenWrapperDownloader.java 程序的信息
+ fi
+ ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
+ # 使用 java 命令运行编译后的程序进行下载，传入项目基础目录作为参数
+ fi
+ fi
+ fi
+ fi
+ ##########################################################################################
+ # End of extension
+ ##########################################################################################
+ # 自动下载 maven-wrapper.jar 扩展部分结束
+
+ export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+ # 导出 MAVEN_PROJECTBASEDIR 环境变量，如果 MAVEN_BASEDIR 未设置，则使用 BASE_DIR 的值
+
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo $MAVEN_PROJECTBASEDIR
+ # 输出 MAVEN_PROJECTBASEDIR 的值
+ fi
+
+ MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+ # 将 MAVEN_PROJECTBASEDIR/.mvn/jvm.config 文件中的内容连接起来，并追加到 MAVEN_OPTS 变量后面
+
+ # For Cygwin, switch paths to Windows format before running java
+ if $cygwin; then
+ # 如果是 Cygwin 系统
+ [ -n "$M2_HOME" ] &&
+ M2_HOME=`cygpath --path --windows "$M2_HOME"`
+ # 如果 M2_HOME 不为空，将其转换为 Windows 格式路径
+ [ -n "$JAVA_HOME" ] &&
+ JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
+ # 如果 JAVA_HOME 不为空，将其转换为 Windows 格式路径
+ [ -n "$CLASSPATH" ] &&
+ CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
+ # 如果 CLASSPATH 不为空，将其转换为 Windows 格式路径
+ [ -n "$MAVEN_PROJECTBASEDIR" ] &&
+ MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+ # 如果 MAVEN_PROJECTBASEDIR 不为空，将其转换为 Windows 格式路径
+ fi
+
+ # Provide a "standardized" way to retrieve the CLI args that will
+ # work with both Windows and non-Windows executions.
+ MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
+ # 将 MAVEN_CONFIG 变量的值和脚本的所有参数连接起来，赋值给 MAVEN_CMD_LINE_ARGS 变量
+ export MAVEN_CMD_LINE_ARGS
+ # 导出 MAVEN_CMD_LINE_ARGS 环境变量
+
+ WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+ # 设置 WRAPPER_LAUNCHER 变量为 Maven 包装器的主类名
+
+ exec "$JAVACMD" \
+ # 执行 Java 命令
+ $MAVEN_OPTS \
+ # 传递 MAVEN_OPTS 变量中的参数给 Java 虚拟机
+ -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+ # 设置 Java 类路径为 maven-wrapper.jar 文件所在路径
+ "-Dmaven.home=${M2_HOME}" "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+ # 设置系统属性 maven.home 和 maven.multiModuleProjectDirectory
+ ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
+ # 执行 WRAPPER_LAUNCHER 类，并传递 MAVEN_CONFIG 和脚本的所有参数
+ #!/bin/sh
+ # 声明这是一个 shell 脚本，指定使用 /bin/sh 作为解释器
+
+ # ----------------------------------------------------------------------------
+ # Licensed to the Apache Software Foundation (ASF) under one
+ # or more contributor license agreements. See the NOTICE file
+ # distributed with this work for additional information
+ # regarding copyright ownership. The ASF licenses this file
+ # to you under the Apache License, Version 2.0 (the
+ # "License"); you may not use this file except in compliance
+ # with the License. You may obtain a copy of the License at
+ #
+ # https://www.apache.org/licenses/LICENSE-2.0
+ #
+ # Unless required by applicable law or agreed to in writing,
+ # software distributed under the License is distributed on an
+ # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ # KIND, either express or implied. See the License for the
+ # specific language governing permissions and limitations
+ # under the License.
+ # ----------------------------------------------------------------------------
+ # 以上是关于该脚本遵循的 Apache 许可证相关信息，说明版权归属、使用条件等
+
+ # ----------------------------------------------------------------------------
+ # Maven2 Start Up Batch script
+ #
+ # Required ENV vars:
+ # ------------------
+ # JAVA_HOME - location of a JDK home dir
+ #
+ # Optional ENV vars
+ # -----------------
+ # M2_HOME - location of maven2's installed home dir
+ # MAVEN_OPTS - parameters passed to the Java VM when running Maven
+ # e.g. to debug Maven itself, use
+ # set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+ # MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+ # ----------------------------------------------------------------------------
+ # 以上是关于该脚本的描述，说明这是 Maven2 的启动脚本，以及所需和可选的环境变量
+
+ if [ -z "$MAVEN_SKIP_RC" ] ; then
+ # 如果 MAVEN_SKIP_RC 环境变量为空（即未设置）
+ if [ -f /etc/mavenrc ] ; then
+ # 如果 /etc/mavenrc 文件存在
+ . /etc/mavenrc
+ # 执行 /etc/mavenrc 文件中的命令（通常用于设置环境变量等，以配置 Maven 相关运行参数）
+ fi
+
+ if [ -f "$HOME/.mavenrc" ] ; then
+ # 如果用户主目录下的 .mavenrc 文件存在
+ . "$HOME/.mavenrc"
+ # 执行该文件中的命令，进一步配置 Maven 运行相关的环境或参数
+ fi
+ fi
+
+ # OS specific support. $var _must_ be set to either true or false.
+ cygwin=false;
+ # 定义变量 cygwin 并初始化为 false，表示当前系统是否是 Cygwin 系统（Cygwin 是一个在 Windows 上模拟 Unix 环境的软件）
+ darwin=false;
+ # 定义变量 darwin 并初始化为 false，表示当前系统是否是 Darwin（Mac OS）系统
+ mingw=false
+ # 定义变量 mingw 并初始化为 false，表示当前系统是否是 MinGW 系统（MinGW 是在 Windows 上提供一套开源的开发工具集）
+ case "`uname`" in
+ # 根据系统的 uname 命令输出（获取系统名称）进行匹配
+ CYGWIN*) cygwin=true ;;
+ # 如果 uname 输出以 CYGWIN 开头，设置 cygwin 为 true，表明当前系统是 Cygwin 环境
+ MINGW*) mingw=true;;
+ # 如果 uname 输出以 MINGW 开头，设置 mingw 为 true，表明当前系统是 MinGW 环境
+ Darwin*) darwin=true
+ # 如果是 Darwin 系统，设置 darwin 为 true
+ # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+ # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+ if [ -z "$JAVA_HOME" ]; then
+ # 如果 JAVA_HOME 环境变量未设置
+ if [ -x "/usr/libexec/java_home" ]; then
+ # 如果 /usr/libexec/java_home 可执行（该命令可用于获取系统上可用的 JDK 路径）
+ export JAVA_HOME="`/usr/libexec/java_home`"
+ # 使用 /usr/libexec/java_home 命令获取 JDK 路径并设置 JAVA_HOME 环境变量
+ else
+ export JAVA_HOME="/Library/Java/Home"
+ # 否则，设置 JAVA_HOME 为默认的 Mac OS 上 Java 安装路径（常见的默认路径）
+ fi
+ fi
+ ;;
+ esac
+
+ if [ -z "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量未设置
+ if [ -r /etc/gentoo-release ] ; then
+ # 如果 /etc/gentoo-release 文件可读（在 Gentoo Linux 系统中，该文件标识系统版本等信息）
+ JAVA_HOME=`java-config --jre-home`
+ # 使用 java-config --jre-home 命令获取 JDK 路径并设置 JAVA_HOME（适用于 Gentoo 系统获取 JDK 路径的方式）
+ fi
+ fi
+
+ if [ -z "$M2_HOME" ] ; then
+ # 如果 M2_HOME 环境变量未设置
+ ## resolve links - $0 may be a link to maven's home
+ PRG="$0"
+ # 将当前脚本的路径赋值给 PRG 变量，$0 在 shell 中表示脚本本身的名称或路径
+ # need this for relative symlinks
+ while [ -h "$PRG" ] ; do
+ # 当 PRG 是一个符号链接时（-h 用于判断是否为符号链接）
+ ls=`ls -ld "$PRG"`
+ # 使用 ls -ld 命令获取符号链接的详细信息并赋值给 ls 变量，包括链接指向的目标等信息
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ # 使用 expr 命令从 ls 变量中提取符号链接指向的目标路径并赋值给 link 变量，通过正则表达式匹配提取链接目标
+ if expr "$link" : '/.*' > /dev/null; then
+ # 如果 link 是一个绝对路径（通过判断路径是否以 / 开头来确定是否为绝对路径）
+ PRG="$link"
+ # 将 PRG 设置为链接的目标路径，更新 PRG 为实际的路径
+ else
+ PRG="`dirname "$PRG"`/$link"
+ # 否则，根据当前 PRG 的目录和链接目标计算出完整路径并赋值给 PRG，拼接得到实际路径
+ fi
+ done
+
+ saveddir=`pwd`
+ # 保存当前工作目录到 saveddir 变量，pwd 命令用于获取当前工作目录路径
+ M2_HOME=`dirname "$PRG"`/..
+ # 根据 PRG 计算出 Maven 安装目录的路径并赋值给 M2_HOME，取 PRG 的目录的上一级目录作为 Maven 安装目录
+ # make it fully qualified
+ M2_HOME=`cd "$M2_HOME" && pwd`
+ # 进入 M2_HOME 目录并获取其绝对路径，cd 命令进入目录，pwd 命令获取当前目录路径，更新 M2_HOME 为绝对路径
+ cd "$saveddir"
+ # 切换回之前保存的工作目录，恢复之前的工作目录状态
+ # echo Using m2 at $M2_HOME
+ # （注释掉的行，原本可能用于输出使用的 M2_HOME 路径，调试或信息展示用途）
+ fi
+
+ # For Cygwin, ensure paths are in UNIX format before anything is touched
+ if $cygwin ; then
+ # 如果是 Cygwin 系统
+ [ -n "$M2_HOME" ] &&
+ M2_HOME=`cygpath --unix "$M2_HOME"`
+ # 如果 M2_HOME 不为空（-n 判断变量是否为空字符串），将其转换为 UNIX 格式路径，cygpath 用于转换 Cygwin 路径格式
+ [ -n "$JAVA_HOME" ] &&
+ JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+ # 如果 JAVA_HOME 不为空，将其转换为 UNIX 格式路径
+ [ -n "$CLASSPATH" ] &&
+ CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+ # 如果 CLASSPATH 不为空，将其转换为 UNIX 格式路径，确保路径格式符合 Cygwin 下的 UNIX 环境要求
+ fi
+
+ # For Mingw, ensure paths are in UNIX format before anything is touched
+ if $mingw ; then
+ # 如果是 MinGW 系统
+ [ -n "$M2_HOME" ] &&
+ M2_HOME="`(cd "$M2_HOME"; pwd)`"
+ # 如果 M2_HOME 不为空，进入该目录并获取其绝对路径（转换为 UNIX 格式），通过 cd 和 pwd 命令组合实现
+ [ -n "$JAVA_HOME" ] &&
+ JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+ # 如果 JAVA_HOME 不为空，进入该目录并获取其绝对路径（转换为 UNIX 格式）
+ fi
+
+ if [ -z "$JAVA_HOME" ]; then
+ # 如果 JAVA_HOME 环境变量未设置
+ javaExecutable="`which javac`"
+ # 使用 which 命令查找 javac 可执行文件的路径并赋值给 javaExecutable 变量，which 用于在系统路径中查找命令的可执行文件位置
+ if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+ # 如果找到了 javac 可执行文件且不是 "no"（即有效路径，排除 which 未找到时输出的错误标识）
+ # readlink(1) is not available as standard on Solaris 10.
+ readLink=`which readlink`
+ # 使用 which 命令查找 readlink 命令的路径并赋值给 readLink 变量，readlink 用于获取符号链接指向的实际路径
+ if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+ # 如果找到了 readlink 命令且不是 "no"（即有效路径）
+ if $darwin ; then
+ # 如果是 Darwin 系统
+ javaHome="`dirname \"$javaExecutable\"`"
+ # 获取 javac 可执行文件所在目录并赋值给 javaHome 变量，dirname 用于获取路径的目录部分
+ javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
+ # 进入 javaHome 目录并获取其绝对路径（-P 选项用于获取物理路径，不包含符号链接），再加上 javac 文件名，更新 javaExecutable 为绝对路径的 javac 可执行文件
+ else
+ javaExecutable="`readlink -f \"$javaExecutable\"`"
+ # 否则（非 Darwin 系统），使用 readlink -f 命令获取 javac 可执行文件的绝对路径并更新 javaExecutable，-f 选项用于获取符号链接的最终目标路径
+ fi
+ javaHome="`dirname \"$javaExecutable\"`"
+ # 获取更新后的 javaExecutable 所在目录并赋值给 javaHome 变量
+ javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+ # 从 javaHome 变量中提取 bin 目录的上一级目录路径并赋值给 javaHome 变量，通过正则表达式匹配提取路径部分
+ JAVA_HOME="$javaHome"
+ # 将计算出的 JDK 路径设置为 JAVA_HOME 环境变量
+ export JAVA_HOME
+ # 导出 JAVA_HOME 环境变量，使其在后续的子进程中也能使用
+ fi
+ fi
+ fi
+
+ if [ -z "$JAVACMD" ] ; then
+ # 如果 JAVACMD 变量未设置
+ if [ -n "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量不为空
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # 如果 JAVA_HOME/jre/sh/java 可执行（IBM 的 JDK 在 AIX 上的特殊路径下的 java 可执行文件）
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ # 设置 JAVACMD 为该路径，指定用于运行 Java 程序的命令路径
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ # 否则，设置 JAVACMD 为标准的 JAVA_HOME/bin/java 路径，这是常见的 Java 可执行文件路径
+ fi
+ else
+ JAVACMD="`which java`"
+ # 如果 JAVA_HOME 未设置，使用 which 命令查找 java 可执行文件的路径并设置为 JAVACMD，在系统路径中查找默认的 java 可执行文件
+ fi
+ fi
+
+ if [ ! -x "$JAVACMD" ] ; then
+ # 如果 JAVACMD 不是可执行文件（-x 判断文件是否可执行）
+ echo "Error: JAVA_HOME is not defined correctly." >&2
+ # 向标准错误输出流输出错误信息，提示 JAVA_HOME 定义不正确，>&2 表示输出到标准错误流
+ echo " We cannot execute $JAVACMD" >&2
+ # 向标准错误输出流输出无法执行 JAVACMD 的信息
+ exit 1
+ # 以错误状态码 1 退出脚本，表示脚本执行出现错误
+ fi
+
+ if [ -z "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量未设置
+ echo "Warning: JAVA_HOME environment variable is not set."
+ # 输出警告信息，提示 JAVA_HOME 环境变量未设置，可能会影响程序的正确运行
+ fi
+
+ CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+ # 设置 CLASSWORLDS_LAUNCHER 变量为指定的类名，用于指定使用 org.codehaus.plexus.classworlds.launcher.Launcher 类来启动类加载器，这是 Maven 中用于管理类加载的一种机制
+
+ # traverses directory structure from process work directory to filesystem root
+ # first directory with .mvn subdirectory is considered project base directory
+ find_maven_basedir() {
+ # 定义函数 find_maven_basedir，用于查找 Maven 项目的基础目录
+ # 函数从当前进程的工作目录开始，向上遍历目录结构直到文件系统根目录，找到第一个包含.mvn 子目录的目录作为项目基础目录
+
+ if [ -z "$1" ]
+ then
+ # 如果函数的第一个参数为空（$1 表示函数的第一个参数）
+ echo "Path not specified to find_maven_basedir"
+ # 输出错误信息，提示未指定路径给 find_maven_basedir 函数
+ return 1
+ # 以错误状态码 1 返回，表示函数执行失败
+ fi
+
+ basedir="$1"
+ # 将函数的第一个参数赋值给 basedir 变量，作为起始查找的目录
+ wdir="$1"
+ # 将函数的第一个参数赋值给 wdir 变量，用于在循环中逐步向上遍历目录
+ while [ "$wdir" != '/' ] ; do
+ # 当 wdir 不是根目录时（循环条件，直到遍历到根目录为止）
+ if [ -d "$wdir"/.mvn ] ; then
+ # 如果 wdir 目录下存在 .mvn 子目录（-d 判断是否为目录）
+ basedir=$wdir
+ # 将 basedir 设置为 wdir，即找到了包含.mvn 子目录的目录，作为项目基础目录
+ break
+ # 跳出循环，不再继续向上遍历
+ fi
+ # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+ if [ -d "${wdir}" ]; then
+ wdir=`cd "$wdir/.."; pwd`
+ # 如果 wdir 是一个目录，进入上一级目录并获取其路径，更新 wdir 为上一级目录路径，这是一个针对 Solaris 10/Sparc 系统的特定处理（解决某些问题的变通方法）
+ fi
+ # end of workaround
+ done
+ echo "${basedir}"
+ # 输出找到的 Maven 项目基础目录路径
+ }
+
+ # concatenates all lines of a file
+ concat_lines() {
+ # 定义函数 concat_lines，用于将文件的所有行连接成一行字符串
+
+ if [ -f "$1" ]; then
+ # 如果函数的第一个参数是一个文件（-f 判断是否为文件）
+ echo "$(tr -s '\n' ' ' < "$1")"
+ # 使用 tr 命令将文件中的换行符 '\n' 替换为空格 ' '，-s 选项用于压缩连续的多个换行符为一个空格，< "$1" 表示从文件中读取内容，然后输出连接后的内容
+ fi
+ }
+
+ BASE_DIR=`find_maven_basedir "$(pwd)"`
+ # 调用 find_maven_basedir 函数，传入当前工作目录路径（通过 pwd 命令获取），获取 Maven 项目基础目录并赋值给 BASE_DIR 变量
+ if [ -z "$BASE_DIR" ]; then
+ # 如果 BASE_DIR 为空（即未找到合适的项目基础目录）
+ exit 1;
+ # 以错误状态码 1 退出脚本，表示脚本执行失败，因为无法确定 Maven 项目基础目录
+ fi
+
+ ##########################################################################################
+ # Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+ # This allows using the maven
+
+# OS specific support. $var _must_ be set to either true or false.
+cygwin=false;
+# 定义变量 cygwin 并初始化为 false，表示是否是 Cygwin 系统
+darwin=false;
+# 定义变量 darwin 并初始化为 false，表示是否是 Darwin（Mac OS）系统
+mingw=false
+# 定义变量 mingw 并初始化为 false，表示是否是 MinGW 系统
+case "`uname`" in
+ # 根据系统的 uname 命令输出进行匹配
+ CYGWIN*) cygwin=true ;;
+ # 如果 uname 输出以 CYGWIN 开头，设置 cygwin 为 true
+ MINGW*) mingw=true;;
+ # 如果 uname 输出以 MINGW 开头，设置 mingw 为 true
+ Darwin*) darwin=true
+ # 如果是 Darwin 系统，设置 darwin 为 true
+ # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+ # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+ if [ -z "$JAVA_HOME" ]; then
+ # 如果 JAVA_HOME 环境变量未设置
+ if [ -x "/usr/libexec/java_home" ]; then
+ # 如果 /usr/libexec/java_home 可执行
+ export JAVA_HOME="`/usr/libexec/java_home`"
+ # 使用 /usr/libexec/java_home 命令获取 JDK 路径并设置 JAVA_HOME 环境变量
+ else
+ export JAVA_HOME="/Library/Java/Home"
+ # 否则，设置 JAVA_HOME 为默认的 Mac OS 上 Java 安装路径
+ fi
+ fi
+ ;;
+esac
+
+if [ -z "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量未设置
+ if [ -r /etc/gentoo-release ] ; then
+ # 如果 /etc/gentoo-release 文件可读（通常在 Gentoo 系统上）
+ JAVA_HOME=`java-config --jre-home`
+ # 使用 java-config --jre-home 命令获取 JDK 路径并设置 JAVA_HOME
+ fi
+fi
+
+if [ -z "$M2_HOME" ] ; then
+ # 如果 M2_HOME 环境变量未设置
+ ## resolve links - $0 may be a link to maven's home
+ PRG="$0"
+ # 将当前脚本的路径赋值给 PRG 变量
+
+ # need this for relative symlinks
+ while [ -h "$PRG" ] ; do
+ # 当 PRG 是一个符号链接时
+ ls=`ls -ld "$PRG"`
+ # 使用 ls -ld 命令获取符号链接的详细信息并赋值给 ls 变量
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ # 使用 expr 命令从 ls 变量中提取符号链接指向的目标路径并赋值给 link 变量
+ if expr "$link" : '/.*' > /dev/null; then
+ # 如果 link 是一个绝对路径
+ PRG="$link"
+ # 将 PRG 设置为链接的目标路径
+ else
+ PRG="`dirname "$PRG"`/$link"
+ # 否则，根据当前 PRG 的目录和链接目标计算出完整路径并赋值给 PRG
+ fi
+ done
+
+ saveddir=`pwd`
+ # 保存当前工作目录到 saveddir 变量
+
+ M2_HOME=`dirname "$PRG"`/..
+ # 根据 PRG 计算出 Maven 安装目录的路径并赋值给 M2_HOME
+
+ # make it fully qualified
+ M2_HOME=`cd "$M2_HOME" && pwd`
+ # 进入 M2_HOME 目录并获取其绝对路径，更新 M2_HOME
+
+ cd "$saveddir"
+ # 切换回之前保存的工作目录
+
+ # echo Using m2 at $M2_HOME
+ # （注释掉的行，原本可能用于输出使用的 M2_HOME 路径）
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin ; then
+ # 如果是 Cygwin 系统
+ [ -n "$M2_HOME" ] &&
+ M2_HOME=`cygpath --unix "$M2_HOME"`
+ # 如果 M2_HOME 不为空，将其转换为 UNIX 格式路径
+ [ -n "$JAVA_HOME" ] &&
+ JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+ # 如果 JAVA_HOME 不为空，将其转换为 UNIX 格式路径
+ [ -n "$CLASSPATH" ] &&
+ CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+ # 如果 CLASSPATH 不为空，将其转换为 UNIX 格式路径
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw ; then
+ # 如果是 MinGW 系统
+ [ -n "$M2_HOME" ] &&
+ M2_HOME="`(cd "$M2_HOME"; pwd)`"
+ # 如果 M2_HOME 不为空，进入该目录并获取其绝对路径（转换为 UNIX 格式）
+ [ -n "$JAVA_HOME" ] &&
+ JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+ # 如果 JAVA_HOME 不为空，进入该目录并获取其绝对路径（转换为 UNIX 格式）
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+ # 如果 JAVA_HOME 环境变量未设置
+ javaExecutable="`which javac`"
+ # 使用 which 命令查找 javac 可执行文件的路径并赋值给 javaExecutable 变量
+ if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+ # 如果找到了 javac 可执行文件且不是 "no"（即有效路径）
+ # readlink(1) is not available as standard on Solaris 10.
+ readLink=`which readlink`
+ # 使用 which 命令查找 readlink 命令的路径并赋值给 readLink 变量
+ if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+ # 如果找到了 readlink 命令且不是 "no"（即有效路径）
+ if $darwin ; then
+ # 如果是 Darwin 系统
+ javaHome="`dirname \"$javaExecutable\"`"
+ # 获取 javac 可执行文件所在目录并赋值给 javaHome 变量
+ javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
+ # 进入 javaHome 目录并获取其绝对路径，再加上 javac 文件名，更新 javaExecutable
+ else
+ javaExecutable="`readlink -f \"$javaExecutable\"`"
+ # 否则（非 Darwin 系统），使用 readlink -f 命令获取 javac 可执行文件的绝对路径并更新 javaExecutable
+ fi
+ javaHome="`dirname \"$javaExecutable\"`"
+ # 获取更新后的 javaExecutable 所在目录并赋值给 javaHome 变量
+ javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+ # 从 javaHome 变量中提取 bin 目录的上一级目录路径并赋值给 javaHome 变量
+ JAVA_HOME="$javaHome"
+ # 将计算出的 JDK 路径设置为 JAVA_HOME 环境变量
+ export JAVA_HOME
+ # 导出 JAVA_HOME 环境变量
fi
+ fi
+fi
+
+if [ -z "$JAVACMD" ] ; then
+ # 如果 JAVACMD 变量未设置
+ if [ -n "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量不为空
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # 如果 JAVA_HOME/jre/sh/java 可执行（IBM 的 JDK 在 AIX 上的特殊路径）
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ # 设置 JAVACMD 为该路径
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ # 否则，设置 JAVACMD 为标准的 JAVA_HOME/bin/java 路径
+ fi
+ else
+ JAVACMD="`which java`"
+ # 如果 JAVA_HOME 未设置，使用 which 命令查找 java 可执行文件的路径并设置为 JAVACMD
+ fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+ # 如果 JAVACMD 不是可执行文件
+ echo "Error: JAVA_HOME is not defined correctly." >&2
+ # 向标准错误输出流输出错误信息，提示 JAVA_HOME 定义不正确
+ echo " We cannot execute $JAVACMD" >&2
+ # 向标准错误输出流输出无法执行 JAVACMD 的信息
+ exit 1
+ # 以错误状态码 1 退出脚本
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+ # 如果 JAVA_HOME 环境变量未设置
+ echo "Warning: JAVA_HOME environment variable is not set."
+ # 输出警告信息，提示 JAVA_HOME 环境变量未设置
+fi
+
+CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+# 设置 CLASSWORLDS_LAUNCHER 变量为指定的类名，用于启动类加载器
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+ # 定义函数 find_maven_basedir，用于查找 Maven 项目的基础目录
+
+ if [ -z "$1" ]
+ then
+ # 如果函数的第一个参数为空
+ echo "Path not specified to find_maven_basedir"
+ # 输出错误信息，提示未指定路径
+ return 1
+ # 以错误状态码 1 返回
+ fi
+
+ basedir="$1"
+ # 将函数的第一个参数赋值给 basedir 变量
+ wdir="$1"
+ # 将函数的第一个参数赋值给 wdir 变量
+ while [ "$wdir" != '/' ] ; do
+ # 当 wdir 不是根目录时
+ if [ -d "$wdir"/.mvn ] ; then
+ # 如果 wdir 目录下存在 .mvn 子目录
+ basedir=$wdir
+ # 将 basedir 设置为 wdir
+ break
+ # 跳出循环
+ fi
+ # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+ if [ -d "${wdir}" ]; then
+ wdir=`cd "$wdir/.."; pwd`
+ # 如果 wdir 是一个目录，进入上一级目录并获取其路径，更新 wdir
+ fi
+ # end of workaround
+ done
+ echo "${basedir}"
+ # 输出找到的 Maven 项目基础目录路径
+}
+
+# concatenates all lines of a file
+concat_lines() {
+ # 定义函数 concat_lines，用于连接文件的所有行
+
+ if [ -f "$1" ]; then
+ # 如果函数的第一个参数是一个文件
+ echo "$(tr -s '\n' ' ' < "$1")"
+ # 使用 tr 命令将文件中的换行符替换为空格，并输出连接后的内容
+ fi
+}
+
+BASE_DIR=`find_maven_basedir "$(pwd)"`
+# 调用 find_maven_basedir 函数，传入当前工作目录路径，获取 Maven 项目基础目录并赋值给 BASE_DIR 变量
+if [ -z "$BASE_DIR" ]; then
+ # 如果 BASE_DIR 为空
+ exit 1;
+ # 以错误状态码 1 退出脚本
+fi
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+# 以下是关于自动从 Maven 中央仓库下载 maven-wrapper.jar 的扩展部分说明
+
+if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then
+ # 如果在 Maven 项目基础目录下的 .mvn/wrapper 目录中存在可读取的 maven-wrapper.jar 文件
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Found .mvn/wrapper/maven-wrapper.jar"
+ # 输出找到 maven-wrapper.jar 文件的信息
+ fi
else
+ # 如果不存在 maven-wrapper.jar 文件
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
+ # 输出未找到文件并开始下载的信息
+ fi
+ if [ -n "$MVNW_REPOURL" ]; then
+ # 如果 MVNW_REPOURL 环境变量不为空
+ jarUrl="$MVNW_REPOURL/io/takari/maven-wrapper/0.5.5/maven-wrapper-0.5.5.jar"
+ # 设置 jarUrl 为指定仓库路径下的 maven-wrapper.jar 文件路径
+ else
+ jarUrl="https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.5/maven-wrapper-0.5.5.jar"
+ # 否则，设置 jarUrl 为 Maven 中央仓库的 maven-wrapper.jar 文件路径
+ fi
+ while IFS="=" read key value; do
+ # 按行读取文件内容，以 = 分割为键值对
+ case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
+ # 如果键为 wrapperUrl，将值赋给 jarUrl 并跳出循环
+ esac
+ done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
+ # 从 .mvn/wrapper/maven-wrapper.properties 文件中读取内容进行处理
+
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Downloading from: $jarUrl"
+ # 输出从哪个路径下载 maven-wrapper.jar 文件的信息
+ fi
+ wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
+ # 设置 wrapperJarPath 为要下载到的本地路径
+
+ if $cygwin; then
+ # 如果是 Cygwin 系统
+ wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
+ # 将 wrapperJarPath 转换为 Windows 格式路径
+ fi
+
+ if command -v wget > /dev/null; then
+ # 如果 wget 命令存在
if [ "$MVNW_VERBOSE" = true ]; then
- echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Found wget ... using wget"
+ # 输出找到 wget 命令并将使用它下载的信息
fi
- if [ -n "$MVNW_REPOURL" ]; then
- jarUrl="$MVNW_REPOURL/io/takari/maven-wrapper/0.5.5/maven-wrapper-0.5.5.jar"
+ if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+ # 如果 MVNW_USERNAME 或 MVNW_PASSWORD 环境变量为空
+ wget "$jarUrl" -O "$wrapperJarPath"
+ # 使用 wget 命令从 jarUrl 下载文件并保存到 wrapperJarPath
else
- jarUrl="https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.5/maven-wrapper-0.5.5.jar"
+ wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath"
+ # 如果有用户名和密码，使用它们进行认证后下载文件
fi
- while IFS="=" read key value; do
- case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
- esac
- done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
+ elif command -v curl > /dev/null; then
+ # 如果 wget 不可用但 curl 命令存在
if [ "$MVNW_VERBOSE" = true ]; then
- echo "Downloading from: $jarUrl"
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Found curl ... using curl"
+ # 输出找到 curl 命令并将使用它下载的信息
fi
- wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
+ if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+ # 如果 MVNW_USERNAME 或 MVNW_PASSWORD 环境变量为空
+ curl -o "$wrapperJarPath" "$jarUrl" -f
+ # 使用 curl 命令从 jarUrl 下载文件并保存到 wrapperJarPath，-f 表示失败时不显示进度条
+ else
+ curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
+ # 如果有用户名和密码，使用它们进行认证后下载文件
+ fi
+ else
+ # 如果 wget 和 curl 都不可用
+ if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo "Falling back to using Java to download"
+ # 输出将使用 Java 进行下载的信息
+ fi
+ javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
+ # 设置 javaClass 为 MavenWrapperDownloader.java 文件的路径
+
+ # For Cygwin, switch paths to Windows format before running javac
if $cygwin; then
- wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
+ # 如果是 Cygwin 系统
+ javaClass=`cygpath --path --windows "$javaClass"`
+ # 将 javaClass 路径转换为 Windows 格式
fi
- if command -v wget > /dev/null; then
- if [ "$MVNW_VERBOSE" = true ]; then
- echo "Found wget ... using wget"
- fi
- if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
- wget "$jarUrl" -O "$wrapperJarPath"
- else
- wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath"
- fi
- elif command -v curl > /dev/null; then
+ if [ -e "$javaClass" ]; then
+ # 如果 MavenWrapperDownloader.java 文件存在
+ if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+ # 如果 MavenWrapperDownloader.class 文件不存在
if [ "$MVNW_VERBOSE" = true ]; then
- echo "Found curl ... using curl"
- fi
- if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
- curl -o "$wrapperJarPath" "$jarUrl" -f
- else
- curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo " - Compiling MavenWrapperDownloader.java ..."
+ # 输出正在编译 MavenWrapperDownloader.java 文件的信息
fi
-
- else
+ # Compiling the Java class
+ ("$JAVA_HOME/bin/javac" "$javaClass")
+ # 使用 javac 命令编译 MavenWrapperDownloader.java 文件
+ fi
+ if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+ # 如果编译后的 MavenWrapperDownloader.class 文件存在
+ # Running the downloader
if [ "$MVNW_VERBOSE" = true ]; then
- echo "Falling back to using Java to download"
- fi
- javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
- # For Cygwin, switch paths to Windows format before running javac
- if $cygwin; then
- javaClass=`cygpath --path --windows "$javaClass"`
- fi
- if [ -e "$javaClass" ]; then
- if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
- if [ "$MVNW_VERBOSE" = true ]; then
- echo " - Compiling MavenWrapperDownloader.java ..."
- fi
- # Compiling the Java class
- ("$JAVA_HOME/bin/javac" "$javaClass")
- fi
- if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
- # Running the downloader
- if [ "$MVNW_VERBOSE" = true ]; then
- echo " - Running MavenWrapperDownloader.java ..."
- fi
- ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
- fi
+ # 如果 MVNW_VERBOSE 环境变量为 true
+ echo " - Running MavenWrapperDownloader.java ..."
+ # 输出正在运行 MavenWrapperDownloader.java 程序的信息
fi
+ ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
+ # 使用 java 命令运行编译后的程序进行下载，传入项目基础目录作为参数
+ fi
fi
+ fi
fi
##########################################################################################
# End of extension
##########################################################################################
+# 自动下载 maven-wrapper.jar 扩展部分结束
export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+# 导出 MAVEN_PROJECTBASEDIR 环境变量，如果 MAVEN_BASEDIR 未设置，则使用 BASE_DIR 的值
if [ "$MVNW_VERBOSE" = true ]; then
+ # 如果 MVNW_VERBOSE 环境变量为 true
echo $MAVEN_PROJECTBASEDIR
+ # 输出 MAVEN_PROJECTBASEDIR 的值
fi
+
MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+# 调用 concat_lines 函数将 .mvn/jvm.config 文件内容拼接成一行，再与原有的 MAVEN_OPTS 拼接，作为新的 JVM 启动参数
# For Cygwin, switch paths to Windows format before running java
if $cygwin; then
- [ -n "$M2_HOME" ] &&
- M2_HOME=`cygpath --path --windows "$M2_HOME"`
- [ -n "$JAVA_HOME" ] &&
- JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
- [ -n "$CLASSPATH" ] &&
- CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
- [ -n "$MAVEN_PROJECTBASEDIR" ] &&
- MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+ # 若为 Cygwin 系统
+ [ -n "$M2_HOME" ] && M2_HOME=`cygpath --path --windows "$M2_HOME"`
+ # 若 M2_HOME 不为空，将其转换为 Windows 路径格式
+ [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
+ # 若 JAVA_HOME 不为空，将其转换为 Windows 路径格式
+ [ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
+ # 若 CLASSPATH 不为空，将其转换为 Windows 路径格式
+ [ -n "$MAVEN_PROJECTBASEDIR" ] && MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+ # 若 MAVEN_PROJECTBASEDIR 不为空，将其转换为 Windows 路径格式
fi
# Provide a "standardized" way to retrieve the CLI args that will
# work with both Windows and non-Windows executions.
MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
+# 将 MAVEN_CONFIG 环境变量的值和传递给脚本的所有参数拼接，存储到 MAVEN_CMD_LINE_ARGS 变量，用于统一管理命令行参数
export MAVEN_CMD_LINE_ARGS
+# 导出 MAVEN_CMD_LINE_ARGS 环境变量，以便后续使用
WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+# 设置 WRAPPER_LAUNCHER 为 Maven 包装器的主类，用于启动 Maven 包装器
exec "$JAVACMD" \
+ # 使用 exec 命令执行 Java 命令，替换当前 shell 进程
$MAVEN_OPTS \
+ # 传递 MAVEN_OPTS 作为 Java 虚拟机的启动参数
-classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+ # 设置类路径为 maven-wrapper.jar 文件所在路径
"-Dmaven.home=${M2_HOME}" "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+ # 设置两个系统属性，分别指定 Maven 主目录和多模块项目目录
${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
+ # 执行 Maven 包装器主类，并传递 MAVEN_CONFIG 和所有命令行参数，正式启动 Maven 构建过程
\ No newline at end of file
diff --git a/mvnw.cmd b/mvnw.cmd
index 84d60ab..1d2142f 100644
--- a/mvnw.cmd
+++ b/mvnw.cmd
@@ -1,133 +1,217 @@
@REM ----------------------------------------------------------------------------
+@REM 此注释块表明该文件遵循 Apache 软件基金会的许可协议
@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM 可能有一个或多个贡献者与 ASF 签订了许可协议
@REM or more contributor license agreements. See the NOTICE file
+@REM 查看随此项目一同分发的 NOTICE 文件，获取更多版权信息
@REM distributed with this work for additional information
+@REM 关于版权归属的详细信息
@REM regarding copyright ownership. The ASF licenses this file
+@REM ASF 根据 Apache 许可证 2.0 版本将此文件授权给你
@REM to you under the Apache License, Version 2.0 (the
@REM "License"); you may not use this file except in compliance
+@REM 除非你遵守该许可协议，否则不能使用此文件
@REM with the License. You may obtain a copy of the License at
-@REM
+@REM 你可以在下面的链接获取许可协议副本
@REM https://www.apache.org/licenses/LICENSE-2.0
@REM
@REM Unless required by applicable law or agreed to in writing,
+@REM 除非适用法律要求或书面同意
@REM software distributed under the License is distributed on an
+@REM 根据许可协议分发的软件按“原样”分发
@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM 不附带任何形式的明示或暗示保证和条件
@REM KIND, either express or implied. See the License for the
+@REM 查看许可协议以了解相关权限和限制的具体条款
@REM specific language governing permissions and limitations
@REM under the License.
@REM ----------------------------------------------------------------------------
@REM ----------------------------------------------------------------------------
+@REM 此注释块介绍了这是一个 Maven2 的启动批处理脚本
@REM Maven2 Start Up Batch script
@REM
@REM Required ENV vars:
+@REM 必需的环境变量
@REM JAVA_HOME - location of a JDK home dir
+@REM JAVA_HOME 环境变量，指向 JDK 的安装目录
@REM
@REM Optional ENV vars
+@REM 可选的环境变量
@REM M2_HOME - location of maven2's installed home dir
+@REM M2_HOME 环境变量，指向 Maven2 的安装目录
@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_ECHO 环境变量，设置为 'on' 可启用批处理命令的回显
@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a key stroke before ending
+@REM MAVEN_BATCH_PAUSE 环境变量，设置为 'on' 可在脚本结束前等待按键
@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM MAVEN_OPTS 环境变量，用于在运行 Maven 时传递给 Java 虚拟机的参数
@REM e.g. to debug Maven itself, use
+@REM 例如，要调试 Maven 本身，可使用以下设置
@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM MAVEN_SKIP_RC 环境变量，用于禁用加载 mavenrc 文件的标志
@REM ----------------------------------------------------------------------------
@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@REM 以 '@' 开头的 REM 行，防止在 MAVEN_BATCH_ECHO 为 'on' 时回显注释
@echo off
+@REM 关闭命令回显，避免在执行脚本时显示命令本身
@REM set title of command window
+@REM 设置命令窗口的标题
title %0
+@REM 将命令窗口的标题设置为当前脚本的名称
@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@REM 通过将 MAVEN_BATCH_ECHO 设置为 'on' 来启用命令回显
@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO%
+@REM 如果 MAVEN_BATCH_ECHO 环境变量的值为 'on'，则开启命令回显
@REM set %HOME% to equivalent of $HOME
+@REM 将 %HOME% 环境变量设置为与 $HOME 等效的值
if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+@REM 如果 %HOME% 环境变量未设置，则将其设置为当前用户的主目录
@REM Execute a user defined script before this one
+@REM 在执行此脚本之前执行用户定义的脚本
if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM 如果 MAVEN_SKIP_RC 环境变量不为空，则跳过执行用户定义的前置脚本
@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+@REM 检查是否存在前置脚本，分别检查以 .bat 和 .cmd 结尾的文件
if exist "%HOME%\mavenrc_pre.bat" call "%HOME%\mavenrc_pre.bat"
+@REM 如果存在 %HOME%\mavenrc_pre.bat 文件，则调用该脚本
if exist "%HOME%\mavenrc_pre.cmd" call "%HOME%\mavenrc_pre.cmd"
+@REM 如果存在 %HOME%\mavenrc_pre.cmd 文件，则调用该脚本
:skipRcPre
+@REM 跳过执行用户定义的前置脚本的标签
@setlocal
+@REM 开启本地环境变量作用域，确保后续设置的变量只在当前脚本块内有效
set ERROR_CODE=0
+@REM 初始化错误代码为 0，表示脚本执行正常
@REM To isolate internal variables from possible post scripts, we use another setlocal
+@REM 为了将内部变量与可能的后置脚本隔离开，我们再次使用 setlocal
@setlocal
@REM ==== START VALIDATION ====
+@REM 开始验证环境变量
if not "%JAVA_HOME%" == "" goto OkJHome
+@REM 如果 JAVA_HOME 环境变量已设置，则跳转到 OkJHome 标签
echo.
echo Error: JAVA_HOME not found in your environment. >&2
+@REM 输出错误信息，提示 JAVA_HOME 环境变量未找到
echo Please set the JAVA_HOME variable in your environment to match the >&2
+@REM 提示用户设置 JAVA_HOME 环境变量
echo location of your Java installation. >&2
+@REM 提示用户将 JAVA_HOME 设置为 Java 安装目录
echo.
goto error
+@REM 跳转到 error 标签，处理错误情况
:OkJHome
+@REM JAVA_HOME 环境变量已设置的标签
if exist "%JAVA_HOME%\bin\java.exe" goto init
+@REM 如果 JAVA_HOME\bin\java.exe 文件存在，则跳转到 init 标签
echo.
echo Error: JAVA_HOME is set to an invalid directory. >&2
+@REM 输出错误信息，提示 JAVA_HOME 设置为无效目录
echo JAVA_HOME = "%JAVA_HOME%" >&2
+@REM 显示当前 JAVA_HOME 的值
echo Please set the JAVA_HOME variable in your environment to match the >&2
+@REM 提示用户设置正确的 JAVA_HOME 环境变量
echo location of your Java installation. >&2
+@REM 提示用户将 JAVA_HOME 设置为 Java 安装目录
echo.
goto error
+@REM 跳转到 error 标签，处理错误情况
@REM ==== END VALIDATION ====
+@REM 结束环境变量验证
:init
+@REM 初始化标签
@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM 查找项目的基础目录，即包含 .mvn 文件夹的目录
@REM Fallback to current working directory if not found.
+@REM 如果未找到，则使用当前工作目录作为基础目录
set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+@REM 将 MAVEN_PROJECTBASEDIR 环境变量设置为 MAVEN_BASEDIR 的值
IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+@REM 如果 MAVEN_PROJECTBASEDIR 环境变量不为空，则跳转到 endDetectBaseDir 标签
set EXEC_DIR=%CD%
+@REM 将 EXEC_DIR 环境变量设置为当前工作目录
set WDIR=%EXEC_DIR%
+@REM 将 WDIR 环境变量设置为当前工作目录
:findBaseDir
+@REM 查找基础目录的标签
IF EXIST "%WDIR%"\.mvn goto baseDirFound
+@REM 如果当前目录下存在 .mvn 文件夹，则跳转到 baseDirFound 标签
cd ..
+@REM 切换到上一级目录
IF "%WDIR%"=="%CD%" goto baseDirNotFound
+@REM 如果已经到达根目录，则跳转到 baseDirNotFound 标签
set WDIR=%CD%
+@REM 更新 WDIR 环境变量为当前目录
goto findBaseDir
+@REM 继续查找基础目录
:baseDirFound
+@REM 找到基础目录的标签
set MAVEN_PROJECTBASEDIR=%WDIR%
+@REM 将 MAVEN_PROJECTBASEDIR 环境变量设置为找到的基础目录
cd "%EXEC_DIR%"
+@REM 切换回原来的工作目录
goto endDetectBaseDir
+@REM 跳转到 endDetectBaseDir 标签
:baseDirNotFound
+@REM 未找到基础目录的标签
set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+@REM 将 MAVEN_PROJECTBASEDIR 环境变量设置为当前工作目录
cd "%EXEC_DIR%"
+@REM 切换回原来的工作目录
:endDetectBaseDir
+@REM 结束基础目录检测的标签
IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+@REM 如果 %MAVEN_PROJECTBASEDIR%\.mvn\jvm.config 文件不存在，则跳转到 endReadAdditionalConfig 标签
@setlocal EnableExtensions EnableDelayedExpansion
+@REM 开启扩展和延迟环境变量扩展
for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@REM 读取 %MAVEN_PROJECTBASEDIR%\.mvn\jvm.config 文件的内容，并将其添加到 JVM_CONFIG_MAVEN_PROPS 环境变量中
@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+@REM 结束本地环境变量作用域，并将 JVM_CONFIG_MAVEN_PROPS 环境变量传递到外部
:endReadAdditionalConfig
+@REM 结束读取额外配置文件的标签
SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+@REM 设置 MAVEN_JAVA_EXE 环境变量为 Java 可执行文件的路径
set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+@REM 设置 WRAPPER_JAR 环境变量为 Maven 包装器 JAR 文件的路径
set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+@REM 设置 WRAPPER_LAUNCHER 环境变量为 Maven 包装器的主类名
set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.5/maven-wrapper-0.5.5.jar"
+@REM 设置 DOWNLOAD_URL 环境变量为 Maven 包装器 JAR 文件的下载地址
FOR /F "tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B
)
+@REM 读取 %MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties 文件，查找 wrapperUrl 属性，并更新 DOWNLOAD_URL 环境变量
@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM 扩展功能，允许自动从 Maven 中央仓库下载 maven-wrapper.jar 文件
@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+@REM 这允许在禁止提交二进制数据的项目中使用 Maven 包装器
if exist %WRAPPER_JAR% (
if "%MVNW_VERBOSE%" == "true" (
echo Found %WRAPPER_JAR%
@@ -153,30 +237,50 @@ if exist %WRAPPER_JAR% (
)
)
@REM End of extension
+@REM 扩展功能结束
@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM 提供一种“标准化”的方式来获取命令行参数
@REM work with both Windows and non-Windows executions.
+@REM 适用于 Windows 和非 Windows 系统的执行环境
set MAVEN_CMD_LINE_ARGS=%*
+@REM 将 MAVEN_CMD_LINE_ARGS 环境变量设置为所有命令行参数
%MAVEN_JAVA_EXE% %JVM_CONFIG_MAVEN_PROPS% %MAVEN_OPTS% %MAVEN_DEBUG_OPTS% -classpath %WRAPPER_JAR% "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+@REM 执行 Java 命令，启动 Maven 包装器
if ERRORLEVEL 1 goto error
+@REM 如果执行 Java 命令返回错误码，则跳转到 error 标签
goto end
+@REM 跳转到 end 标签
:error
+@REM 错误处理标签
set ERROR_CODE=1
+@REM 设置错误代码为 1，表示脚本执行出错
:end
+@REM 结束标签
@endlocal & set ERROR_CODE=%ERROR_CODE%
+@REM 结束本地环境变量作用域，并将错误代码传递到外部
if not "%MAVEN_SKIP_RC%" == "" goto skipRcPost
+@REM 如果 MAVEN_SKIP_RC 环境变量不为空，则跳过执行用户定义的后置脚本
@REM check for post script, once with legacy .bat ending and once with .cmd ending
+@REM 检查是否存在后置脚本，分别检查以 .bat 和 .cmd 结尾的文件
if exist "%HOME%\mavenrc_post.bat" call "%HOME%\mavenrc_post.bat"
+@REM 如果存在 %HOME%\mavenrc_post.bat 文件，则调用该脚本
if exist "%HOME%\mavenrc_post.cmd" call "%HOME%\mavenrc_post.cmd"
+@REM 如果存在 %HOME%\mavenrc_post.cmd 文件，则调用该脚本
:skipRcPost
+@REM 跳过执行用户定义的后置脚本的标签
@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+@REM 如果 MAVEN_BATCH_PAUSE 环境变量设置为 'on'，则暂停脚本执行
if "%MAVEN_BATCH_PAUSE%" == "on" pause
+@REM 等待用户按键
if "%MAVEN_TERMINATE_CMD%" == "on" exit %ERROR_CODE%
+@REM 如果 MAVEN_TERMINATE_CMD 环境变量设置为 'on'，则退出命令提示符并返回错误代码
exit /B %ERROR_CODE%
+@REM 退出当前批处理脚本并返回错误代码
\ No newline at end of file
diff --git a/pom-war.xml b/pom-war.xml
index 93c5638..fcac2a7 100644
--- a/pom-war.xml
+++ b/pom-war.xml
@@ -1,116 +1,138 @@
+
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+
4.0.0
+
+
org.springframework.boot
+
spring-boot-starter-parent
+
2.2.2.RELEASE
-
+
+
+
com.jlwl
springbootus5uu
+
0.0.1-SNAPSHOT
+
springboot-schema
+
springboot学习框架(war包对应的pom，打war包，执行【mvn clean package -f pom-war.xml】)
+
war
+
+
1.8
+
1.2.8
+
3.1.1
+
+
org.springframework.boot
spring-boot-starter-web
+
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.1.1
+
- org.springframework.boot
- spring-boot-starter-jdbc
+ org.springframework.boot
+ spring-boot-starter-jdbc
-
+
- org.springframework.boot
- spring-boot-starter-tomcat
- provided
+ org.springframework.boot
+ spring-boot-starter-tomcat
+ provided
-
+
- mysql
- mysql-connector-java
+ mysql
+ mysql-connector-java
+
org.apache.shiro
shiro-spring
1.3.2
-
+
com.baomidou
mybatis-plus
2.3
+
com.baomidou
mybatisplus-spring-boot-starter
1.0.5
+
- com.google.protobuf
- protobuf-java
- 3.10.0
+ com.google.protobuf
+ protobuf-java
+ 3.10.0
-
+
- org.apache.commons
- commons-lang3
- 3.0
+ org.apache.commons
+ commons-lang3
+ 3.0
-
+
- javax.validation
- validation-api
- 2.0.1.Final
+ javax.validation
+ validation-api
+ 2.0.1.Final
-
+
- commons-io
- commons-io
- 2.5
+ commons-io
+ commons-io
+ 2.5
-
-
+
- cn.hutool
- hutool-all
- 4.0.12
+ cn.hutool
+ hutool-all
+ 4.0.12
-
-
+
com.alibaba
fastjson
${fastjson.version}
-
+
- com.baidu.aip
- java-sdk
- 4.4.1
+ com.baidu.aip
+ java-sdk
+ 4.4.1
-
+
org.springframework.boot
spring-boot-starter-test
test
+
org.junit.vintage
@@ -120,23 +142,27 @@
-
+
+
springbootus5uu
+
+
org.springframework.boot
spring-boot-maven-plugin
-
+
org.apache.maven.plugins
maven-surefire-plugin
+
true
-
+
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 1c9ddf8..8f6f207 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,143 +1,219 @@
+
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+
4.0.0
+
+
org.springframework.boot
+
spring-boot-starter-parent
+
2.2.2.RELEASE
+
+
com.jlwl
+
springbootus5uu
+
0.0.1-SNAPSHOT
+
springboot-schema
- springboot学习框架
+
+ springboot学习框架(war包对应的pom，打war包，执行【mvn clean package -f pom-war.xml】)
+
+ war
+
+
1.8
+
1.2.8
+
3.1.1
+
+
+
org.springframework.boot
+
spring-boot-starter-web
+
org.mybatis.spring.boot
+
mybatis-spring-boot-starter
+
2.1.1
+
- org.springframework.boot
- spring-boot-starter-jdbc
+ org.springframework.boot
+
+ spring-boot-starter-jdbc
+
+
+
+
+ org.springframework.boot
+
+ spring-boot-starter-tomcat
+
+ provided
+
-
+
- mysql
- mysql-connector-java
+ mysql
+
+ mysql-connector-java
+
org.apache.shiro
+
shiro-spring
+
1.3.2
+
-
+
com.baomidou
+
mybatis-plus
+
2.3
+
com.baomidou
+
mybatisplus-spring-boot-starter
+
1.0.5
+
- com.google.protobuf
- protobuf-java
- 3.10.0
+ com.google.protobuf
+
+ protobuf-java
+
+ 3.10.0
+
-
+
- org.apache.commons
- commons-lang3
- 3.0
+ org.apache.commons
+
+ commons-lang3
+
+ 3.0
+
-
+
- javax.validation
- validation-api
- 2.0.1.Final
+ javax.validation
+
+ validation-api
+
+ 2.0.1.Final
+
-
+
- commons-io
- commons-io
- 2.5
+ commons-io
+
+ commons-io
+
+ 2.5
+
-
-
+
+
- cn.hutool
- hutool-all
- 4.0.12
+ cn.hutool
+
+ hutool-all
+
+ 4.0.12
+
-
+
com.alibaba
+
fastjson
+
${fastjson.version}
-
-
-
-
-
-
-
-
- com.microsoft.sqlserver
- mssql-jdbc
- 6.2.0.jre8
- test
-
-
- com.microsoft.sqlserver
- mssql-jdbc
- 6.2.0.jre8
- runtime
+
- com.baidu.aip
- java-sdk
- 4.4.1
+ com.baidu.aip
+
+ java-sdk
+
+ 4.4.1
+
-
+
org.springframework.boot
+
spring-boot-starter-test
+
test
+
+
org.junit.vintage
+
junit-vintage-engine
+
+
+
+ springbootus5uu
+
+
org.springframework.boot
+
spring-boot-maven-plugin
+
+
+
+
+ org.apache.maven.plugins
+
+ maven-surefire-plugin
+
+
+
+ true
+
+
-
+
\ No newline at end of file
diff --git a/src/main/java/com/config/InterceptorConfig.java b/src/main/java/com/config/InterceptorConfig.java
index 21cd1dc..ce36911 100644
--- a/src/main/java/com/config/InterceptorConfig.java
+++ b/src/main/java/com/config/InterceptorConfig.java
@@ -33,6 +33,6 @@ public class InterceptorConfig extends WebMvcConfigurationSupport{
.addResourceLocations("classpath:/admin/")
.addResourceLocations("classpath:/front/")
.addResourceLocations("classpath:/public/");
- super.addResourceHandlers(registry);
+ super.addResourceHandlers(registry);//测试
}
}
diff --git a/src/main/java/com/controller/ChatController.java b/src/main/java/com/controller/ChatController.java
index 34f578e..c98ab5d 100644
--- a/src/main/java/com/controller/ChatController.java
+++ b/src/main/java/com/controller/ChatController.java
@@ -1,231 +1,346 @@
package com.controller;
+// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
+// 导入ArrayList类，用于创建动态数组
import java.util.ArrayList;
+// 导入Arrays类，提供操作数组的静态方法
import java.util.Arrays;
+// 导入Calendar类，用于处理日期和时间
import java.util.Calendar;
+// 导入Map接口，用于存储键值对
import java.util.Map;
+// 导入HashMap类，实现了Map接口
import java.util.HashMap;
+// 导入Iterator接口，用于遍历集合
import java.util.Iterator;
+// 导入Date类，用于表示特定的瞬间
import java.util.Date;
+// 导入List接口，用于存储有序的元素集合
import java.util.List;
+// 导入HttpServletRequest类，用于获取客户端请求信息
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
+// 导入Apache Commons Lang库中的StringUtils类，用于处理字符串
import org.apache.commons.lang3.StringUtils;
+// 导入Spring框架的自动装配注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
+// 导入Spring框架的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入Spring框架的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入Spring框架的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入Spring框架的请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
+// 导入Spring框架的REST控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入Chat实体类
import com.entity.ChatEntity;
+// 导入Chat视图类
import com.entity.view.ChatView;
+// 导入Chat服务类
import com.service.ChatService;
+// 导入Token服务类
import com.service.TokenService;
+// 导入自定义的分页工具类
import com.utils.PageUtils;
+// 导入自定义的响应结果类
import com.utils.R;
+// 导入自定义的MD5工具类
import com.utils.MD5Util;
+// 导入自定义的MyBatis-Plus工具类
import com.utils.MPUtil;
+// 导入自定义的通用工具类
import com.utils.CommonUtil;
/**
* 客户服务
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:15
*/
+// 声明为RESTful风格的控制器
@RestController
+// 定义请求的基础路径
@RequestMapping("/chat")
public class ChatController {
- @Autowired
- private ChatService chatService;
-
-
-
- /**
- * 后端列表
- */
- @RequestMapping("/page")
- public R page(@RequestParam Map params,ChatEntity chat,
- HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- chat.setUserid((Long)request.getSession().getAttribute("userId"));
- }
- EntityWrapper ew = new EntityWrapper();
+ // 自动装配ChatService实例
+ @Autowired
+ private ChatService chatService;
+
+
+ /**
+ * 后端列表
+ */
+ // 处理/page请求
+ @RequestMapping("/page")
+ // 方法接收请求参数、Chat实体和HttpServletRequest对象
+ public R page(@RequestParam Map params, ChatEntity chat,
+ HttpServletRequest request) {
+ // 如果当前用户不是管理员
+ if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置Chat实体的用户ID为当前用户ID
+ chat.setUserid((Long) request.getSession().getAttribute("userId"));
+ }
+ // 创建MyBatis-Plus的实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 调用ChatService的queryPage方法进行分页查询
PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
+ // 返回成功响应，并将分页数据放入响应中
+ return R.ok().put("data", page);
+ }
- return R.ok().put("data", page);
- }
-
- /**
- * 前端列表
- */
- @RequestMapping("/list")
- public R list(@RequestParam Map params,ChatEntity chat,
- HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- chat.setUserid((Long)request.getSession().getAttribute("userId"));
- }
- EntityWrapper ew = new EntityWrapper();
+ /**
+ * 前端列表
+ */
+ // 处理/list请求
+ @RequestMapping("/list")
+ // 方法接收请求参数、Chat实体和HttpServletRequest对象
+ public R list(@RequestParam Map params, ChatEntity chat,
+ HttpServletRequest request) {
+ // 如果当前用户不是管理员
+ if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置Chat实体的用户ID为当前用户ID
+ chat.setUserid((Long) request.getSession().getAttribute("userId"));
+ }
+ // 创建MyBatis-Plus的实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 调用ChatService的queryPage方法进行分页查询
PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
- return R.ok().put("data", page);
- }
+ // 返回成功响应，并将分页数据放入响应中
+ return R.ok().put("data", page);
+ }
+
+ /**
+ * 列表
+ */
+ // 处理/lists请求
+ @RequestMapping("/lists")
+ // 方法接收Chat实体
+ public R list(ChatEntity chat) {
+ // 创建MyBatis-Plus的实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，将Chat实体的属性作为查询条件
+ ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
+ // 调用ChatService的selectListView方法查询列表数据
+ return R.ok().put("data", chatService.selectListView(ew));
+ }
/**
- * 列表
- */
- @RequestMapping("/lists")
- public R list( ChatEntity chat){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( chat, "chat"));
- return R.ok().put("data", chatService.selectListView(ew));
- }
-
- /**
- * 查询
- */
- @RequestMapping("/query")
- public R query(ChatEntity chat){
- EntityWrapper< ChatEntity> ew = new EntityWrapper< ChatEntity>();
- ew.allEq(MPUtil.allEQMapPre( chat, "chat"));
- ChatView chatView = chatService.selectView(ew);
+ * 查询
+ */
+ // 处理/query请求
+ @RequestMapping("/query")
+ // 方法接收Chat实体
+ public R query(ChatEntity chat) {
+ // 创建MyBatis-Plus的实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，将Chat实体的属性作为查询条件
+ ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
+ // 调用ChatService的selectView方法查询单个视图数据
+ ChatView chatView = chatService.selectView(ew);
+ // 返回成功响应，并将查询结果放入响应中
return R.ok("查询客户服务成功").put("data", chatView);
- }
-
- /**
- * 后端详情
- */
- @RequestMapping("/info/{id}")
- public R info(@PathVariable("id") Long id){
- ChatEntity chat = chatService.selectById(id);
- return R.ok().put("data", chat);
- }
-
- /**
- * 前端详情
- */
- @RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") Long id){
- ChatEntity chat = chatService.selectById(id);
- return R.ok().put("data", chat);
- }
-
-
-
-
- /**
- * 后端保存
- */
- @RequestMapping("/save")
- public R save(@RequestBody ChatEntity chat, HttpServletRequest request){
- chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(chat);
- if(StringUtils.isNotBlank(chat.getAsk())) {
+ }
+
+ /**
+ * 后端详情
+ */
+ // 处理/info/{id}请求，接收路径变量id
+ @RequestMapping("/info/{id}")
+ public R info(@PathVariable("id") Long id) {
+ // 根据ID查询Chat实体
+ ChatEntity chat = chatService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应中
+ return R.ok().put("data", chat);
+ }
+
+ /**
+ * 前端详情
+ */
+ // 处理/detail/{id}请求，接收路径变量id
+ @RequestMapping("/detail/{id}")
+ public R detail(@PathVariable("id") Long id) {
+ // 根据ID查询Chat实体
+ ChatEntity chat = chatService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应中
+ return R.ok().put("data", chat);
+ }
+
+
+ /**
+ * 后端保存
+ */
+ // 处理/save请求，接收请求体中的Chat实体和HttpServletRequest对象
+ @RequestMapping("/save")
+ public R save(@RequestBody ChatEntity chat, HttpServletRequest request) {
+ // 生成唯一的ID，使用当前时间戳加上随机数
+ chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 注释掉的验证代码
+ //ValidatorUtils.validateEntity(chat);
+ // 如果询问内容不为空
+ if (StringUtils.isNotBlank(chat.getAsk())) {
+ // 将该用户的所有聊天记录的isreply字段置为0
chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", request.getSession().getAttribute("userId")));
- chat.setUserid((Long)request.getSession().getAttribute("userId"));
- chat.setIsreply(1);
- }
- if(StringUtils.isNotBlank(chat.getReply())) {
- chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid()));
- chat.setAdminid((Long)request.getSession().getAttribute("userId"));
- }
- chatService.insert(chat);
- return R.ok();
- }
-
- /**
- * 前端保存
- */
- @RequestMapping("/add")
- public R add(@RequestBody ChatEntity chat, HttpServletRequest request){
- chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(chat);
- chat.setUserid((Long)request.getSession().getAttribute("userId"));
- if(StringUtils.isNotBlank(chat.getAsk())) {
+ // 设置Chat实体的用户ID为当前用户ID
+ chat.setUserid((Long) request.getSession().getAttribute("userId"));
+ // 设置isreply字段为1
+ chat.setIsreply(1);
+ }
+ // 如果回复内容不为空
+ if (StringUtils.isNotBlank(chat.getReply())) {
+ // 将该用户的所有聊天记录的isreply字段置为0
+ chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid()));
+ // 设置Chat实体的管理员ID为当前用户ID
+ chat.setAdminid((Long) request.getSession().getAttribute("userId"));
+ }
+ // 插入Chat实体到数据库
+ chatService.insert(chat);
+ // 返回成功响应
+ return R.ok();
+ }
+
+ /**
+ * 前端保存
+ */
+ // 处理/add请求，接收请求体中的Chat实体和HttpServletRequest对象
+ @RequestMapping("/add")
+ public R add(@RequestBody ChatEntity chat, HttpServletRequest request) {
+ // 生成唯一的ID，使用当前时间戳加上随机数
+ chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 注释掉的验证代码
+ //ValidatorUtils.validateEntity(chat);
+ // 设置Chat实体的用户ID为当前用户ID
+ chat.setUserid((Long) request.getSession().getAttribute("userId"));
+ // 如果询问内容不为空
+ if (StringUtils.isNotBlank(chat.getAsk())) {
+ // 将该用户的所有聊天记录的isreply字段置为0
chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", request.getSession().getAttribute("userId")));
- chat.setUserid((Long)request.getSession().getAttribute("userId"));
- chat.setIsreply(1);
- }
- if(StringUtils.isNotBlank(chat.getReply())) {
- chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid()));
- chat.setAdminid((Long)request.getSession().getAttribute("userId"));
- }
- chatService.insert(chat);
- return R.ok();
- }
-
- /**
- * 修改
- */
- @RequestMapping("/update")
- public R update(@RequestBody ChatEntity chat, HttpServletRequest request){
- //ValidatorUtils.validateEntity(chat);
- chatService.updateById(chat);//全部更新
- return R.ok();
- }
-
-
- /**
- * 删除
- */
- @RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
- chatService.deleteBatchIds(Arrays.asList(ids));
- return R.ok();
- }
-
- /**
- * 提醒接口
- */
+ // 设置Chat实体的用户ID为当前用户ID
+ chat.setUserid((Long) request.getSession().getAttribute("userId"));
+ // 设置isreply字段为1
+ chat.setIsreply(1);
+ }
+ // 如果回复内容不为空
+ if (StringUtils.isNotBlank(chat.getReply())) {
+ // 将该用户的所有聊天记录的isreply字段置为0
+ chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid()));
+ // 设置Chat实体的管理员ID为当前用户ID
+ chat.setAdminid((Long) request.getSession().getAttribute("userId"));
+ }
+ // 插入Chat实体到数据库
+ chatService.insert(chat);
+ // 返回成功响应
+ return R.ok();
+ }
+
+ /**
+ * 修改
+ */
+ // 处理/update请求，接收请求体中的Chat实体和HttpServletRequest对象
+ @RequestMapping("/update")
+ public R update(@RequestBody ChatEntity chat, HttpServletRequest request) {
+ // 注释掉的验证代码
+ //ValidatorUtils.validateEntity(chat);
+ // 根据ID更新Chat实体的所有字段
+ chatService.updateById(chat);
+ // 返回成功响应
+ return R.ok();
+ }
+
+
+ /**
+ * 删除
+ */
+ // 处理/delete请求，接收请求体中的ID数组
+ @RequestMapping("/delete")
+ public R delete(@RequestBody Long[] ids) {
+ // 根据ID数组批量删除Chat实体
+ chatService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
+ return R.ok();
+ }
+
+ /**
+ * 提醒接口
+ */
+ // 处理/remind/{columnName}/{type}请求，接收路径变量columnName和type，以及请求参数map
@RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type, @RequestParam Map map) {
+ // 将列名和类型放入请求参数map中
map.put("column", columnName);
map.put("type", type);
-
- if(type.equals("2")) {
+
+ // 如果类型为2
+ if (type.equals("2")) {
+ // 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建Calendar对象
Calendar c = Calendar.getInstance();
+ // 提醒开始日期
Date remindStartDate = null;
+ // 提醒结束日期
Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
+ // 如果提醒开始时间不为空
+ if (map.get("remindstart") != null) {
+ // 将提醒开始时间转换为整数
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
+ // 设置Calendar的时间为当前时间
+ c.setTime(new Date());
+ // 增加指定天数
+ c.add(Calendar.DAY_OF_MONTH, remindStart);
+ // 获取提醒开始日期
remindStartDate = c.getTime();
+ // 将提醒开始日期格式化后放入请求参数map中
map.put("remindstart", sdf.format(remindStartDate));
}
- if(map.get("remindend")!=null) {
+ // 如果提醒结束时间不为空
+ if (map.get("remindend") != null) {
+ // 将提醒结束时间转换为整数
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置Calendar的时间为当前时间
c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
+ // 增加指定天数
+ c.add(Calendar.DAY_OF_MONTH, remindEnd);
+ // 获取提醒结束日期
remindEndDate = c.getTime();
+ // 将提醒结束日期格式化后放入请求参数map中
map.put("remindend", sdf.format(remindEndDate));
}
}
-
+
+ // 创建MyBatis-Plus的包装器
Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
+ // 如果提醒开始时间不为空
+ if (map.get("remindstart") != null) {
+ // 设置查询条件，列名大于等于提醒开始时间
wrapper.ge(columnName, map.get("remindstart"));
}
- if(map.get("remindend")!=null) {
+ // 如果提醒结束时间不为空
+ if (map.get("remindend") != null) {
+ // 设置查询条件，列名小于等于提醒结束时间
wrapper.le(columnName, map.get("remindend"));
}
-
+ // 统计符合条件的记录数
int count = chatService.selectCount(wrapper);
+ // 返回成功响应，并将统计结果放入响应中
return R.ok().put("count", count);
}
-
-
-
-}
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/CommonController.java b/src/main/java/com/controller/CommonController.java
index 4c6e1f1..1068b70 100644
--- a/src/main/java/com/controller/CommonController.java
+++ b/src/main/java/com/controller/CommonController.java
@@ -1,256 +1,405 @@
package com.controller;
+// 导入文件操作相关类
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
+// 导入日期格式化类
import java.text.SimpleDateFormat;
+// 导入动态数组类
import java.util.ArrayList;
+// 导入日历类
import java.util.Calendar;
+// 导入日期类
import java.util.Date;
+// 导入哈希映射类
import java.util.HashMap;
+// 导入列表接口
import java.util.List;
+// 导入映射接口
import java.util.Map;
+// 导入Apache Commons Lang工具类
import org.apache.commons.lang3.StringUtils;
+// 导入JSON对象类
import org.json.JSONObject;
+// 导入Spring的自动装配注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring的资源工具类
import org.springframework.util.ResourceUtils;
+// 导入Spring的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入Spring的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入Spring的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入Spring的请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
+// 导入Spring的REST控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入百度人脸识别客户端类
import com.baidu.aip.face.AipFace;
+// 导入百度人脸匹配请求类
import com.baidu.aip.face.MatchRequest;
+// 导入百度的Base64工具类
import com.baidu.aip.util.Base64Util;
+// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入配置实体类
import com.entity.ConfigEntity;
+// 导入通用服务类
import com.service.CommonService;
+// 导入配置服务类
import com.service.ConfigService;
+// 导入自定义的百度工具类
import com.utils.BaiduUtil;
+// 导入自定义的文件工具类
import com.utils.FileUtil;
+// 导入自定义的响应结果类
import com.utils.R;
/**
* 通用接口
*/
+// 声明为RESTful控制器
@RestController
-public class CommonController{
+public class CommonController {
+ // 自动装配通用服务类实例
@Autowired
private CommonService commonService;
-
+
+ // 自动装配配置服务类实例
@Autowired
private ConfigService configService;
+
+ // 定义一个未使用的整型变量
private int aaaa;
+
+ // 定义百度人脸识别客户端静态变量
private static AipFace client = null;
-
+
+ // 定义百度地图AK静态变量
private static String BAIDU_DITU_AK = null;
-
+
+ /**
+ * 根据经纬度获取城市信息
+ * @param lng 经度
+ * @param lat 纬度
+ * @return 包含城市信息的响应结果
+ */
@RequestMapping("/location")
- public R location(String lng,String lat) {
- if(BAIDU_DITU_AK==null) {
+ public R location(String lng, String lat) {
+ // 如果百度地图AK为空
+ if (BAIDU_DITU_AK == null) {
+ // 从配置表中获取百度地图AK
BAIDU_DITU_AK = configService.selectOne(new EntityWrapper().eq("name", "baidu_ditu_ak")).getValue();
- if(BAIDU_DITU_AK==null) {
+ // 如果获取失败
+ if (BAIDU_DITU_AK == null) {
+ // 返回错误信息
return R.error("请在配置管理中正确配置baidu_ditu_ak");
}
}
+ // 调用百度工具类的方法获取城市信息
Map map = BaiduUtil.getCityByLonLat(BAIDU_DITU_AK, lng, lat);
+ // 返回成功响应并携带城市信息
return R.ok().put("data", map);
}
-
+
/**
* 人脸比对
- *
- * @param face1 人脸1
- * @param face2 人脸2
- * @return
+ * @param face1 人脸1的文件名
+ * @param face2 人脸2的文件名
+ * @return 包含比对结果的响应结果
*/
@RequestMapping("/matchFace")
public R matchFace(String face1, String face2) {
- if(client==null) {
- /*String AppID = configService.selectOne(new EntityWrapper().eq("name", "AppID")).getValue();*/
+ // 如果百度人脸识别客户端未初始化
+ if (client == null) {
+ // 从配置表中获取API Key
String APIKey = configService.selectOne(new EntityWrapper().eq("name", "APIKey")).getValue();
+ // 从配置表中获取Secret Key
String SecretKey = configService.selectOne(new EntityWrapper().eq("name", "SecretKey")).getValue();
+ // 获取百度认证令牌
String token = BaiduUtil.getAuth(APIKey, SecretKey);
- if(token==null) {
+ // 如果获取失败
+ if (token == null) {
+ // 返回错误信息
return R.error("请在配置管理中正确配置APIKey和SecretKey");
}
+ // 初始化百度人脸识别客户端
client = new AipFace(null, APIKey, SecretKey);
+ // 设置连接超时时间
client.setConnectionTimeoutInMillis(2000);
+ // 设置套接字超时时间
client.setSocketTimeoutInMillis(60000);
}
+ // 定义JSON对象用于存储比对结果
JSONObject res = null;
try {
- File file1 = new File(ResourceUtils.getFile("classpath:static/upload").getAbsolutePath()+"/"+face1);
- File file2 = new File(ResourceUtils.getFile("classpath:static/upload").getAbsolutePath()+"/"+face2);
+ // 获取人脸1的文件对象
+ File file1 = new File(ResourceUtils.getFile("classpath:static/upload").getAbsolutePath() + "/" + face1);
+ // 获取人脸2的文件对象
+ File file2 = new File(ResourceUtils.getFile("classpath:static/upload").getAbsolutePath() + "/" + face2);
+ // 将人脸1的文件转换为Base64编码字符串
String img1 = Base64Util.encode(FileUtil.FileToByte(file1));
+ // 将人脸2的文件转换为Base64编码字符串
String img2 = Base64Util.encode(FileUtil.FileToByte(file2));
+ // 创建人脸1的匹配请求对象
MatchRequest req1 = new MatchRequest(img1, "BASE64");
+ // 创建人脸2的匹配请求对象
MatchRequest req2 = new MatchRequest(img2, "BASE64");
+ // 创建匹配请求列表
ArrayList requests = new ArrayList();
+ // 将人脸1的匹配请求添加到列表中
requests.add(req1);
+ // 将人脸2的匹配请求添加到列表中
requests.add(req2);
+ // 调用百度人脸识别客户端的匹配方法进行人脸比对
res = client.match(requests);
+ // 打印比对结果
System.out.println(res.get("result"));
} catch (FileNotFoundException e) {
+ // 打印文件未找到异常信息
e.printStackTrace();
+ // 返回文件不存在的错误信息
return R.error("文件不存在");
} catch (IOException e) {
+ // 打印IO异常信息
e.printStackTrace();
- }
+ }
+ // 返回成功响应并携带比对结果
return R.ok().put("data", com.alibaba.fastjson.JSONObject.parse(res.get("result").toString()));
}
-
+
/**
* 获取table表中的column列表(联动接口)
- * @param table
- * @param column
- * @return
+ * @param tableName 表名
+ * @param columnName 列名
+ * @param level 层级信息
+ * @param parent 父级信息
+ * @return 包含列列表的响应结果
*/
@IgnoreAuth
@RequestMapping("/option/{tableName}/{columnName}")
- public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,String level,String parent) {
+ public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, String level, String parent) {
+ // 创建参数映射
Map params = new HashMap();
+ // 将表名放入参数映射中
params.put("table", tableName);
+ // 将列名放入参数映射中
params.put("column", columnName);
- if(StringUtils.isNotBlank(level)) {
+ // 如果层级信息不为空
+ if (StringUtils.isNotBlank(level)) {
+ // 将层级信息放入参数映射中
params.put("level", level);
}
- if(StringUtils.isNotBlank(parent)) {
+ // 如果父级信息不为空
+ if (StringUtils.isNotBlank(parent)) {
+ // 将父级信息放入参数映射中
params.put("parent", parent);
}
+ // 调用通用服务类的方法获取列列表
List data = commonService.getOption(params);
+ // 返回成功响应并携带列列表
return R.ok().put("data", data);
}
-
+
/**
* 根据table中的column获取单条记录
- * @param table
- * @param column
- * @return
+ * @param tableName 表名
+ * @param columnName 列名
+ * @param columnValue 列值
+ * @return 包含单条记录的响应结果
*/
@IgnoreAuth
@RequestMapping("/follow/{tableName}/{columnName}")
public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) {
+ // 创建参数映射
Map params = new HashMap();
+ // 将表名放入参数映射中
params.put("table", tableName);
+ // 将列名放入参数映射中
params.put("column", columnName);
+ // 将列值放入参数映射中
params.put("columnValue", columnValue);
+ // 调用通用服务类的方法获取单条记录
Map result = commonService.getFollowByOption(params);
+ // 返回成功响应并携带单条记录
return R.ok().put("data", result);
}
-
+
/**
* 修改table表的sfsh状态
- * @param table
- * @param map
- * @return
+ * @param tableName 表名
+ * @param map 包含修改信息的映射
+ * @return 成功响应
*/
@RequestMapping("/sh/{tableName}")
public R sh(@PathVariable("tableName") String tableName, @RequestBody Map map) {
+ // 将表名放入映射中
map.put("table", tableName);
+ // 调用通用服务类的方法修改状态
commonService.sh(map);
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 获取需要提醒的记录数
- * @param tableName
- * @param columnName
+ * @param tableName 表名
+ * @param columnName 列名
* @param type 1:数字 2:日期
- * @param map
- * @return
+ * @param map 包含查询条件的映射
+ * @return 包含提醒记录数的响应结果
*/
@IgnoreAuth
@RequestMapping("/remind/{tableName}/{columnName}/{type}")
- public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
- @PathVariable("type") String type,@RequestParam Map map) {
+ public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
+ @PathVariable("type") String type, @RequestParam Map map) {
+ // 将表名放入映射中
map.put("table", tableName);
+ // 将列名放入映射中
map.put("column", columnName);
+ // 将类型放入映射中
map.put("type", type);
-
- if(type.equals("2")) {
+
+ // 如果类型为日期
+ if (type.equals("2")) {
+ // 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建日历对象
Calendar c = Calendar.getInstance();
+ // 提醒开始日期
Date remindStartDate = null;
+ // 提醒结束日期
Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
+ // 如果提醒开始时间不为空
+ if (map.get("remindstart") != null) {
+ // 将提醒开始时间转换为整数
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
+ // 设置日历时间为当前时间
+ c.setTime(new Date());
+ // 增加指定天数
+ c.add(Calendar.DAY_OF_MONTH, remindStart);
+ // 获取提醒开始日期
remindStartDate = c.getTime();
+ // 将提醒开始日期格式化后放入映射中
map.put("remindstart", sdf.format(remindStartDate));
}
- if(map.get("remindend")!=null) {
+ // 如果提醒结束时间不为空
+ if (map.get("remindend") != null) {
+ // 将提醒结束时间转换为整数
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置日历时间为当前时间
c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
+ // 增加指定天数
+ c.add(Calendar.DAY_OF_MONTH, remindEnd);
+ // 获取提醒结束日期
remindEndDate = c.getTime();
+ // 将提醒结束日期格式化后放入映射中
map.put("remindend", sdf.format(remindEndDate));
}
}
-
+ // 调用通用服务类的方法统计提醒记录数
int count = commonService.remindCount(map);
+ // 返回成功响应并携带提醒记录数
return R.ok().put("count", count);
}
-
+
/**
* 单列求和
+ * @param tableName 表名
+ * @param columnName 列名
+ * @return 包含求和结果的响应结果
*/
@IgnoreAuth
@RequestMapping("/cal/{tableName}/{columnName}")
public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
+ // 创建参数映射
Map params = new HashMap();
+ // 将表名放入参数映射中
params.put("table", tableName);
+ // 将列名放入参数映射中
params.put("column", columnName);
+ // 调用通用服务类的方法进行单列求和
Map result = commonService.selectCal(params);
+ // 返回成功响应并携带求和结果
return R.ok().put("data", result);
}
-
+
/**
* 分组统计
+ * @param tableName 表名
+ * @param columnName 列名
+ * @return 包含分组统计结果的响应结果
*/
@IgnoreAuth
@RequestMapping("/group/{tableName}/{columnName}")
public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
+ // 创建参数映射
Map params = new HashMap();
+ // 将表名放入参数映射中
params.put("table", tableName);
+ // 将列名放入参数映射中
params.put("column", columnName);
+ // 调用通用服务类的方法进行分组统计
List> result = commonService.selectGroup(params);
+ // 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- for(Map m : result) {
- for(String k : m.keySet()) {
- if(m.get(k) instanceof Date) {
- m.put(k, sdf.format((Date)m.get(k)));
+ // 遍历统计结果
+ for (Map m : result) {
+ // 遍历结果中的键
+ for (String k : m.keySet()) {
+ // 如果值为日期类型
+ if (m.get(k) instanceof Date) {
+ // 将日期格式化后重新放入结果中
+ m.put(k, sdf.format((Date) m.get(k)));
}
}
}
+ // 返回成功响应并携带分组统计结果
return R.ok().put("data", result);
}
-
+
/**
* （按值统计）
+ * @param tableName 表名
+ * @param yColumnName y列名
+ * @param xColumnName x列名
+ * @return 包含按值统计结果的响应结果
*/
@IgnoreAuth
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) {
+ // 创建参数映射
Map params = new HashMap();
+ // 将表名放入参数映射中
params.put("table", tableName);
+ // 将x列名放入参数映射中
params.put("xColumn", xColumnName);
+ // 将y列名放入参数映射中
params.put("yColumn", yColumnName);
+ // 调用通用服务类的方法进行按值统计
List> result = commonService.selectValue(params);
+ // 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- for(Map m : result) {
- for(String k : m.keySet()) {
- if(m.get(k) instanceof Date) {
- m.put(k, sdf.format((Date)m.get(k)));
+ // 遍历统计结果
+ for (Map m : result) {
+ // 遍历结果中的键
+ for (String k : m.keySet()) {
+ // 如果值为日期类型
+ if (m.get(k) instanceof Date) {
+ // 将日期格式化后重新放入结果中
+ m.put(k, sdf.format((Date) m.get(k)));
}
}
}
+ // 返回成功响应并携带按值统计结果
return R.ok().put("data", result);
}
-
-}
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/ConfigController.java b/src/main/java/com/controller/ConfigController.java
index 6e9f123..58b430b 100644
--- a/src/main/java/com/controller/ConfigController.java
+++ b/src/main/java/com/controller/ConfigController.java
@@ -1,111 +1,156 @@
-
+// 声明该类所在的包
package com.controller;
-
+// 导入Arrays类，用于操作数组，这里主要用于处理批量删除时的ID数组
import java.util.Arrays;
+// 导入Map接口，用于存储键值对，通常用于接收请求参数
import java.util.Map;
+// 导入Spring框架的自动装配注解，用于将ConfigService注入到当前类中
import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架的路径变量注解，用于从URL路径中获取参数
import org.springframework.web.bind.annotation.PathVariable;
+// 导入Spring框架的Post请求映射注解，用于处理HTTP POST请求
import org.springframework.web.bind.annotation.PostMapping;
+// 导入Spring框架的请求体注解，用于将请求体中的数据绑定到方法参数上
import org.springframework.web.bind.annotation.RequestBody;
+// 导入Spring框架的请求映射注解，用于将HTTP请求映射到处理方法上
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入Spring框架的请求参数注解，用于从请求中获取参数
import org.springframework.web.bind.annotation.RequestParam;
+// 导入Spring框架的REST控制器注解，表明该类是一个RESTful风格的控制器
import org.springframework.web.bind.annotation.RestController;
+// 导入自定义的忽略认证注解，用于标记某些接口不需要进行认证
import com.annotation.IgnoreAuth;
+// 导入MyBatis-Plus的实体包装器类，用于构建查询条件
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入配置实体类，用于表示配置信息
import com.entity.ConfigEntity;
+// 导入配置服务类，用于处理配置信息的业务逻辑
import com.service.ConfigService;
+// 导入自定义的分页工具类，用于处理分页查询结果
import com.utils.PageUtils;
+// 导入自定义的响应结果类，用于封装接口的返回数据
import com.utils.R;
+// 导入自定义的验证工具类，用于验证实体对象的合法性
import com.utils.ValidatorUtils;
/**
* 登录相关
*/
+// 定义该控制器处理的请求路径前缀为"config"
@RequestMapping("config")
+// 声明该类为RESTful控制器
@RestController
-public class ConfigController{
-
- @Autowired
- private ConfigService configService;
+public class ConfigController {
+ // 使用自动装配将ConfigService实例注入到当前类中
+ @Autowired
+ private ConfigService configService;
- /**
+ /**
* 列表
+ * 该方法用于处理分页查询配置信息的请求
*/
@RequestMapping("/page")
- public R page(@RequestParam Map params,ConfigEntity config){
+ public R page(@RequestParam Map params, ConfigEntity config) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = configService.queryPage(params);
+ // 调用ConfigService的queryPage方法进行分页查询
+ PageUtils page = configService.queryPage(params);
+ // 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
-
- /**
+
+ /**
* 列表
+ * 该方法用于处理查询配置信息列表的请求，且该接口不需要认证
*/
@IgnoreAuth
@RequestMapping("/list")
- public R list(@RequestParam Map params,ConfigEntity config){
+ public R list(@RequestParam Map params, ConfigEntity config) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = configService.queryPage(params);
+ // 调用ConfigService的queryPage方法进行分页查询
+ PageUtils page = configService.queryPage(params);
+ // 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 信息
+ * 该方法用于根据配置信息的ID查询单个配置信息
*/
@RequestMapping("/info/{id}")
- public R info(@PathVariable("id") String id){
+ public R info(@PathVariable("id") String id) {
+ // 调用ConfigService的selectById方法根据ID查询配置信息
ConfigEntity config = configService.selectById(id);
+ // 返回成功响应，并将查询到的配置信息放入响应数据中
return R.ok().put("data", config);
}
-
+
/**
* 详情
+ * 该方法用于根据配置信息的ID查询单个配置信息详情，且该接口不需要认证
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") String id){
+ public R detail(@PathVariable("id") String id) {
+ // 调用ConfigService的selectById方法根据ID查询配置信息
ConfigEntity config = configService.selectById(id);
+ // 返回成功响应，并将查询到的配置信息放入响应数据中
return R.ok().put("data", config);
}
-
+
/**
* 根据name获取信息
+ * 该方法用于根据配置信息的名称查询单个配置信息
*/
@RequestMapping("/info")
- public R infoByName(@RequestParam String name){
+ public R infoByName(@RequestParam String name) {
+ // 调用ConfigService的selectOne方法根据名称查询配置信息，这里写死了查询"faceFile"
ConfigEntity config = configService.selectOne(new EntityWrapper().eq("name", "faceFile"));
+ // 返回成功响应，并将查询到的配置信息放入响应数据中
return R.ok().put("data", config);
}
-
+
/**
* 保存
+ * 该方法用于处理保存配置信息的请求，使用HTTP POST请求
*/
@PostMapping("/save")
- public R save(@RequestBody ConfigEntity config){
+ public R save(@RequestBody ConfigEntity config) {
+ // 注释掉的代码，原本用于验证实体对象的合法性
// ValidatorUtils.validateEntity(config);
- configService.insert(config);
+ // 调用ConfigService的insert方法将配置信息插入到数据库中
+ configService.insert(config);
+ // 返回成功响应
return R.ok();
}
/**
* 修改
+ * 该方法用于处理更新配置信息的请求
*/
@RequestMapping("/update")
- public R update(@RequestBody ConfigEntity config){
+ public R update(@RequestBody ConfigEntity config) {
+ // 注释掉的代码，原本用于验证实体对象的合法性
// ValidatorUtils.validateEntity(config);
- configService.updateById(config);//全部更新
+ // 调用ConfigService的updateById方法根据ID更新配置信息的所有字段
+ configService.updateById(config);
+ // 返回成功响应
return R.ok();
}
/**
* 删除
+ * 该方法用于处理批量删除配置信息的请求
*/
@RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
- configService.deleteBatchIds(Arrays.asList(ids));
+ public R delete(@RequestBody Long[] ids) {
+ // 调用ConfigService的deleteBatchIds方法根据ID数组批量删除配置信息
+ configService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-}
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/DiscusskechengxinxiController.java b/src/main/java/com/controller/DiscusskechengxinxiController.java
index fb52e12..8b10f25 100644
--- a/src/main/java/com/controller/DiscusskechengxinxiController.java
+++ b/src/main/java/com/controller/DiscusskechengxinxiController.java
@@ -1,207 +1,297 @@
+// 声明该类所在的包
package com.controller;
+// 导入用于格式化日期的类，可将日期对象按照指定格式转换为字符串
import java.text.SimpleDateFormat;
+// 导入动态数组类，可动态调整大小，用于存储多个元素
import java.util.ArrayList;
+// 导入用于操作数组的工具类，提供了如排序、查找等操作数组的方法
import java.util.Arrays;
+// 导入日历类，用于处理日期和时间，可进行日期的计算和转换
import java.util.Calendar;
+// 导入映射接口，用于存储键值对，方便通过键快速查找对应的值
import java.util.Map;
+// 导入哈希映射类，是Map接口的一个实现类，使用哈希表存储键值对
import java.util.HashMap;
+// 导入迭代器接口，用于遍历集合中的元素
import java.util.Iterator;
+// 导入日期类，用于表示特定的瞬间
import java.util.Date;
+// 导入列表接口，是有序集合，可存储重复元素
import java.util.List;
+// 导入用于处理HTTP请求的类，可获取请求的各种信息，如参数、头信息等
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类，可用于验证实体对象的属性是否符合要求
import com.utils.ValidatorUtils;
+// 导入Apache Commons Lang库中的字符串工具类，提供了丰富的字符串处理方法
import org.apache.commons.lang3.StringUtils;
+// 导入Spring框架的自动装配注解，用于将依赖的对象自动注入到当前类中
import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架的日期格式化注解，可将请求参数中的日期字符串按照指定格式转换为日期对象
import org.springframework.format.annotation.DateTimeFormat;
+// 导入Spring框架的路径变量注解，用于从URL路径中提取参数
import org.springframework.web.bind.annotation.PathVariable;
+// 导入Spring框架的请求体注解，用于将请求体中的数据绑定到方法参数上
import org.springframework.web.bind.annotation.RequestBody;
+// 导入Spring框架的请求映射注解，用于将HTTP请求映射到对应的处理方法上
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入Spring框架的请求参数注解，用于从请求中获取参数
import org.springframework.web.bind.annotation.RequestParam;
+// 导入Spring框架的REST控制器注解，表明该类是一个RESTful风格的控制器
import org.springframework.web.bind.annotation.RestController;
+// 导入MyBatis-Plus的实体包装器类，用于构建查询条件
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的包装器接口，是EntityWrapper的父接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解，用于标记某些接口不需要进行认证
import com.annotation.IgnoreAuth;
+// 导入课程信息评论实体类，用于表示课程信息评论的数据结构
import com.entity.DiscusskechengxinxiEntity;
+// 导入课程信息评论视图类，可能用于展示课程信息评论的特定视图
import com.entity.view.DiscusskechengxinxiView;
+// 导入课程信息评论服务类，用于处理课程信息评论的业务逻辑
import com.service.DiscusskechengxinxiService;
+// 导入令牌服务类，可能用于处理用户认证和授权相关的令牌
import com.service.TokenService;
+// 导入自定义的分页工具类，用于处理分页查询的结果
import com.utils.PageUtils;
+// 导入自定义的响应结果类，用于封装接口的返回数据，统一返回格式
import com.utils.R;
+// 导入自定义的MD5工具类，用于进行MD5加密操作
import com.utils.MD5Util;
+// 导入自定义的MyBatis-Plus工具类，提供了一些方便使用MyBatis-Plus的方法
import com.utils.MPUtil;
+// 导入自定义的通用工具类，包含一些通用的工具方法
import com.utils.CommonUtil;
/**
* 课程信息评论表
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:15
*/
+// 声明该类为RESTful风格的控制器
@RestController
+// 定义该控制器处理的请求路径前缀
@RequestMapping("/discusskechengxinxi")
public class DiscusskechengxinxiController {
+ // 使用自动装配将DiscusskechengxinxiService注入到当前类中
@Autowired
private DiscusskechengxinxiService discusskechengxinxiService;
-
-
/**
* 后端列表
+ * 该方法用于处理后端分页查询课程信息评论列表的请求
*/
@RequestMapping("/page")
- public R page(@RequestParam Map params,DiscusskechengxinxiEntity discusskechengxinxi,
- HttpServletRequest request){
+ public R page(@RequestParam Map params, DiscusskechengxinxiEntity discusskechengxinxi,
+ HttpServletRequest request) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = discusskechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, discusskechengxinxi), params), params));
-
+ // 调用DiscusskechengxinxiService的queryPage方法进行分页查询
+ PageUtils page = discusskechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, discusskechengxinxi), params), params));
+ // 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
-
+
/**
* 前端列表
+ * 该方法用于处理前端分页查询课程信息评论列表的请求，且该接口不需要认证
*/
- @IgnoreAuth
+ @IgnoreAuth
@RequestMapping("/list")
- public R list(@RequestParam Map params,DiscusskechengxinxiEntity discusskechengxinxi,
- HttpServletRequest request){
+ public R list(@RequestParam Map params, DiscusskechengxinxiEntity discusskechengxinxi,
+ HttpServletRequest request) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = discusskechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, discusskechengxinxi), params), params));
+ // 调用DiscusskechengxinxiService的queryPage方法进行分页查询
+ PageUtils page = discusskechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, discusskechengxinxi), params), params));
+ // 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
- /**
+ /**
* 列表
+ * 该方法用于查询课程信息评论列表，根据传入的实体对象构建查询条件
*/
@RequestMapping("/lists")
- public R list( DiscusskechengxinxiEntity discusskechengxinxi){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( discusskechengxinxi, "discusskechengxinxi"));
+ public R list(DiscusskechengxinxiEntity discusskechengxinxi) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，将实体对象的属性作为查询条件
+ ew.allEq(MPUtil.allEQMapPre(discusskechengxinxi, "discusskechengxinxi"));
+ // 调用DiscusskechengxinxiService的selectListView方法查询列表数据
return R.ok().put("data", discusskechengxinxiService.selectListView(ew));
}
- /**
+ /**
* 查询
+ * 该方法用于根据传入的实体对象查询单个课程信息评论视图
*/
@RequestMapping("/query")
- public R query(DiscusskechengxinxiEntity discusskechengxinxi){
- EntityWrapper< DiscusskechengxinxiEntity> ew = new EntityWrapper< DiscusskechengxinxiEntity>();
- ew.allEq(MPUtil.allEQMapPre( discusskechengxinxi, "discusskechengxinxi"));
- DiscusskechengxinxiView discusskechengxinxiView = discusskechengxinxiService.selectView(ew);
- return R.ok("查询课程信息评论表成功").put("data", discusskechengxinxiView);
+ public R query(DiscusskechengxinxiEntity discusskechengxinxi) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，将实体对象的属性作为查询条件
+ ew.allEq(MPUtil.allEQMapPre(discusskechengxinxi, "discusskechengxinxi"));
+ // 调用DiscusskechengxinxiService的selectView方法查询单个视图数据
+ DiscusskechengxinxiView discusskechengxinxiView = discusskechengxinxiService.selectView(ew);
+ // 返回成功响应，并将查询结果放入响应数据中
+ return R.ok("查询课程信息评论表成功").put("data", discusskechengxinxiView);
}
-
+
/**
* 后端详情
+ * 该方法用于根据ID查询单个课程信息评论的详细信息
*/
@RequestMapping("/info/{id}")
- public R info(@PathVariable("id") Long id){
+ public R info(@PathVariable("id") Long id) {
+ // 调用DiscusskechengxinxiService的selectById方法根据ID查询课程信息评论
DiscusskechengxinxiEntity discusskechengxinxi = discusskechengxinxiService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应数据中
return R.ok().put("data", discusskechengxinxi);
}
/**
* 前端详情
+ * 该方法用于根据ID查询单个课程信息评论的详细信息
*/
@RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") Long id){
+ public R detail(@PathVariable("id") Long id) {
+ // 调用DiscusskechengxinxiService的selectById方法根据ID查询课程信息评论
DiscusskechengxinxiEntity discusskechengxinxi = discusskechengxinxiService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应数据中
return R.ok().put("data", discusskechengxinxi);
}
-
-
-
/**
* 后端保存
+ * 该方法用于处理后端保存课程信息评论的请求
*/
@RequestMapping("/save")
- public R save(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request){
- discusskechengxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(discusskechengxinxi);
+ public R save(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request) {
+ // 为课程信息评论生成一个唯一的ID，使用当前时间戳加上一个随机数
+ discusskechengxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 注释掉的代码，原本用于验证实体对象的合法性
+ //ValidatorUtils.validateEntity(discusskechengxinxi);
+ // 调用DiscusskechengxinxiService的insert方法将课程信息评论插入到数据库中
discusskechengxinxiService.insert(discusskechengxinxi);
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 前端保存
+ * 该方法用于处理前端保存课程信息评论的请求
*/
@RequestMapping("/add")
- public R add(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request){
- discusskechengxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(discusskechengxinxi);
+ public R add(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request) {
+ // 为课程信息评论生成一个唯一的ID，使用当前时间戳加上一个随机数
+ discusskechengxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 注释掉的代码，原本用于验证实体对象的合法性
+ //ValidatorUtils.validateEntity(discusskechengxinxi);
+ // 调用DiscusskechengxinxiService的insert方法将课程信息评论插入到数据库中
discusskechengxinxiService.insert(discusskechengxinxi);
+ // 返回成功响应
return R.ok();
}
/**
* 修改
+ * 该方法用于处理更新课程信息评论的请求
*/
@RequestMapping("/update")
- public R update(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request){
+ public R update(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request) {
+ // 注释掉的代码，原本用于验证实体对象的合法性
//ValidatorUtils.validateEntity(discusskechengxinxi);
- discusskechengxinxiService.updateById(discusskechengxinxi);//全部更新
+ // 调用DiscusskechengxinxiService的updateById方法根据ID更新课程信息评论的所有字段
+ discusskechengxinxiService.updateById(discusskechengxinxi);
+ // 返回成功响应
return R.ok();
}
-
/**
* 删除
+ * 该方法用于处理批量删除课程信息评论的请求
*/
@RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
+ public R delete(@RequestBody Long[] ids) {
+ // 调用DiscusskechengxinxiService的deleteBatchIds方法根据ID数组批量删除课程信息评论
discusskechengxinxiService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 提醒接口
+ * 该方法用于统计符合提醒条件的课程信息评论数量
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
-
-
- int count = discusskechengxinxiService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
-
-
-}
+ @RequestMapping("/remind/{columnName}/{type}")
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type, @RequestParam Map map) {
+ // 将列名和类型放入请求参数映射中
+ map.put("column", columnName);
+ map.put("type", type);
+
+ // 如果类型为2，表示日期类型的提醒
+ if (type.equals("2")) {
+ // 创建一个日期格式化对象，用于将日期对象格式化为指定格式的字符串
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建一个日历对象，用于进行日期的计算和操作
+ Calendar c = Calendar.getInstance();
+ // 提醒开始日期
+ Date remindStartDate = null;
+ // 提醒结束日期
+ Date remindEndDate = null;
+ // 如果请求参数中包含提醒开始时间
+ if (map.get("remindstart") != null) {
+ // 将提醒开始时间转换为整数
+ Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+ // 设置日历对象的时间为当前时间
+ c.setTime(new Date());
+ // 在当前时间基础上增加指定的天数
+ c.add(Calendar.DAY_OF_MONTH, remindStart);
+ // 获取增加天数后的日期
+ remindStartDate = c.getTime();
+ // 将提醒开始日期格式化为字符串并放入请求参数映射中
+ map.put("remindstart", sdf.format(remindStartDate));
+ }
+ // 如果请求参数中包含提醒结束时间
+ if (map.get("remindend") != null) {
+ // 将提醒结束时间转换为整数
+ Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置日历对象的时间为当前时间
+ c.setTime(new Date());
+ // 在当前时间基础上增加指定的天数
+ c.add(Calendar.DAY_OF_MONTH, remindEnd);
+ // 获取增加天数后的日期
+ remindEndDate = c.getTime();
+ // 将提醒结束日期格式化为字符串并放入请求参数映射中
+ map.put("remindend", sdf.format(remindEndDate));
+ }
+ }
+
+ // 创建一个EntityWrapper对象，用于构建查询条件
+ Wrapper wrapper = new EntityWrapper();
+ // 如果请求参数中包含提醒开始时间
+ if (map.get("remindstart") != null) {
+ // 设置查询条件，列名大于等于提醒开始时间
+ wrapper.ge(columnName, map.get("remindstart"));
+ }
+ // 如果请求参数中包含提醒结束时间
+ if (map.get("remindend") != null) {
+ // 设置查询条件，列名小于等于提醒结束时间
+ wrapper.le(columnName, map.get("remindend"));
+ }
+
+ // 调用DiscusskechengxinxiService的selectCount方法统计符合条件的记录数量
+ int count = discusskechengxinxiService.selectCount(wrapper);
+ // 返回成功响应，并将统计结果放入响应数据中
+ return R.ok().put("count", count);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/ExampaperController.java b/src/main/java/com/controller/ExampaperController.java
index b1c75a3..4731ab5 100644
--- a/src/main/java/com/controller/ExampaperController.java
+++ b/src/main/java/com/controller/ExampaperController.java
@@ -1,206 +1,295 @@
+// 声明该类所在的包
package com.controller;
+// 导入用于格式化日期的类，可将日期对象按指定格式转换为字符串
import java.text.SimpleDateFormat;
+// 导入动态数组类，可动态调整大小来存储多个元素
import java.util.ArrayList;
+// 导入用于操作数组的工具类，提供排序、查找等数组操作方法
import java.util.Arrays;
+// 导入日历类，用于处理日期和时间，可进行日期计算和转换
import java.util.Calendar;
+// 导入映射接口，用于存储键值对，方便通过键快速查找对应值
import java.util.Map;
+// 导入哈希映射类，是Map接口的实现类，使用哈希表存储键值对
import java.util.HashMap;
+// 导入迭代器接口，用于遍历集合中的元素
import java.util.Iterator;
+// 导入日期类，用于表示特定的瞬间
import java.util.Date;
+// 导入列表接口，是有序集合，可存储重复元素
import java.util.List;
+// 导入用于处理HTTP请求的类，可获取请求的参数、头信息等
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类，用于验证实体对象属性是否符合要求
import com.utils.ValidatorUtils;
+// 导入Apache Commons Lang库中的字符串工具类，提供丰富的字符串处理方法
import org.apache.commons.lang3.StringUtils;
+// 导入Spring框架的自动装配注解，用于将依赖对象自动注入当前类
import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架的日期格式化注解，可将请求参数中的日期字符串按指定格式转换为日期对象
import org.springframework.format.annotation.DateTimeFormat;
+// 导入Spring框架的路径变量注解，用于从URL路径中提取参数
import org.springframework.web.bind.annotation.PathVariable;
+// 导入Spring框架的请求体注解，用于将请求体中的数据绑定到方法参数上
import org.springframework.web.bind.annotation.RequestBody;
+// 导入Spring框架的请求映射注解，用于将HTTP请求映射到对应的处理方法
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入Spring框架的请求参数注解，用于从请求中获取参数
import org.springframework.web.bind.annotation.RequestParam;
+// 导入Spring框架的REST控制器注解，表明该类是RESTful风格的控制器
import org.springframework.web.bind.annotation.RestController;
+// 导入MyBatis-Plus的实体包装器类，用于构建查询条件
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的包装器接口，是EntityWrapper的父接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解，用于标记某些接口不需要认证
import com.annotation.IgnoreAuth;
+// 导入试卷实体类，用于表示试卷的数据结构
import com.entity.ExampaperEntity;
+// 导入试卷视图类，可能用于展示试卷的特定视图
import com.entity.view.ExampaperView;
+// 导入试卷服务类，用于处理试卷的业务逻辑
import com.service.ExampaperService;
+// 导入令牌服务类，可能用于处理用户认证和授权相关的令牌
import com.service.TokenService;
+// 导入自定义的分页工具类，用于处理分页查询结果
import com.utils.PageUtils;
+// 导入自定义的响应结果类，用于封装接口的返回数据，统一返回格式
import com.utils.R;
+// 导入自定义的MD5工具类，用于进行MD5加密操作
import com.utils.MD5Util;
+// 导入自定义的MyBatis-Plus工具类，提供方便使用MyBatis-Plus的方法
import com.utils.MPUtil;
+// 导入自定义的通用工具类，包含一些通用的工具方法
import com.utils.CommonUtil;
-
/**
* 试卷表
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:15
*/
+// 声明该类为RESTful风格的控制器
@RestController
+// 定义该控制器处理的请求路径前缀
@RequestMapping("/exampaper")
public class ExampaperController {
+ // 使用自动装配将ExampaperService注入到当前类中
@Autowired
private ExampaperService exampaperService;
-
-
/**
* 后端列表
+ * 处理后端分页查询试卷列表的请求
*/
@RequestMapping("/page")
- public R page(@RequestParam Map params,ExampaperEntity exampaper,
- HttpServletRequest request){
+ public R page(@RequestParam Map params, ExampaperEntity exampaper,
+ HttpServletRequest request) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = exampaperService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, exampaper), params), params));
-
+ // 调用ExampaperService的queryPage方法进行分页查询，同时对查询条件进行排序、范围和模糊查询等处理
+ PageUtils page = exampaperService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, exampaper), params), params));
+ // 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
-
+
/**
* 前端列表
+ * 处理前端分页查询试卷列表的请求
*/
@RequestMapping("/list")
- public R list(@RequestParam Map params,ExampaperEntity exampaper,
- HttpServletRequest request){
+ public R list(@RequestParam Map params, ExampaperEntity exampaper,
+ HttpServletRequest request) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = exampaperService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, exampaper), params), params));
+ // 调用ExampaperService的queryPage方法进行分页查询，同时对查询条件进行排序、范围和模糊查询等处理
+ PageUtils page = exampaperService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, exampaper), params), params));
+ // 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
- /**
+ /**
* 列表
+ * 根据传入的试卷实体对象构建查询条件，查询试卷列表
*/
@RequestMapping("/lists")
- public R list( ExampaperEntity exampaper){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( exampaper, "exampaper"));
+ public R list(ExampaperEntity exampaper) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，将实体对象的属性作为查询条件
+ ew.allEq(MPUtil.allEQMapPre(exampaper, "exampaper"));
+ // 调用ExampaperService的selectListView方法查询列表数据
return R.ok().put("data", exampaperService.selectListView(ew));
}
- /**
+ /**
* 查询
+ * 根据传入的试卷实体对象构建查询条件，查询单个试卷视图
*/
@RequestMapping("/query")
- public R query(ExampaperEntity exampaper){
- EntityWrapper< ExampaperEntity> ew = new EntityWrapper< ExampaperEntity>();
- ew.allEq(MPUtil.allEQMapPre( exampaper, "exampaper"));
- ExampaperView exampaperView = exampaperService.selectView(ew);
- return R.ok("查询试卷表成功").put("data", exampaperView);
+ public R query(ExampaperEntity exampaper) {
+ // 创建一个EntityWrapper对象，用于构建查询条件
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，将实体对象的属性作为查询条件
+ ew.allEq(MPUtil.allEQMapPre(exampaper, "exampaper"));
+ // 调用ExampaperService的selectView方法查询单个视图数据
+ ExampaperView exampaperView = exampaperService.selectView(ew);
+ // 返回成功响应，并将查询结果放入响应数据中
+ return R.ok("查询试卷表成功").put("data", exampaperView);
}
-
+
/**
* 后端详情
+ * 根据ID查询单个试卷的详细信息
*/
@RequestMapping("/info/{id}")
- public R info(@PathVariable("id") Long id){
+ public R info(@PathVariable("id") Long id) {
+ // 调用ExampaperService的selectById方法根据ID查询试卷信息
ExampaperEntity exampaper = exampaperService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应数据中
return R.ok().put("data", exampaper);
}
/**
* 前端详情
+ * 根据ID查询单个试卷的详细信息
*/
@RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") Long id){
+ public R detail(@PathVariable("id") Long id) {
+ // 调用ExampaperService的selectById方法根据ID查询试卷信息
ExampaperEntity exampaper = exampaperService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应数据中
return R.ok().put("data", exampaper);
}
-
-
-
/**
* 后端保存
+ * 处理后端保存试卷的请求
*/
@RequestMapping("/save")
- public R save(@RequestBody ExampaperEntity exampaper, HttpServletRequest request){
- exampaper.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(exampaper);
+ public R save(@RequestBody ExampaperEntity exampaper, HttpServletRequest request) {
+ // 为试卷生成一个唯一的ID，使用当前时间戳加上一个随机数
+ exampaper.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 注释掉的代码，原本用于验证实体对象的合法性
+ //ValidatorUtils.validateEntity(exampaper);
+ // 调用ExampaperService的insert方法将试卷信息插入到数据库中
exampaperService.insert(exampaper);
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 前端保存
+ * 处理前端保存试卷的请求
*/
@RequestMapping("/add")
- public R add(@RequestBody ExampaperEntity exampaper, HttpServletRequest request){
- exampaper.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(exampaper);
+ public R add(@RequestBody ExampaperEntity exampaper, HttpServletRequest request) {
+ // 为试卷生成一个唯一的ID，使用当前时间戳加上一个随机数
+ exampaper.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 注释掉的代码，原本用于验证实体对象的合法性
+ //ValidatorUtils.validateEntity(exampaper);
+ // 调用ExampaperService的insert方法将试卷信息插入到数据库中
exampaperService.insert(exampaper);
+ // 返回成功响应
return R.ok();
}
/**
* 修改
+ * 处理更新试卷信息的请求
*/
@RequestMapping("/update")
- public R update(@RequestBody ExampaperEntity exampaper, HttpServletRequest request){
+ public R update(@RequestBody ExampaperEntity exampaper, HttpServletRequest request) {
+ // 注释掉的代码，原本用于验证实体对象的合法性
//ValidatorUtils.validateEntity(exampaper);
- exampaperService.updateById(exampaper);//全部更新
+ // 调用ExampaperService的updateById方法根据ID更新试卷信息的所有字段
+ exampaperService.updateById(exampaper);
+ // 返回成功响应
return R.ok();
}
-
/**
* 删除
+ * 处理批量删除试卷的请求
*/
@RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
+ public R delete(@RequestBody Long[] ids) {
+ // 调用ExampaperService的deleteBatchIds方法根据ID数组批量删除试卷信息
exampaperService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 提醒接口
+ * 统计符合提醒条件的试卷数量
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
-
-
- int count = exampaperService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
-
-
-}
+ @RequestMapping("/remind/{columnName}/{type}")
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type, @RequestParam Map map) {
+ // 将列名和类型放入请求参数映射中
+ map.put("column", columnName);
+ map.put("type", type);
+
+ // 如果类型为2，表示日期类型的提醒
+ if (type.equals("2")) {
+ // 创建一个日期格式化对象，用于将日期对象格式化为指定格式的字符串
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建一个日历对象，用于进行日期的计算和操作
+ Calendar c = Calendar.getInstance();
+ // 提醒开始日期
+ Date remindStartDate = null;
+ // 提醒结束日期
+ Date remindEndDate = null;
+ // 如果请求参数中包含提醒开始时间
+ if (map.get("remindstart") != null) {
+ // 将提醒开始时间转换为整数
+ Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+ // 设置日历对象的时间为当前时间
+ c.setTime(new Date());
+ // 在当前时间基础上增加指定的天数
+ c.add(Calendar.DAY_OF_MONTH, remindStart);
+ // 获取增加天数后的日期
+ remindStartDate = c.getTime();
+ // 将提醒开始日期格式化为字符串并放入请求参数映射中
+ map.put("remindstart", sdf.format(remindStartDate));
+ }
+ // 如果请求参数中包含提醒结束时间
+ if (map.get("remindend") != null) {
+ // 将提醒结束时间转换为整数
+ Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置日历对象的时间为当前时间
+ c.setTime(new Date());
+ // 在当前时间基础上增加指定的天数
+ c.add(Calendar.DAY_OF_MONTH, remindEnd);
+ // 获取增加天数后的日期
+ remindEndDate = c.getTime();
+ // 将提醒结束日期格式化为字符串并放入请求参数映射中
+ map.put("remindend", sdf.format(remindEndDate));
+ }
+ }
+
+ // 创建一个EntityWrapper对象，用于构建查询条件
+ Wrapper wrapper = new EntityWrapper();
+ // 如果请求参数中包含提醒开始时间
+ if (map.get("remindstart") != null) {
+ // 设置查询条件，列名大于等于提醒开始时间
+ wrapper.ge(columnName, map.get("remindstart"));
+ }
+ // 如果请求参数中包含提醒结束时间
+ if (map.get("remindend") != null) {
+ // 设置查询条件，列名小于等于提醒结束时间
+ wrapper.le(columnName, map.get("remindend"));
+ }
+
+ // 调用ExampaperService的selectCount方法统计符合条件的记录数量
+ int count = exampaperService.selectCount(wrapper);
+ // 返回成功响应，并将统计结果放入响应数据中
+ return R.ok().put("count", count);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/ExamquestionController.java b/src/main/java/com/controller/ExamquestionController.java
index a8b8e03..90f09fb 100644
--- a/src/main/java/com/controller/ExamquestionController.java
+++ b/src/main/java/com/controller/ExamquestionController.java
@@ -1,206 +1,315 @@
package com.controller;
+// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
+// 导入用于创建和操作动态数组的类
import java.util.ArrayList;
+// 导入用于操作数组的工具类
import java.util.Arrays;
+// 导入用于处理日期和时间的类
import java.util.Calendar;
+// 导入用于表示键值对映射的接口
import java.util.Map;
+// 导入用于实现 Map 接口的类
import java.util.HashMap;
+// 导入用于遍历集合的迭代器接口
import java.util.Iterator;
+// 导入用于表示日期的类
import java.util.Date;
+// 导入用于表示列表的接口
import java.util.List;
+// 导入用于处理 HTTP 请求的类
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
+// 导入 Apache Commons Lang 库中的字符串处理工具类
import org.apache.commons.lang3.StringUtils;
+// 导入 Spring 框架中的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 框架中用于日期格式化的注解
import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Spring 框架中用于处理路径变量的注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入 Spring 框架中用于处理请求体的注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入 Spring 框架中用于处理请求映射的注解
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 框架中用于处理请求参数的注解
import org.springframework.web.bind.annotation.RequestParam;
+// 导入 Spring 框架中用于将类标记为 RESTful 控制器的注解
import org.springframework.web.bind.annotation.RestController;
+// 导入 MyBatis-Plus 框架中用于构建查询条件的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入 MyBatis-Plus 框架中用于构建查询条件的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入试题实体类
import com.entity.ExamquestionEntity;
+// 导入试题视图类
import com.entity.view.ExamquestionView;
+// 导入试题服务类
import com.service.ExamquestionService;
+// 导入令牌服务类
import com.service.TokenService;
+// 导入自定义的分页工具类
import com.utils.PageUtils;
+// 导入自定义的返回结果工具类
import com.utils.R;
+// 导入自定义的 MD5 加密工具类
import com.utils.MD5Util;
+// 导入自定义的 MyBatis-Plus 工具类
import com.utils.MPUtil;
+// 导入自定义的通用工具类
import com.utils.CommonUtil;
/**
* 试题表
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:15
*/
+// 将该类标记为 RESTful 控制器，用于处理 HTTP 请求
@RestController
+// 定义该控制器处理的请求路径前缀
@RequestMapping("/examquestion")
public class ExamquestionController {
+ // 自动注入试题服务类的实例
@Autowired
private ExamquestionService examquestionService;
-
+
/**
* 后端列表
*/
+ // 处理 /examquestion/page 路径的请求
@RequestMapping("/page")
+ // 该方法用于获取试题的分页列表
public R page(@RequestParam Map params,ExamquestionEntity examquestion,
- HttpServletRequest request){
+ HttpServletRequest request){
+ // 创建一个用于构建查询条件的实体包装器
EntityWrapper ew = new EntityWrapper();
- PageUtils page = examquestionService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examquestion), params), params));
+ // 调用试题服务类的 queryPage 方法进行分页查询
+ PageUtils page = examquestionService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examquestion), params), params));
- return R.ok().put("data", page);
+ // 返回成功响应，并将分页数据放入响应结果中
+ return R.ok().put("data", page);//测试
}
-
+
/**
* 前端列表
*/
+ // 处理 /examquestion/list 路径的请求
@RequestMapping("/list")
- public R list(@RequestParam Map params,ExamquestionEntity examquestion,
- HttpServletRequest request){
+ // 该方法用于获取试题的分页列表（前端使用）
+ public R list(@RequestParam Map params,ExamquestionEntity examquestion,
+ HttpServletRequest request){
+ // 创建一个用于构建查询条件的实体包装器
EntityWrapper ew = new EntityWrapper();
- PageUtils page = examquestionService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examquestion), params), params));
+ // 调用试题服务类的 queryPage 方法进行分页查询
+ PageUtils page = examquestionService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examquestion), params), params));
+ // 返回成功响应，并将分页数据放入响应结果中
return R.ok().put("data", page);
}
- /**
+ /**
* 列表
*/
+ // 处理 /examquestion/lists 路径的请求
@RequestMapping("/lists")
+ // 该方法用于获取试题列表
public R list( ExamquestionEntity examquestion){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( examquestion, "examquestion"));
+ // 创建一个用于构建查询条件的实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件为所有字段相等
+ ew.allEq(MPUtil.allEQMapPre( examquestion, "examquestion"));
+ // 返回成功响应，并将查询到的试题列表放入响应结果中
return R.ok().put("data", examquestionService.selectListView(ew));
}
- /**
+ /**
* 查询
*/
+ // 处理 /examquestion/query 路径的请求
@RequestMapping("/query")
+ // 该方法用于查询单个试题信息
public R query(ExamquestionEntity examquestion){
+ // 创建一个用于构建查询条件的实体包装器
EntityWrapper< ExamquestionEntity> ew = new EntityWrapper< ExamquestionEntity>();
- ew.allEq(MPUtil.allEQMapPre( examquestion, "examquestion"));
- ExamquestionView examquestionView = examquestionService.selectView(ew);
- return R.ok("查询试题表成功").put("data", examquestionView);
+ // 设置查询条件为所有字段相等
+ ew.allEq(MPUtil.allEQMapPre( examquestion, "examquestion"));
+ // 调用试题服务类的 selectView 方法查询单个试题信息
+ ExamquestionView examquestionView = examquestionService.selectView(ew);
+ // 返回成功响应，并将查询到的试题信息放入响应结果中
+ return R.ok("查询试题表成功").put("data", examquestionView);
}
-
+
/**
* 后端详情
*/
+ // 处理 /examquestion/info/{id} 路径的请求，{id} 为路径变量
@RequestMapping("/info/{id}")
+ // 该方法用于获取单个试题的详细信息
public R info(@PathVariable("id") Long id){
+ // 调用试题服务类的 selectById 方法根据 ID 查询试题信息
ExamquestionEntity examquestion = examquestionService.selectById(id);
+ // 返回成功响应，并将查询到的试题信息放入响应结果中
return R.ok().put("data", examquestion);
}
/**
* 前端详情
*/
+ // 处理 /examquestion/detail/{id} 路径的请求，{id} 为路径变量
@RequestMapping("/detail/{id}")
+ // 该方法用于获取单个试题的详细信息（前端使用）
public R detail(@PathVariable("id") Long id){
+ // 调用试题服务类的 selectById 方法根据 ID 查询试题信息
ExamquestionEntity examquestion = examquestionService.selectById(id);
+ // 返回成功响应，并将查询到的试题信息放入响应结果中
return R.ok().put("data", examquestion);
}
-
+
/**
* 后端保存
*/
+ // 处理 /examquestion/save 路径的 POST 请求
@RequestMapping("/save")
+ // 该方法用于保存新的试题信息
public R save(@RequestBody ExamquestionEntity examquestion, HttpServletRequest request){
- examquestion.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(examquestion);
+ // 为试题设置一个唯一的 ID，由当前时间戳加上一个随机数组成
+ examquestion.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
+ // 暂时注释掉实体验证逻辑
+ //ValidatorUtils.validateEntity(examquestion);
+ // 调用试题服务类的 insert 方法将试题信息插入数据库
examquestionService.insert(examquestion);
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 前端保存
*/
+ // 处理 /examquestion/add 路径的 POST 请求
@RequestMapping("/add")
+ // 该方法用于保存新的试题信息（前端使用）
public R add(@RequestBody ExamquestionEntity examquestion, HttpServletRequest request){
- examquestion.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(examquestion);
+ // 为试题设置一个唯一的 ID，由当前时间戳加上一个随机数组成
+ examquestion.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
+ // 暂时注释掉实体验证逻辑
+ //ValidatorUtils.validateEntity(examquestion);
+ // 调用试题服务类的 insert 方法将试题信息插入数据库
examquestionService.insert(examquestion);
+ // 返回成功响应
return R.ok();
}
/**
* 修改
*/
+ // 处理 /examquestion/update 路径的 POST 请求
@RequestMapping("/update")
+ // 该方法用于更新试题信息
public R update(@RequestBody ExamquestionEntity examquestion, HttpServletRequest request){
+ // 暂时注释掉实体验证逻辑
//ValidatorUtils.validateEntity(examquestion);
+ // 调用试题服务类的 updateById 方法根据 ID 更新试题信息
examquestionService.updateById(examquestion);//全部更新
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 删除
*/
+ // 处理 /examquestion/delete 路径的 POST 请求
@RequestMapping("/delete")
+ // 该方法用于批量删除试题信息
public R delete(@RequestBody Long[] ids){
+ // 调用试题服务类的 deleteBatchIds 方法根据 ID 批量删除试题信息
examquestionService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 提醒接口
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
-
-
- int count = examquestionService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
-
-
-}
+ // 处理 /examquestion/remind/{columnName}/{type} 路径的请求，{columnName} 和 {type} 为路径变量
+ @RequestMapping("/remind/{columnName}/{type}")
+ // 该方法用于统计符合提醒条件的试题数量
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type,@RequestParam Map map) {
+ // 将列名和提醒类型放入请求参数中
+ map.put("column", columnName);
+ map.put("type", type);
+
+ // 如果提醒类型为 2
+ if(type.equals("2")) {
+ // 创建一个用于格式化日期的对象
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建一个 Calendar 实例用于处理日期
+ Calendar c = Calendar.getInstance();
+ // 定义提醒开始日期和结束日期
+ Date remindStartDate = null;
+ Date remindEndDate = null;
+ // 如果请求参数中包含提醒开始时间
+ if(map.get("remindstart")!=null) {
+ // 将提醒开始时间转换为整数
+ Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+ // 设置 Calendar 的时间为当前时间
+ c.setTime(new Date());
+ // 在当前时间基础上加上提醒开始时间的天数
+ c.add(Calendar.DAY_OF_MONTH,remindStart);
+ // 获取提醒开始日期
+ remindStartDate = c.getTime();
+ // 将格式化后的提醒开始日期放入请求参数中
+ map.put("remindstart", sdf.format(remindStartDate));
+ }
+ // 如果请求参数中包含提醒结束时间
+ if(map.get("remindend")!=null) {
+ // 将提醒结束时间转换为整数
+ Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置 Calendar 的时间为当前时间
+ c.setTime(new Date());
+ // 在当前时间基础上加上提醒结束时间的天数
+ c.add(Calendar.DAY_OF_MONTH,remindEnd);
+ // 获取提醒结束日期
+ remindEndDate = c.getTime();
+ // 将格式化后的提醒结束日期放入请求参数中
+ map.put("remindend", sdf.format(remindEndDate));
+ }
+ }
+
+ // 创建一个用于构建查询条件的包装器
+ Wrapper wrapper = new EntityWrapper();
+ // 如果请求参数中包含提醒开始时间
+ if(map.get("remindstart")!=null) {
+ // 设置查询条件为列值大于等于提醒开始时间
+ wrapper.ge(columnName, map.get("remindstart"));
+ }
+ // 如果请求参数中包含提醒结束时间
+ if(map.get("remindend")!=null) {
+ // 设置查询条件为列值小于等于提醒结束时间
+ wrapper.le(columnName, map.get("remindend"));
+ }
+
+
+ // 调用试题服务类的 selectCount 方法统计符合条件的试题数量
+ int count = examquestionService.selectCount(wrapper);
+ // 返回成功响应，并将统计结果放入响应结果中
+ return R.ok().put("count", count);
+ }
+
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/ExamrecordController.java b/src/main/java/com/controller/ExamrecordController.java
index 1b8174b..15169c2 100644
--- a/src/main/java/com/controller/ExamrecordController.java
+++ b/src/main/java/com/controller/ExamrecordController.java
@@ -1,238 +1,369 @@
package com.controller;
+// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
+// 导入 ArrayList 类，用于创建动态数组
import java.util.ArrayList;
+// 导入 Arrays 类，用于操作数组
import java.util.Arrays;
+// 导入 Calendar 类，用于处理日期和时间
import java.util.Calendar;
+// 导入 Map 接口，用于存储键值对
import java.util.Map;
+// 导入 HashMap 类，实现了 Map 接口
import java.util.HashMap;
+// 导入 Iterator 接口，用于遍历集合
import java.util.Iterator;
+// 导入 Date 类，用于表示日期和时间
import java.util.Date;
+// 导入 List 接口，用于创建列表
import java.util.List;
+// 导入 HttpServletRequest 类，用于处理 HTTP 请求
import javax.servlet.http.HttpServletRequest;
+// 导入验证工具类
import com.utils.ValidatorUtils;
+// 导入 Apache Commons Lang 库中的 StringUtils 类，用于处理字符串
import org.apache.commons.lang3.StringUtils;
+// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Spring 框架的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入 Spring 框架的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入 Spring 框架的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 框架的请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
+// 导入 Spring 框架的 REST 控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入 MyBatis-Plus 的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入 MyBatis-Plus 的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入考试记录实体类
import com.entity.ExamrecordEntity;
+// 导入考试记录视图类
import com.entity.view.ExamrecordView;
+// 导入考试记录服务类
import com.service.ExamrecordService;
+// 导入令牌服务类
import com.service.TokenService;
+// 导入分页工具类
import com.utils.PageUtils;
+// 导入自定义的响应类
import com.utils.R;
+// 导入 MD5 加密工具类
import com.utils.MD5Util;
+// 导入 MyBatis-Plus 工具类
import com.utils.MPUtil;
+// 导入通用工具类
import com.utils.CommonUtil;
/**
* 考试记录表
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:15
*/
+// 声明为 REST 控制器，用于处理 HTTP 请求
@RestController
+// 映射请求路径，所有以 /examrecord 开头的请求都会被该控制器处理
@RequestMapping("/examrecord")
public class ExamrecordController {
+ // 自动注入考试记录服务类的实例
@Autowired
private ExamrecordService examrecordService;
-
- /**
+
+ /**
* 考试记录接口
*/
+ // 映射请求路径 /examrecord/groupby
@RequestMapping("/groupby")
+ // 处理分组查询请求
public R page2(@RequestParam Map params,ExamrecordEntity examrecord, HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
- }
+ // 如果当前用户不是管理员
+ if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置考试记录的用户 ID 为当前用户的 ID
+ examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
+ }
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = examrecordService.queryPageGroupBy(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params));
+ // 调用考试记录服务类的查询分页分组方法
+ PageUtils page = examrecordService.queryPageGroupBy(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params));
+ // 返回成功响应，并将分页数据放入响应中
return R.ok().put("data", page);
}
/**
* 后端列表
*/
+ // 映射请求路径 /examrecord/page
@RequestMapping("/page")
+ // 处理后端分页查询请求
public R page(@RequestParam Map params,ExamrecordEntity examrecord,
- HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
- }
+ HttpServletRequest request){
+ // 如果当前用户不是管理员
+ if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置考试记录的用户 ID 为当前用户的 ID
+ examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
+ }
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = examrecordService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params));
+ // 调用考试记录服务类的查询分页方法
+ PageUtils page = examrecordService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params));
+ // 返回成功响应，并将分页数据放入响应中
return R.ok().put("data", page);
}
-
+
/**
* 前端列表
*/
+ // 映射请求路径 /examrecord/list
@RequestMapping("/list")
- public R list(@RequestParam Map params,ExamrecordEntity examrecord,
- HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
- }
+ // 处理前端分页查询请求
+ public R list(@RequestParam Map params,ExamrecordEntity examrecord,
+ HttpServletRequest request){
+ // 如果当前用户不是管理员
+ if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置考试记录的用户 ID 为当前用户的 ID
+ examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
+ }
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = examrecordService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params));
+ // 调用考试记录服务类的查询分页方法
+ PageUtils page = examrecordService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params));
+ // 返回成功响应，并将分页数据放入响应中
return R.ok().put("data", page);
}
- /**
+ /**
* 列表
*/
+ // 映射请求路径 /examrecord/lists
@RequestMapping("/lists")
+ // 处理列表查询请求
public R list( ExamrecordEntity examrecord){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( examrecord, "examrecord"));
+ // 创建一个实体包装器，用于构建查询条件
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，所有字段相等
+ ew.allEq(MPUtil.allEQMapPre( examrecord, "examrecord"));
+ // 返回成功响应，并将查询结果放入响应中
return R.ok().put("data", examrecordService.selectListView(ew));
}
- /**
+ /**
* 查询
*/
+ // 映射请求路径 /examrecord/query
@RequestMapping("/query")
+ // 处理查询请求
public R query(ExamrecordEntity examrecord){
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper< ExamrecordEntity> ew = new EntityWrapper< ExamrecordEntity>();
- ew.allEq(MPUtil.allEQMapPre( examrecord, "examrecord"));
- ExamrecordView examrecordView = examrecordService.selectView(ew);
- return R.ok("查询考试记录表成功").put("data", examrecordView);
+ // 设置查询条件，所有字段相等
+ ew.allEq(MPUtil.allEQMapPre( examrecord, "examrecord"));
+ // 调用考试记录服务类的查询视图方法
+ ExamrecordView examrecordView = examrecordService.selectView(ew);
+ // 返回成功响应，并将查询结果放入响应中
+ return R.ok("查询考试记录表成功").put("data", examrecordView);
}
-
+
/**
* 后端详情
*/
+ // 映射请求路径 /examrecord/info/{id}
@RequestMapping("/info/{id}")
+ // 处理后端详情查询请求
public R info(@PathVariable("id") Long id){
+ // 根据 ID 查询考试记录实体
ExamrecordEntity examrecord = examrecordService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应中
return R.ok().put("data", examrecord);
}
/**
* 前端详情
*/
+ // 映射请求路径 /examrecord/detail/{id}
@RequestMapping("/detail/{id}")
+ // 处理前端详情查询请求
public R detail(@PathVariable("id") Long id){
+ // 根据 ID 查询考试记录实体
ExamrecordEntity examrecord = examrecordService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应中
return R.ok().put("data", examrecord);
}
-
+
/**
* 后端保存
*/
+ // 映射请求路径 /examrecord/save
@RequestMapping("/save")
+ // 处理后端保存请求
public R save(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request){
- examrecord.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(examrecord);
- examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
+ // 生成一个唯一的 ID
+ examrecord.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
+ // 验证实体（注释掉，未启用）
+ //ValidatorUtils.validateEntity(examrecord);
+ // 设置考试记录的用户 ID 为当前用户的 ID
+ examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
+ // 调用考试记录服务类的插入方法
examrecordService.insert(examrecord);
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 前端保存
*/
+ // 映射请求路径 /examrecord/add
@RequestMapping("/add")
+ // 处理前端保存请求
public R add(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request){
- examrecord.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(examrecord);
- examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
+ // 生成一个唯一的 ID
+ examrecord.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
+ // 验证实体（注释掉，未启用）
+ //ValidatorUtils.validateEntity(examrecord);
+ // 设置考试记录的用户 ID 为当前用户的 ID
+ examrecord.setUserid((Long)request.getSession().getAttribute("userId"));
+ // 调用考试记录服务类的插入方法
examrecordService.insert(examrecord);
+ // 返回成功响应
return R.ok();
}
/**
* 修改
*/
+ // 映射请求路径 /examrecord/update
@RequestMapping("/update")
+ // 处理修改请求
public R update(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request){
+ // 验证实体（注释掉，未启用）
//ValidatorUtils.validateEntity(examrecord);
+ // 调用考试记录服务类的更新方法，更新所有字段
examrecordService.updateById(examrecord);//全部更新
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 删除
*/
+ // 映射请求路径 /examrecord/delete
@RequestMapping("/delete")
+ // 处理删除请求
public R delete(@RequestBody Long[] ids){
+ // 调用考试记录服务类的批量删除方法
examrecordService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 提醒接口
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- wrapper.eq("userid", (Long)request.getSession().getAttribute("userId"));
- }
-
-
- int count = examrecordService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
+ // 映射请求路径 /examrecord/remind/{columnName}/{type}
+ @RequestMapping("/remind/{columnName}/{type}")
+ // 处理提醒统计请求
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type,@RequestParam Map map) {
+ // 将列名放入参数映射中
+ map.put("column", columnName);
+ // 将类型放入参数映射中
+ map.put("type", type);
+
+ // 如果类型为 2
+ if(type.equals("2")) {
+ // 创建一个日期格式化对象
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建一个日历对象
+ Calendar c = Calendar.getInstance();
+ // 提醒开始日期
+ Date remindStartDate = null;
+ // 提醒结束日期
+ Date remindEndDate = null;
+ // 如果提醒开始参数不为空
+ if(map.get("remindstart")!=null) {
+ // 将提醒开始参数转换为整数
+ Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+ // 设置日历时间为当前时间
+ c.setTime(new Date());
+ // 在当前日期上加上提醒开始天数
+ c.add(Calendar.DAY_OF_MONTH,remindStart);
+ // 获取提醒开始日期
+ remindStartDate = c.getTime();
+ // 将提醒开始日期格式化后放入参数映射中
+ map.put("remindstart", sdf.format(remindStartDate));
+ }
+ // 如果提醒结束参数不为空
+ if(map.get("remindend")!=null) {
+ // 将提醒结束参数转换为整数
+ Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置日历时间为当前时间
+ c.setTime(new Date());
+ // 在当前日期上加上提醒结束天数
+ c.add(Calendar.DAY_OF_MONTH,remindEnd);
+ // 获取提醒结束日期
+ remindEndDate = c.getTime();
+ // 将提醒结束日期格式化后放入参数映射中
+ map.put("remindend", sdf.format(remindEndDate));
+ }
+ }
+
+ // 创建一个实体包装器，用于构建查询条件
+ Wrapper wrapper = new EntityWrapper();
+ // 如果提醒开始参数不为空
+ if(map.get("remindstart")!=null) {
+ // 设置查询条件，列名大于等于提醒开始日期
+ wrapper.ge(columnName, map.get("remindstart"));
+ }
+ // 如果提醒结束参数不为空
+ if(map.get("remindend")!=null) {
+ // 设置查询条件，列名小于等于提醒结束日期
+ wrapper.le(columnName, map.get("remindend"));
+ }
+ // 如果当前用户不是管理员
+ if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置查询条件，用户 ID 等于当前用户的 ID
+ wrapper.eq("userid", (Long)request.getSession().getAttribute("userId"));
+ }
+
+
+ // 调用考试记录服务类的统计方法，统计符合条件的记录数
+ int count = examrecordService.selectCount(wrapper);
+ // 返回成功响应，并将统计结果放入响应中
+ return R.ok().put("count", count);
+ }
+
/**
* 当重新考试时，删除考生的某个试卷的所有考试记录
*/
+ // 映射请求路径 /examrecord/deleteRecords
@RequestMapping("/deleteRecords")
+ // 处理删除指定考生指定试卷的所有考试记录请求
public R deleteRecords(@RequestParam Long userid,@RequestParam Long paperid){
- examrecordService.delete(new EntityWrapper().eq("paperid", paperid).eq("userid", userid));
+ // 调用考试记录服务类的删除方法，根据用户 ID 和试卷 ID 删除记录
+ examrecordService.delete(new EntityWrapper().eq("paperid", paperid).eq("userid", userid));
+ // 返回成功响应
return R.ok();
}
-}
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/FileController.java b/src/main/java/com/controller/FileController.java
index 7bd4f8e..5413b81 100644
--- a/src/main/java/com/controller/FileController.java
+++ b/src/main/java/com/controller/FileController.java
@@ -1,110 +1,187 @@
+// 声明该类所在的包
package com.controller;
+// 导入用于处理文件的类
import java.io.File;
+// 导入文件未找到异常类
import java.io.FileNotFoundException;
+// 导入输入输出异常类
import java.io.IOException;
+// 导入数组操作工具类
import java.util.Arrays;
+// 导入日期类
import java.util.Date;
+// 导入哈希表实现类
import java.util.HashMap;
+// 导入列表接口
import java.util.List;
+// 导入映射接口
import java.util.Map;
+// 导入随机数生成类
import java.util.Random;
+// 导入通用唯一识别码类
import java.util.UUID;
+// 导入 Apache Commons IO 库的文件工具类
import org.apache.commons.io.FileUtils;
+// 导入 Apache Commons Lang 库的字符串工具类
import org.apache.commons.lang3.StringUtils;
+// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 框架的 HTTP 头类
import org.springframework.http.HttpHeaders;
+// 导入 Spring 框架的 HTTP 状态码类
import org.springframework.http.HttpStatus;
+// 导入 Spring 框架的媒体类型类
import org.springframework.http.MediaType;
+// 导入 Spring 框架的响应实体类
import org.springframework.http.ResponseEntity;
+// 导入 Spring 框架的资源工具类
import org.springframework.util.ResourceUtils;
+// 导入 Spring 框架的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入 Spring 框架的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入 Spring 框架的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 框架的请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
+// 导入 Spring 框架的 REST 控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入 Spring 框架的文件上传类
import org.springframework.web.multipart.MultipartFile;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入 MyBatis-Plus 的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入配置实体类
import com.entity.ConfigEntity;
+// 导入自定义异常类
import com.entity.EIException;
+// 导入配置服务类
import com.service.ConfigService;
+// 导入自定义响应类
import com.utils.R;
/**
* 上传文件映射表
*/
+// 声明为 REST 控制器，用于处理 HTTP 请求
@RestController
+// 映射请求路径，所有以 /file 开头的请求都会被该控制器处理
@RequestMapping("file")
+// 抑制未经检查的类型转换警告
@SuppressWarnings({"unchecked","rawtypes"})
+// 文件控制器类，处理文件上传和下载请求
public class FileController{
+ // 自动注入配置服务类的实例
@Autowired
- private ConfigService configService;
+ private ConfigService configService;
/**
* 上传文件
*/
+ // 映射请求路径 /file/upload
@RequestMapping("/upload")
+ // 处理文件上传请求
public R upload(@RequestParam("file") MultipartFile file,String type) throws Exception {
+ // 检查上传的文件是否为空
if (file.isEmpty()) {
+ // 若为空，抛出自定义异常
throw new EIException("上传文件不能为空");
}
+ // 获取文件扩展名
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1);
+ // 获取类路径下 static 目录的文件对象
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
+ // 检查该目录是否存在
if(!path.exists()) {
- path = new File("");
+ // 若不存在，创建一个空文件对象
+ path = new File("");
}
+ // 创建上传目录的文件对象
File upload = new File(path.getAbsolutePath(),"/upload/");
+ // 检查上传目录是否存在
if(!upload.exists()) {
- upload.mkdirs();
+ // 若不存在，创建该目录及其父目录
+ upload.mkdirs();
}
+ // 生成新的文件名，格式为时间戳加扩展名
String fileName = new Date().getTime()+"."+fileExt;
+ // 创建目标文件对象
File dest = new File(upload.getAbsolutePath()+"/"+fileName);
+ // 将上传的文件转移到目标文件
file.transferTo(dest);
+ // 检查类型参数是否不为空且等于 "1"
if(StringUtils.isNotBlank(type) && type.equals("1")) {
+ // 根据配置名称查询配置实体
ConfigEntity configEntity = configService.selectOne(new EntityWrapper().eq("name", "faceFile"));
+ // 若配置实体不存在
if(configEntity==null) {
+ // 创建新的配置实体
configEntity = new ConfigEntity();
+ // 设置配置名称
configEntity.setName("faceFile");
+ // 设置配置值为文件名
configEntity.setValue(fileName);
} else {
+ // 若配置实体存在，更新配置值为文件名
configEntity.setValue(fileName);
}
+ // 插入或更新配置实体
configService.insertOrUpdate(configEntity);
}
+ // 返回成功响应，并将文件名放入响应中
return R.ok().put("file", fileName);
}
-
+
/**
* 下载文件
*/
+ // 该接口忽略认证
@IgnoreAuth
+ // 映射请求路径 /file/download
@RequestMapping("/download")
+ // 处理文件下载请求
public ResponseEntity download(@RequestParam String fileName) {
try {
+ // 获取类路径下 static 目录的文件对象
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
+ // 检查该目录是否存在
if(!path.exists()) {
- path = new File("");
+ // 若不存在，创建一个空文件对象
+ path = new File("");
}
+ // 创建上传目录的文件对象
File upload = new File(path.getAbsolutePath(),"/upload/");
+ // 检查上传目录是否存在
if(!upload.exists()) {
- upload.mkdirs();
+ // 若不存在，创建该目录及其父目录
+ upload.mkdirs();
}
+ // 创建要下载的文件对象
File file = new File(upload.getAbsolutePath()+"/"+fileName);
+ // 检查文件是否存在
if(file.exists()){
- /*if(!fileService.canRead(file, SessionManager.getSessionUser())){
- getResponse().sendError(403);
- }*/
+ // 这里注释掉的代码是检查用户是否有读取文件的权限
+ /*if(!fileService.canRead(file, SessionManager.getSessionUser())){
+ getResponse().sendError(403);
+ }*/
+ // 创建 HTTP 头对象
HttpHeaders headers = new HttpHeaders();
- headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
- headers.setContentDispositionFormData("attachment", fileName);
- return new ResponseEntity(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED);
+ // 设置内容类型为二进制流
+ headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
+ // 设置内容处置为附件，指定文件名
+ headers.setContentDispositionFormData("attachment", fileName);
+ // 返回响应实体，包含文件内容、HTTP 头和 HTTP 状态码
+ return new ResponseEntity(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED);
}
} catch (IOException e) {
+ // 捕获输入输出异常并打印堆栈跟踪信息
e.printStackTrace();
}
+ // 若出现异常或文件不存在，返回内部服务器错误响应
return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
}
-
-}
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/ForumController.java b/src/main/java/com/controller/ForumController.java
index 8939709..87f13af 100644
--- a/src/main/java/com/controller/ForumController.java
+++ b/src/main/java/com/controller/ForumController.java
@@ -1,238 +1,363 @@
+// 声明该类所在的包
package com.controller;
+// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
+// 导入用于创建动态数组的类
import java.util.ArrayList;
+// 导入用于操作数组的工具类
import java.util.Arrays;
+// 导入用于处理日期和时间的类
import java.util.Calendar;
+// 导入用于存储键值对的接口
import java.util.Map;
+// 导入 HashMap 类，用于实现 Map 接口
import java.util.HashMap;
+// 导入用于遍历集合的接口
import java.util.Iterator;
+// 导入用于表示日期和时间的类
import java.util.Date;
+// 导入用于创建列表的接口
import java.util.List;
+// 导入用于处理 HTTP 请求的类
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
+// 导入 Apache Commons Lang 库中的字符串处理工具类
import org.apache.commons.lang3.StringUtils;
+// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Spring 框架的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入 Spring 框架的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入 Spring 框架的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 框架的请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
+// 导入 Spring 框架的 REST 控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入 MyBatis-Plus 的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入 MyBatis-Plus 的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入学习交流实体类
import com.entity.ForumEntity;
+// 导入学习交流视图类
import com.entity.view.ForumView;
+// 导入学习交流服务类
import com.service.ForumService;
+// 导入令牌服务类
import com.service.TokenService;
+// 导入分页工具类
import com.utils.PageUtils;
+// 导入自定义的响应类
import com.utils.R;
+// 导入 MD5 加密工具类
import com.utils.MD5Util;
+// 导入 MyBatis-Plus 工具类
import com.utils.MPUtil;
+// 导入通用工具类
import com.utils.CommonUtil;
/**
* 学习交流
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:15
*/
+// 声明该类为 REST 控制器，用于处理 HTTP 请求
@RestController
+// 映射请求路径，所有以 /forum 开头的请求都会由该控制器处理
@RequestMapping("/forum")
public class ForumController {
+ // 自动注入学习交流服务类的实例
@Autowired
private ForumService forumService;
-
/**
* 后端列表
*/
+ // 映射请求路径 /forum/page
@RequestMapping("/page")
- public R page(@RequestParam Map params,ForumEntity forum,
- HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- forum.setUserid((Long)request.getSession().getAttribute("userId"));
- }
+ // 处理后端分页查询学习交流列表的请求
+ public R page(@RequestParam Map params, ForumEntity forum,
+ HttpServletRequest request) {
+ // 如果当前用户不是管理员
+ if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置学习交流的用户 ID 为当前用户的 ID
+ forum.setUserid((Long) request.getSession().getAttribute("userId"));
+ }
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
-
+ // 调用学习交流服务类的查询分页方法，进行排序、范围和模糊查询
+ PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
+ // 返回成功响应，并将分页数据放入响应中
return R.ok().put("data", page);
}
-
+
/**
* 前端列表
*/
+ // 映射请求路径 /forum/list
@RequestMapping("/list")
- public R list(@RequestParam Map params,ForumEntity forum,
- HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- forum.setUserid((Long)request.getSession().getAttribute("userId"));
- }
+ // 处理前端分页查询学习交流列表的请求
+ public R list(@RequestParam Map params, ForumEntity forum,
+ HttpServletRequest request) {
+ // 如果当前用户不是管理员
+ if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置学习交流的用户 ID 为当前用户的 ID
+ forum.setUserid((Long) request.getSession().getAttribute("userId"));
+ }
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
+ // 调用学习交流服务类的查询分页方法，进行排序、范围和模糊查询
+ PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
+ // 返回成功响应，并将分页数据放入响应中
return R.ok().put("data", page);
}
- /**
+ /**
* 列表
*/
+ // 该接口忽略认证
@IgnoreAuth
+ // 映射请求路径 /forum/flist
@RequestMapping("/flist")
- public R flist(@RequestParam Map params,ForumEntity forum, HttpServletRequest request){
+ // 处理查询学习交流列表的请求
+ public R flist(@RequestParam Map params, ForumEntity forum, HttpServletRequest request) {
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allEq(ew, forum), params), params));
+ // 调用学习交流服务类的查询分页方法，进行排序、范围和全量相等查询
+ PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allEq(ew, forum), params), params));
+ // 返回成功响应，并将分页数据放入响应中
return R.ok().put("data", page);
}
- /**
+ /**
* 查询
*/
+ // 映射请求路径 /forum/query
@RequestMapping("/query")
- public R query(ForumEntity forum){
- EntityWrapper< ForumEntity> ew = new EntityWrapper< ForumEntity>();
- ew.allEq(MPUtil.allEQMapPre( forum, "forum"));
- ForumView forumView = forumService.selectView(ew);
- return R.ok("查询学习交流成功").put("data", forumView);
+ // 处理查询学习交流信息的请求
+ public R query(ForumEntity forum) {
+ // 创建一个实体包装器，用于构建查询条件
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，所有字段相等
+ ew.allEq(MPUtil.allEQMapPre(forum, "forum"));
+ // 调用学习交流服务类的查询视图方法
+ ForumView forumView = forumService.selectView(ew);
+ // 返回成功响应，并将查询结果放入响应中
+ return R.ok("查询学习交流成功").put("data", forumView);
}
-
+
/**
* 后端详情
*/
+ // 映射请求路径 /forum/info/{id}
@RequestMapping("/info/{id}")
- public R info(@PathVariable("id") Long id){
+ // 处理后端查询学习交流详情的请求
+ public R info(@PathVariable("id") Long id) {
+ // 根据 ID 查询学习交流实体
ForumEntity forum = forumService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应中
return R.ok().put("data", forum);
}
/**
* 前端详情
*/
+ // 映射请求路径 /forum/detail/{id}
@RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") Long id){
+ // 处理前端查询学习交流详情的请求
+ public R detail(@PathVariable("id") Long id) {
+ // 根据 ID 查询学习交流实体
ForumEntity forum = forumService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应中
return R.ok().put("data", forum);
}
-
- /**
+
+ /**
* 论坛详情
*/
- @IgnoreAuth
+ // 该接口忽略认证
+ @IgnoreAuth
+ // 映射请求路径 /forum/list/{id}
@RequestMapping("/list/{id}")
- public R list(@PathVariable("id") String id){
+ // 处理查询论坛详情的请求
+ public R list(@PathVariable("id") String id) {
+ // 根据 ID 查询学习交流实体
ForumEntity forum = forumService.selectById(id);
+ // 递归获取子论坛信息
getChilds(forum);
+ // 返回成功响应，并将查询结果放入响应中
return R.ok().put("data", forum);
}
-
- private ForumEntity getChilds(ForumEntity forum) {
- List childs = new ArrayList();
- childs = forumService.selectList(new EntityWrapper().eq("parentid", forum.getId()));
- if(childs == null || childs.size()==0) {
- return null;
- }
- forum.setChilds(childs);
- for(ForumEntity forumEntity : childs) {
- getChilds(forumEntity);
- }
- return forum;
- }
-
+ // 递归获取子论坛信息的方法
+ private ForumEntity getChilds(ForumEntity forum) {
+ // 创建一个存储子论坛的列表
+ List childs = new ArrayList();
+ // 查询该论坛的所有子论坛
+ childs = forumService.selectList(new EntityWrapper().eq("parentid", forum.getId()));
+ // 如果没有子论坛
+ if (childs == null || childs.size() == 0) {
+ // 返回 null
+ return null;
+ }
+ // 设置该论坛的子论坛列表
+ forum.setChilds(childs);
+ // 递归处理每个子论坛
+ for (ForumEntity forumEntity : childs) {
+ getChilds(forumEntity);
+ }
+ // 返回该论坛
+ return forum;
+ }
/**
* 后端保存
*/
+ // 映射请求路径 /forum/save
@RequestMapping("/save")
- public R save(@RequestBody ForumEntity forum, HttpServletRequest request){
- forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(forum);
- forum.setUserid((Long)request.getSession().getAttribute("userId"));
+ // 处理后端保存学习交流信息的请求
+ public R save(@RequestBody ForumEntity forum, HttpServletRequest request) {
+ // 生成一个唯一的 ID
+ forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 验证实体（注释掉，未启用）
+ //ValidatorUtils.validateEntity(forum);
+ // 设置学习交流的用户 ID 为当前用户的 ID
+ forum.setUserid((Long) request.getSession().getAttribute("userId"));
+ // 调用学习交流服务类的插入方法
forumService.insert(forum);
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 前端保存
*/
+ // 映射请求路径 /forum/add
@RequestMapping("/add")
- public R add(@RequestBody ForumEntity forum, HttpServletRequest request){
- forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(forum);
- forum.setUserid((Long)request.getSession().getAttribute("userId"));
+ // 处理前端保存学习交流信息的请求
+ public R add(@RequestBody ForumEntity forum, HttpServletRequest request) {
+ // 生成一个唯一的 ID
+ forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 验证实体（注释掉，未启用）
+ //ValidatorUtils.validateEntity(forum);
+ // 设置学习交流的用户 ID 为当前用户的 ID
+ forum.setUserid((Long) request.getSession().getAttribute("userId"));
+ // 调用学习交流服务类的插入方法
forumService.insert(forum);
+ // 返回成功响应
return R.ok();
}
/**
* 修改
*/
+ // 映射请求路径 /forum/update
@RequestMapping("/update")
- public R update(@RequestBody ForumEntity forum, HttpServletRequest request){
+ // 处理修改学习交流信息的请求
+ public R update(@RequestBody ForumEntity forum, HttpServletRequest request) {
+ // 验证实体（注释掉，未启用）
//ValidatorUtils.validateEntity(forum);
- forumService.updateById(forum);//全部更新
+ // 调用学习交流服务类的更新方法，更新所有字段
+ forumService.updateById(forum); // 全部更新
+ // 返回成功响应
return R.ok();
}
-
/**
* 删除
*/
+ // 映射请求路径 /forum/delete
@RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
+ // 处理删除学习交流信息的请求
+ public R delete(@RequestBody Long[] ids) {
+ // 调用学习交流服务类的批量删除方法
forumService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 提醒接口
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
-
-
- int count = forumService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
-
-
-}
+ // 映射请求路径 /forum/remind/{columnName}/{type}
+ @RequestMapping("/remind/{columnName}/{type}")
+ // 处理提醒统计的请求
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type, @RequestParam Map map) {
+ // 将列名放入参数映射中
+ map.put("column", columnName);
+ // 将类型放入参数映射中
+ map.put("type", type);
+
+ // 如果类型为 2
+ if (type.equals("2")) {
+ // 创建一个日期格式化对象
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建一个日历对象
+ Calendar c = Calendar.getInstance();
+ // 提醒开始日期
+ Date remindStartDate = null;
+ // 提醒结束日期
+ Date remindEndDate = null;
+ // 如果提醒开始参数不为空
+ if (map.get("remindstart") != null) {
+ // 将提醒开始参数转换为整数
+ Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+ // 设置日历时间为当前时间
+ c.setTime(new Date());
+ // 在当前日期上加上提醒开始天数
+ c.add(Calendar.DAY_OF_MONTH, remindStart);
+ // 获取提醒开始日期
+ remindStartDate = c.getTime();
+ // 将提醒开始日期格式化后放入参数映射中
+ map.put("remindstart", sdf.format(remindStartDate));
+ }
+ // 如果提醒结束参数不为空
+ if (map.get("remindend") != null) {
+ // 将提醒结束参数转换为整数
+ Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置日历时间为当前时间
+ c.setTime(new Date());
+ // 在当前日期上加上提醒结束天数
+ c.add(Calendar.DAY_OF_MONTH, remindEnd);
+ // 获取提醒结束日期
+ remindEndDate = c.getTime();
+ // 将提醒结束日期格式化后放入参数映射中
+ map.put("remindend", sdf.format(remindEndDate));
+ }
+ }
+
+ // 创建一个实体包装器，用于构建查询条件
+ Wrapper wrapper = new EntityWrapper();
+ // 如果提醒开始参数不为空
+ if (map.get("remindstart") != null) {
+ // 设置查询条件，列名大于等于提醒开始日期
+ wrapper.ge(columnName, map.get("remindstart"));
+ }
+ // 如果提醒结束参数不为空
+ if (map.get("remindend") != null) {
+ // 设置查询条件，列名小于等于提醒结束日期
+ wrapper.le(columnName, map.get("remindend"));
+ }
+
+ // 调用学习交流服务类的统计方法，统计符合条件的记录数
+ int count = forumService.selectCount(wrapper);
+ // 返回成功响应，并将统计结果放入响应中
+ return R.ok().put("count", count);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/GoumaidekechengController.java b/src/main/java/com/controller/GoumaidekechengController.java
index a05788a..5739c03 100644
--- a/src/main/java/com/controller/GoumaidekechengController.java
+++ b/src/main/java/com/controller/GoumaidekechengController.java
@@ -1,214 +1,317 @@
package com.controller;
+// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
+// 导入用于创建动态数组的类
import java.util.ArrayList;
+// 导入用于操作数组的工具类
import java.util.Arrays;
+// 导入用于处理日期和时间的类
import java.util.Calendar;
+// 导入用于存储键值对的接口
import java.util.Map;
+// 导入 HashMap 类，用于实现 Map 接口
import java.util.HashMap;
+// 导入用于遍历集合的接口
import java.util.Iterator;
+// 导入用于表示日期和时间的类
import java.util.Date;
+// 导入用于创建列表的接口
import java.util.List;
+// 导入用于处理 HTTP 请求的类
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
+// 导入 Apache Commons Lang 库中的字符串处理工具类
import org.apache.commons.lang3.StringUtils;
+// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Spring 框架的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入 Spring 框架的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入 Spring 框架的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 框架的请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
+// 导入 Spring 框架的 REST 控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入 MyBatis-Plus 的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入 MyBatis-Plus 的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入购买的课程实体类
import com.entity.GoumaidekechengEntity;
+// 导入购买的课程视图类
import com.entity.view.GoumaidekechengView;
+// 导入购买的课程服务类
import com.service.GoumaidekechengService;
+// 导入令牌服务类
import com.service.TokenService;
+// 导入分页工具类
import com.utils.PageUtils;
+// 导入自定义的响应类
import com.utils.R;
+// 导入 MD5 加密工具类
import com.utils.MD5Util;
+// 导入 MyBatis-Plus 工具类
import com.utils.MPUtil;
+// 导入通用工具类
import com.utils.CommonUtil;
/**
* 购买的课程
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:14
*/
+// 声明为 REST 控制器，用于处理 HTTP 请求
@RestController
+// 映射请求路径，所有以 /goumaidekecheng 开头的请求由该控制器处理
@RequestMapping("/goumaidekecheng")
public class GoumaidekechengController {
+ // 自动注入购买的课程服务类实例
@Autowired
private GoumaidekechengService goumaidekechengService;
-
/**
- * 后端列表
+ * 后端列表（分页查询）
*/
+ // 映射请求路径 /goumaidekecheng/page
@RequestMapping("/page")
- public R page(@RequestParam Map params,GoumaidekechengEntity goumaidekecheng,
- HttpServletRequest request){
- String tableName = request.getSession().getAttribute("tableName").toString();
- if(tableName.equals("yonghu")) {
- goumaidekecheng.setYonghuzhanghao((String)request.getSession().getAttribute("username"));
- }
+ // 处理后端分页查询请求，参数包括查询条件、实体对象、HTTP 请求
+ public R page(@RequestParam Map params, GoumaidekechengEntity goumaidekecheng,
+ HttpServletRequest request) {
+ // 从会话中获取表名（判断用户类型）
+ String tableName = request.getSession().getAttribute("tableName").toString();
+ // 如果表名是 "yonghu"（用户表）
+ if (tableName.equals("yonghu")) {
+ // 设置查询条件：用户账号为当前登录用户的用户名
+ goumaidekecheng.setYonghuzhanghao((String) request.getSession().getAttribute("username"));
+ }
+ // 创建实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = goumaidekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, goumaidekecheng), params), params));
-
+ // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理
+ PageUtils page = goumaidekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, goumaidekecheng), params), params));
+ // 返回成功响应，携带分页数据
return R.ok().put("data", page);
}
-
+
/**
- * 前端列表
+ * 前端列表（分页查询）
*/
+ // 映射请求路径 /goumaidekecheng/list
@RequestMapping("/list")
- public R list(@RequestParam Map params,GoumaidekechengEntity goumaidekecheng,
- HttpServletRequest request){
+ // 处理前端分页查询请求，参数包括查询条件、实体对象、HTTP 请求
+ public R list(@RequestParam Map params, GoumaidekechengEntity goumaidekecheng,
+ HttpServletRequest request) {
+ // 创建实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = goumaidekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, goumaidekecheng), params), params));
+ // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理
+ PageUtils page = goumaidekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, goumaidekecheng), params), params));
+ // 返回成功响应，携带分页数据
return R.ok().put("data", page);
}
- /**
- * 列表
+ /**
+ * 列表（不分页，全量查询）
*/
+ // 映射请求路径 /goumaidekecheng/lists
@RequestMapping("/lists")
- public R list( GoumaidekechengEntity goumaidekecheng){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( goumaidekecheng, "goumaidekecheng"));
+ // 处理全量查询请求，参数为实体对象
+ public R list(GoumaidekechengEntity goumaidekecheng) {
+ // 创建实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件：所有字段与实体对象相等（前缀为 "goumaidekecheng"）
+ ew.allEq(MPUtil.allEQMapPre(goumaidekecheng, "goumaidekecheng"));
+ // 返回成功响应，携带查询结果（视图列表）
return R.ok().put("data", goumaidekechengService.selectListView(ew));
}
- /**
- * 查询
+ /**
+ * 查询（单个对象）
*/
+ // 映射请求路径 /goumaidekecheng/query
@RequestMapping("/query")
- public R query(GoumaidekechengEntity goumaidekecheng){
- EntityWrapper< GoumaidekechengEntity> ew = new EntityWrapper< GoumaidekechengEntity>();
- ew.allEq(MPUtil.allEQMapPre( goumaidekecheng, "goumaidekecheng"));
- GoumaidekechengView goumaidekechengView = goumaidekechengService.selectView(ew);
- return R.ok("查询购买的课程成功").put("data", goumaidekechengView);
+ // 处理单个对象查询请求，参数为实体对象
+ public R query(GoumaidekechengEntity goumaidekecheng) {
+ // 创建实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件：所有字段与实体对象相等（前缀为 "goumaidekecheng"）
+ ew.allEq(MPUtil.allEQMapPre(goumaidekecheng, "goumaidekecheng"));
+ // 调用服务类的视图查询方法
+ GoumaidekechengView goumaidekechengView = goumaidekechengService.selectView(ew);
+ // 返回成功响应，携带查询结果和提示信息
+ return R.ok("查询购买的课程成功").put("data", goumaidekechengView);
}
-
+
/**
- * 后端详情
+ * 后端详情（根据 ID 查询）
*/
+ // 映射请求路径 /goumaidekecheng/info/{id}
@RequestMapping("/info/{id}")
- public R info(@PathVariable("id") Long id){
+ // 处理详情查询请求，参数为路径中的 ID
+ public R info(@PathVariable("id") Long id) {
+ // 根据 ID 直接查询实体对象
GoumaidekechengEntity goumaidekecheng = goumaidekechengService.selectById(id);
+ // 返回成功响应，携带查询到的实体数据
return R.ok().put("data", goumaidekecheng);
}
/**
- * 前端详情
+ * 前端详情（根据 ID 查询）
*/
+ // 映射请求路径 /goumaidekecheng/detail/{id}
@RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") Long id){
+ // 处理详情查询请求，参数为路径中的 ID（前端调用）
+ public R detail(@PathVariable("id") Long id) {
+ // 根据 ID 直接查询实体对象
GoumaidekechengEntity goumaidekecheng = goumaidekechengService.selectById(id);
+ // 返回成功响应，携带查询到的实体数据
return R.ok().put("data", goumaidekecheng);
}
-
+
/**
- * 后端保存
+ * 后端保存（新增数据）
*/
+ // 映射请求路径 /goumaidekecheng/save
@RequestMapping("/save")
- public R save(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request){
- goumaidekecheng.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(goumaidekecheng);
+ // 处理后端新增请求，请求体为实体对象，携带 HTTP 请求
+ public R save(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request) {
+ // 生成唯一 ID（时间戳 + 随机数）
+ goumaidekecheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 实体验证（注释，未启用）
+ //ValidatorUtils.validateEntity(goumaidekecheng);
+ // 调用服务类的插入方法
goumaidekechengService.insert(goumaidekecheng);
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 前端保存
+ * 前端保存（新增数据）
*/
+ // 映射请求路径 /goumaidekecheng/add
@RequestMapping("/add")
- public R add(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request){
- goumaidekecheng.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(goumaidekecheng);
+ // 处理前端新增请求，请求体为实体对象，携带 HTTP 请求
+ public R add(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request) {
+ // 生成唯一 ID（时间戳 + 随机数）
+ goumaidekecheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 实体验证（注释，未启用）
+ //ValidatorUtils.validateEntity(goumaidekecheng);
+ // 调用服务类的插入方法
goumaidekechengService.insert(goumaidekecheng);
+ // 返回成功响应
return R.ok();
}
/**
- * 修改
+ * 修改（更新数据）
*/
+ // 映射请求路径 /goumaidekecheng/update
@RequestMapping("/update")
- public R update(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request){
+ // 处理修改请求，请求体为实体对象，携带 HTTP 请求
+ public R update(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request) {
+ // 实体验证（注释，未启用）
//ValidatorUtils.validateEntity(goumaidekecheng);
- goumaidekechengService.updateById(goumaidekecheng);//全部更新
+ // 调用服务类的更新方法（根据 ID 全量更新）
+ goumaidekechengService.updateById(goumaidekecheng); // 全部更新
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 删除
+ * 删除（批量删除）
*/
+ // 映射请求路径 /goumaidekecheng/delete
@RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
+ // 处理删除请求，请求体为 ID 数组
+ public R delete(@RequestBody Long[] ids) {
+ // 调用服务类的批量删除方法（根据 ID 列表）
goumaidekechengService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 提醒接口
+ * 提醒接口（统计符合条件的记录数）
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
-
- String tableName = request.getSession().getAttribute("tableName").toString();
- if(tableName.equals("yonghu")) {
- wrapper.eq("yonghuzhanghao", (String)request.getSession().getAttribute("username"));
- }
-
- int count = goumaidekechengService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
-
-
-}
+ // 映射请求路径 /goumaidekecheng/remind/{columnName}/{type}
+ @RequestMapping("/remind/{columnName}/{type}")
+ // 处理提醒统计请求，参数包括列名、类型、查询条件映射
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type, @RequestParam Map map) {
+ // 向查询条件中添加列名和类型
+ map.put("column", columnName);
+ map.put("type", type);
+
+ // 如果类型为 2（处理日期范围提醒）
+ if (type.equals("2")) {
+ // 创建日期格式化对象（yyyy-MM-dd 格式）
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建日历对象
+ Calendar c = Calendar.getInstance();
+ // 提醒开始日期和结束日期变量
+ Date remindStartDate = null;
+ Date remindEndDate = null;
+ // 处理提醒开始时间（相对当前日期偏移）
+ if (map.get("remindstart") != null) {
+ // 解析偏移天数
+ Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+ // 设置日历为当前时间并添加偏移天数
+ c.setTime(new Date());
+ c.add(Calendar.DAY_OF_MONTH, remindStart);
+ // 获取格式化后的提醒开始日期
+ remindStartDate = c.getTime();
+ map.put("remindstart", sdf.format(remindStartDate));
+ }
+ // 处理提醒结束时间（相对当前日期偏移）
+ if (map.get("remindend") != null) {
+ // 解析偏移天数
+ Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置日历为当前时间并添加偏移天数
+ c.setTime(new Date());
+ c.add(Calendar.DAY_OF_MONTH, remindEnd);
+ // 获取格式化后的提醒结束日期
+ remindEndDate = c.getTime();
+ map.put("remindend", sdf.format(remindEndDate));
+ }
+ }
+
+ // 创建包装器用于构建查询条件
+ Wrapper wrapper = new EntityWrapper();
+ // 添加提醒开始时间的大于等于条件
+ if (map.get("remindstart") != null) {
+ wrapper.ge(columnName, map.get("remindstart"));
+ }
+ // 添加提醒结束时间的小于等于条件
+ if (map.get("remindend") != null) {
+ wrapper.le(columnName, map.get("remindend"));
+ }
+
+ // 根据表名判断是否添加用户账号条件（用户表场景）
+ String tableName = request.getSession().getAttribute("tableName").toString();
+ if (tableName.equals("yonghu")) {
+ wrapper.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username"));
+ }
+
+ // 调用服务类统计符合条件的记录数
+ int count = goumaidekechengService.selectCount(wrapper);
+ // 返回成功响应，携带统计结果
+ return R.ok().put("count", count);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/KechengleixingController.java b/src/main/java/com/controller/KechengleixingController.java
index eab85c5..d099a01 100644
--- a/src/main/java/com/controller/KechengleixingController.java
+++ b/src/main/java/com/controller/KechengleixingController.java
@@ -1,206 +1,304 @@
package com.controller;
+// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
+// 导入用于创建动态数组的类
import java.util.ArrayList;
+// 导入用于操作数组的工具类
import java.util.Arrays;
+// 导入用于处理日期和时间的类
import java.util.Calendar;
+// 导入用于存储键值对的接口
import java.util.Map;
+// 导入HashMap类，用于实现Map接口
import java.util.HashMap;
+// 导入用于遍历集合的接口
import java.util.Iterator;
+// 导入用于表示日期和时间的类
import java.util.Date;
+// 导入用于创建列表的接口
import java.util.List;
+// 导入用于处理HTTP请求的类
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
+// 导入Apache Commons Lang库中的字符串处理工具类
import org.apache.commons.lang3.StringUtils;
+// 导入Spring框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
+// 导入Spring框架的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入Spring框架的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入Spring框架的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
+// 导入Spring框架的REST控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入课程类型实体类
import com.entity.KechengleixingEntity;
+// 导入课程类型视图类
import com.entity.view.KechengleixingView;
+// 导入课程类型服务类
import com.service.KechengleixingService;
+// 导入令牌服务类
import com.service.TokenService;
+// 导入分页工具类
import com.utils.PageUtils;
+// 导入自定义的响应类
import com.utils.R;
+// 导入MD5加密工具类
import com.utils.MD5Util;
+// 导入MyBatis-Plus工具类
import com.utils.MPUtil;
+// 导入通用工具类
import com.utils.CommonUtil;
/**
* 课程类型
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:14
*/
+// 声明为REST控制器，用于处理HTTP请求
@RestController
+// 映射请求路径，所有以/kechengleixing开头的请求由该控制器处理
@RequestMapping("/kechengleixing")
public class KechengleixingController {
+ // 自动注入课程类型服务类实例
@Autowired
private KechengleixingService kechengleixingService;
-
/**
- * 后端列表
+ * 后端列表（分页查询）
*/
+ // 映射请求路径/kechengleixing/page
@RequestMapping("/page")
- public R page(@RequestParam Map params,KechengleixingEntity kechengleixing,
- HttpServletRequest request){
+ // 处理后端分页查询请求，参数包括查询条件、实体对象、HTTP请求
+ public R page(@RequestParam Map params, KechengleixingEntity kechengleixing,
+ HttpServletRequest request) {
+ // 创建实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = kechengleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengleixing), params), params));
-
+ // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理
+ PageUtils page = kechengleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengleixing), params), params));
+ // 返回成功响应，携带分页数据
return R.ok().put("data", page);
}
-
+
/**
- * 前端列表
+ * 前端列表（分页查询）
*/
+ // 映射请求路径/kechengleixing/list
@RequestMapping("/list")
- public R list(@RequestParam Map params,KechengleixingEntity kechengleixing,
- HttpServletRequest request){
+ // 处理前端分页查询请求，参数包括查询条件、实体对象、HTTP请求
+ public R list(@RequestParam Map params, KechengleixingEntity kechengleixing,
+ HttpServletRequest request) {
+ // 创建实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = kechengleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengleixing), params), params));
+ // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理
+ PageUtils page = kechengleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengleixing), params), params));
+ // 返回成功响应，携带分页数据
return R.ok().put("data", page);
}
- /**
- * 列表
+ /**
+ * 列表（不分页，全量查询）
*/
+ // 映射请求路径/kechengleixing/lists（测试用接口）
@RequestMapping("/lists")
- public R list( KechengleixingEntity kechengleixing){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( kechengleixing, "kechengleixing"));
+ // 处理全量查询请求，参数为实体对象
+ public R list(KechengleixingEntity kechengleixing) {
+ // 创建实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件：所有字段与实体对象相等（前缀为"kechengleixing"）
+ ew.allEq(MPUtil.allEQMapPre(kechengleixing, "kechengleixing"));
+ // 返回成功响应，携带查询结果（视图列表）
return R.ok().put("data", kechengleixingService.selectListView(ew));
}
- /**
- * 查询
+ /**
+ * 查询（单个对象）
*/
+ // 映射请求路径/kechengleixing/query
@RequestMapping("/query")
- public R query(KechengleixingEntity kechengleixing){
- EntityWrapper< KechengleixingEntity> ew = new EntityWrapper< KechengleixingEntity>();
- ew.allEq(MPUtil.allEQMapPre( kechengleixing, "kechengleixing"));
- KechengleixingView kechengleixingView = kechengleixingService.selectView(ew);
- return R.ok("查询课程类型成功").put("data", kechengleixingView);
+ // 处理单个对象查询请求，参数为实体对象
+ public R query(KechengleixingEntity kechengleixing) {
+ // 创建实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件：所有字段与实体对象相等（前缀为"kechengleixing"）
+ ew.allEq(MPUtil.allEQMapPre(kechengleixing, "kechengleixing"));
+ // 调用服务类的视图查询方法
+ KechengleixingView kechengleixingView = kechengleixingService.selectView(ew);
+ // 返回成功响应，携带查询结果和提示信息
+ return R.ok("查询课程类型成功").put("data", kechengleixingView);
}
-
+
/**
- * 后端详情
+ * 后端详情（根据ID查询）
*/
+ // 映射请求路径/kechengleixing/info/{id}
@RequestMapping("/info/{id}")
- public R info(@PathVariable("id") Long id){
+ // 处理详情查询请求，参数为路径中的ID
+ public R info(@PathVariable("id") Long id) {
+ // 根据ID直接查询实体对象
KechengleixingEntity kechengleixing = kechengleixingService.selectById(id);
+ // 返回成功响应，携带查询到的实体数据
return R.ok().put("data", kechengleixing);
}
/**
- * 前端详情
+ * 前端详情（根据ID查询）
*/
+ // 映射请求路径/kechengleixing/detail/{id}
@RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") Long id){
+ // 处理详情查询请求，参数为路径中的ID（前端调用）
+ public R detail(@PathVariable("id") Long id) {
+ // 根据ID直接查询实体对象
KechengleixingEntity kechengleixing = kechengleixingService.selectById(id);
+ // 返回成功响应，携带查询到的实体数据
return R.ok().put("data", kechengleixing);
}
-
+
/**
- * 后端保存
+ * 后端保存（新增数据）
*/
+ // 映射请求路径/kechengleixing/save
@RequestMapping("/save")
- public R save(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request){
- kechengleixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(kechengleixing);
+ // 处理后端新增请求，请求体为实体对象，携带HTTP请求
+ public R save(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request) {
+ // 生成唯一ID（时间戳 + 随机数）
+ kechengleixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 实体验证（注释，未启用）
+ //ValidatorUtils.validateEntity(kechengleixing);
+ // 调用服务类的插入方法
kechengleixingService.insert(kechengleixing);
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 前端保存
+ * 前端保存（新增数据）
*/
+ // 映射请求路径/kechengleixing/add
@RequestMapping("/add")
- public R add(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request){
- kechengleixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(kechengleixing);
+ // 处理前端新增请求，请求体为实体对象，携带HTTP请求
+ public R add(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request) {
+ // 生成唯一ID（时间戳 + 随机数）
+ kechengleixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 实体验证（注释，未启用）
+ //ValidatorUtils.validateEntity(kechengleixing);
+ // 调用服务类的插入方法
kechengleixingService.insert(kechengleixing);
+ // 返回成功响应
return R.ok();
}
/**
- * 修改
+ * 修改（更新数据）
*/
+ // 映射请求路径/kechengleixing/update
@RequestMapping("/update")
- public R update(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request){
+ // 处理修改请求，请求体为实体对象，携带HTTP请求
+ public R update(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request) {
+ // 实体验证（注释，未启用）
//ValidatorUtils.validateEntity(kechengleixing);
- kechengleixingService.updateById(kechengleixing);//全部更新
+ // 调用服务类的更新方法（根据ID全量更新）
+ kechengleixingService.updateById(kechengleixing); // 全部更新
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 删除
+ * 删除（批量删除）
*/
+ // 映射请求路径/kechengleixing/delete
@RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
+ // 处理删除请求，请求体为ID数组
+ public R delete(@RequestBody Long[] ids) {
+ // 调用服务类的批量删除方法（根据ID列表）
kechengleixingService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 提醒接口
+ * 提醒接口（统计符合条件的记录数）
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
-
-
- int count = kechengleixingService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
-
-
-}
+ // 映射请求路径/kechengleixing/remind/{columnName}/{type}
+ @RequestMapping("/remind/{columnName}/{type}")
+ // 处理提醒统计请求，参数包括列名、类型、查询条件映射
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type, @RequestParam Map map) {
+ // 向查询条件中添加列名和类型
+ map.put("column", columnName);
+ map.put("type", type);
+
+ // 如果类型为2（处理日期范围提醒）
+ if (type.equals("2")) {
+ // 创建日期格式化对象（yyyy-MM-dd格式）
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建日历对象
+ Calendar c = Calendar.getInstance();
+ // 提醒开始日期和结束日期变量
+ Date remindStartDate = null;
+ Date remindEndDate = null;
+ // 处理提醒开始时间（相对当前日期偏移）
+ if (map.get("remindstart") != null) {
+ // 解析偏移天数
+ Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+ // 设置日历为当前时间并添加偏移天数
+ c.setTime(new Date());
+ c.add(Calendar.DAY_OF_MONTH, remindStart);
+ // 获取格式化后的提醒开始日期
+ remindStartDate = c.getTime();
+ map.put("remindstart", sdf.format(remindStartDate));
+ }
+ // 处理提醒结束时间（相对当前日期偏移）
+ if (map.get("remindend") != null) {
+ // 解析偏移天数
+ Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置日历为当前时间并添加偏移天数
+ c.setTime(new Date());
+ c.add(Calendar.DAY_OF_MONTH, remindEnd);
+ // 获取格式化后的提醒结束日期
+ remindEndDate = c.getTime();
+ map.put("remindend", sdf.format(remindEndDate));
+ }
+ }
+
+ // 创建包装器用于构建查询条件
+ Wrapper wrapper = new EntityWrapper();
+ // 添加提醒开始时间的大于等于条件
+ if (map.get("remindstart") != null) {
+ wrapper.ge(columnName, map.get("remindstart"));
+ }
+ // 添加提醒结束时间的小于等于条件
+ if (map.get("remindend") != null) {
+ wrapper.le(columnName, map.get("remindend"));
+ }
+
+
+ // 调用服务类统计符合条件的记录数
+ int count = kechengleixingService.selectCount(wrapper);
+ // 返回成功响应，携带统计结果
+ return R.ok().put("count", count);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/KechengxinxiController.java b/src/main/java/com/controller/KechengxinxiController.java
index 332245a..3af9fda 100644
--- a/src/main/java/com/controller/KechengxinxiController.java
+++ b/src/main/java/com/controller/KechengxinxiController.java
@@ -1,208 +1,313 @@
+// 声明该类所在的包
package com.controller;
+// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
+// 导入用于创建动态数组的类
import java.util.ArrayList;
+// 导入用于操作数组的工具类
import java.util.Arrays;
+// 导入用于处理日期和时间的类
import java.util.Calendar;
+// 导入用于存储键值对的接口
import java.util.Map;
+// 导入用于实现 Map 接口的 HashMap 类
import java.util.HashMap;
+// 导入用于遍历集合的接口
import java.util.Iterator;
+// 导入用于表示日期和时间的类
import java.util.Date;
+// 导入用于创建列表的接口
import java.util.List;
+// 导入用于处理 HTTP 请求的类
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
+// 导入 Apache Commons Lang 库中的字符串处理工具类
import org.apache.commons.lang3.StringUtils;
+// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Spring 框架的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入 Spring 框架的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入 Spring 框架的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 框架的请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
+// 导入 Spring 框架的 REST 控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入 MyBatis-Plus 的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入 MyBatis-Plus 的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入课程信息实体类
import com.entity.KechengxinxiEntity;
+// 导入课程信息视图类
import com.entity.view.KechengxinxiView;
+// 导入课程信息服务类
import com.service.KechengxinxiService;
+// 导入令牌服务类
import com.service.TokenService;
+// 导入分页工具类
import com.utils.PageUtils;
+// 导入自定义的响应类
import com.utils.R;
+// 导入 MD5 加密工具类
import com.utils.MD5Util;
+// 导入 MyBatis-Plus 工具类
import com.utils.MPUtil;
+// 导入通用工具类
import com.utils.CommonUtil;
/**
* 课程信息
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:14
*/
+// 声明该类为 REST 控制器，用于处理 HTTP 请求
@RestController
+// 映射请求路径，所有以 /kechengxinxi 开头的请求都会由该控制器处理
@RequestMapping("/kechengxinxi")
public class KechengxinxiController {
+ // 自动注入课程信息服务类的实例
@Autowired
private KechengxinxiService kechengxinxiService;
-
/**
* 后端列表
*/
+ // 映射请求路径 /kechengxinxi/page
@RequestMapping("/page")
- public R page(@RequestParam Map params,KechengxinxiEntity kechengxinxi,
- HttpServletRequest request){
+ // 处理后端分页查询课程信息列表的请求
+ public R page(@RequestParam Map params, KechengxinxiEntity kechengxinxi,
+ HttpServletRequest request) {
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = kechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengxinxi), params), params));
-
+ // 调用课程信息服务类的查询分页方法，进行排序、范围和模糊查询
+ PageUtils page = kechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengxinxi), params), params));
+ // 返回成功响应，并将分页数据放入响应中
return R.ok().put("data", page);
}
-
+
/**
* 前端列表
*/
- @IgnoreAuth
+ // 该接口忽略认证
+ @IgnoreAuth
+ // 映射请求路径 /kechengxinxi/list
@RequestMapping("/list")
- public R list(@RequestParam Map params,KechengxinxiEntity kechengxinxi,
- HttpServletRequest request){
+ // 处理前端分页查询课程信息列表的请求
+ public R list(@RequestParam Map params, KechengxinxiEntity kechengxinxi,
+ HttpServletRequest request) {
+ // 创建一个实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = kechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengxinxi), params), params));
+ // 调用课程信息服务类的查询分页方法，进行排序、范围和模糊查询
+ PageUtils page = kechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengxinxi), params), params));
+ // 返回成功响应，并将分页数据放入响应中
return R.ok().put("data", page);
}
- /**
+ /**
* 列表
*/
+ // 映射请求路径 /kechengxinxi/lists
@RequestMapping("/lists")
- public R list( KechengxinxiEntity kechengxinxi){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( kechengxinxi, "kechengxinxi"));
+ // 处理查询课程信息列表的请求
+ public R list(KechengxinxiEntity kechengxinxi) {
+ // 创建一个实体包装器，用于构建查询条件
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，所有字段相等
+ ew.allEq(MPUtil.allEQMapPre(kechengxinxi, "kechengxinxi"));
+ // 返回成功响应，并将查询结果（视图列表）放入响应中
return R.ok().put("data", kechengxinxiService.selectListView(ew));
}
- /**
+ /**
* 查询
*/
+ // 映射请求路径 /kechengxinxi/query
@RequestMapping("/query")
- public R query(KechengxinxiEntity kechengxinxi){
- EntityWrapper< KechengxinxiEntity> ew = new EntityWrapper< KechengxinxiEntity>();
- ew.allEq(MPUtil.allEQMapPre( kechengxinxi, "kechengxinxi"));
- KechengxinxiView kechengxinxiView = kechengxinxiService.selectView(ew);
- return R.ok("查询课程信息成功").put("data", kechengxinxiView);
+ // 处理查询课程信息的请求
+ public R query(KechengxinxiEntity kechengxinxi) {
+ // 创建一个实体包装器，用于构建查询条件
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件，所有字段相等
+ ew.allEq(MPUtil.allEQMapPre(kechengxinxi, "kechengxinxi"));
+ // 调用课程信息服务类的查询视图方法
+ KechengxinxiView kechengxinxiView = kechengxinxiService.selectView(ew);
+ // 返回成功响应，并将查询结果放入响应中，附带成功提示信息
+ return R.ok("查询课程信息成功").put("data", kechengxinxiView);
}
-
+
/**
* 后端详情
*/
+ // 映射请求路径 /kechengxinxi/info/{id}
@RequestMapping("/info/{id}")
- public R info(@PathVariable("id") Long id){
+ // 处理后端查询课程信息详情的请求
+ public R info(@PathVariable("id") Long id) {
+ // 根据 ID 查询课程信息实体
KechengxinxiEntity kechengxinxi = kechengxinxiService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应中
return R.ok().put("data", kechengxinxi);
}
/**
* 前端详情
*/
+ // 映射请求路径 /kechengxinxi/detail/{id}
@RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") Long id){
+ // 处理前端查询课程信息详情的请求
+ public R detail(@PathVariable("id") Long id) {
+ // 根据 ID 查询课程信息实体
KechengxinxiEntity kechengxinxi = kechengxinxiService.selectById(id);
+ // 返回成功响应，并将查询结果放入响应中
return R.ok().put("data", kechengxinxi);
}
-
-
-
/**
* 后端保存
*/
+ // 映射请求路径 /kechengxinxi/save
@RequestMapping("/save")
- public R save(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request){
- kechengxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(kechengxinxi);
+ // 处理后端保存课程信息的请求
+ public R save(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request) {
+ // 生成一个唯一的 ID
+ kechengxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 验证实体（注释掉，未启用）
+ //ValidatorUtils.validateEntity(kechengxinxi);
+ // 调用课程信息服务类的插入方法
kechengxinxiService.insert(kechengxinxi);
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 前端保存
*/
- @IgnoreAuth
+ // 该接口忽略认证
+ @IgnoreAuth
+ // 映射请求路径 /kechengxinxi/add
@RequestMapping("/add")
- public R add(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request){
- kechengxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(kechengxinxi);
+ // 处理前端保存课程信息的请求
+ public R add(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request) {
+ // 生成一个唯一的 ID
+ kechengxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 验证实体（注释掉，未启用）
+ //ValidatorUtils.validateEntity(kechengxinxi);
+ // 调用课程信息服务类的插入方法
kechengxinxiService.insert(kechengxinxi);
+ // 返回成功响应
return R.ok();
}
/**
* 修改
*/
+ // 映射请求路径 /kechengxinxi/update
@RequestMapping("/update")
- public R update(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request){
+ // 处理修改课程信息的请求
+ public R update(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request) {
+ // 验证实体（注释掉，未启用）
//ValidatorUtils.validateEntity(kechengxinxi);
- kechengxinxiService.updateById(kechengxinxi);//全部更新
+ // 调用课程信息服务类的更新方法，更新所有字段
+ kechengxinxiService.updateById(kechengxinxi); // 全部更新
+ // 返回成功响应
return R.ok();
}
-
/**
* 删除
*/
+ // 映射请求路径 /kechengxinxi/delete
@RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
+ // 处理删除课程信息的请求
+ public R delete(@RequestBody Long[] ids) {
+ // 调用课程信息服务类的批量删除方法
kechengxinxiService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
* 提醒接口
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
-
-
- int count = kechengxinxiService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
-
-
-}
+ // 映射请求路径 /kechengxinxi/remind/{columnName}/{type}
+ @RequestMapping("/remind/{columnName}/{type}")
+ // 处理提醒统计的请求
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type, @RequestParam Map map) {
+ // 将列名放入参数映射中
+ map.put("column", columnName);
+ // 将类型放入参数映射中
+ map.put("type", type);
+
+ // 如果类型为 2
+ if (type.equals("2")) {
+ // 创建一个日期格式化对象
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ // 创建一个日历对象
+ Calendar c = Calendar.getInstance();
+ // 提醒开始日期
+ Date remindStartDate = null;
+ // 提醒结束日期
+ Date remindEndDate = null;
+ // 如果提醒开始参数不为空
+ if (map.get("remindstart") != null) {
+ // 将提醒开始参数转换为整数
+ Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+ // 设置日历时间为当前时间
+ c.setTime(new Date());
+ // 在当前日期上加上提醒开始天数
+ c.add(Calendar.DAY_OF_MONTH, remindStart);
+ // 获取提醒开始日期
+ remindStartDate = c.getTime();
+ // 将提醒开始日期格式化后放入参数映射中
+ map.put("remindstart", sdf.format(remindStartDate));
+ }
+ // 如果提醒结束参数不为空
+ if (map.get("remindend") != null) {
+ // 将提醒结束参数转换为整数
+ Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+ // 设置日历时间为当前时间
+ c.setTime(new Date());
+ // 在当前日期上加上提醒结束天数
+ c.add(Calendar.DAY_OF_MONTH, remindEnd);
+ // 获取提醒结束日期
+ remindEndDate = c.getTime();
+ // 将提醒结束日期格式化后放入参数映射中
+ map.put("remindend", sdf.format(remindEndDate));
+ }
+ }
+
+ // 创建一个实体包装器，用于构建查询条件
+ Wrapper wrapper = new EntityWrapper();
+ // 如果提醒开始参数不为空
+ if (map.get("remindstart") != null) {
+ // 设置查询条件，列名大于等于提醒开始日期
+ wrapper.ge(columnName, map.get("remindstart"));
+ }
+ // 如果提醒结束参数不为空
+ if (map.get("remindend") != null) {
+ // 设置查询条件，列名小于等于提醒结束日期
+ wrapper.le(columnName, map.get("remindend"));
+ }
+
+ // 调用课程信息服务类的统计方法，统计符合条件的记录数
+ int count = kechengxinxiService.selectCount(wrapper);
+ // 返回成功响应，并将统计结果放入响应中
+ return R.ok().put("count", count);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/controller/MessagesController.java b/src/main/java/com/controller/MessagesController.java
index b1d92c4..d94aa74 100644
--- a/src/main/java/com/controller/MessagesController.java
+++ b/src/main/java/com/controller/MessagesController.java
@@ -1,213 +1,316 @@
package com.controller;
+// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
+// 导入用于创建动态数组的类
import java.util.ArrayList;
+// 导入用于操作数组的工具类
import java.util.Arrays;
+// 导入用于处理日期和时间的类
import java.util.Calendar;
+// 导入用于存储键值对的接口
import java.util.Map;
+// 导入用于实现Map接口的HashMap类
import java.util.HashMap;
+// 导入用于遍历集合的接口
import java.util.Iterator;
+// 导入用于表示日期和时间的类
import java.util.Date;
+// 导入用于创建列表的接口
import java.util.List;
+// 导入用于处理HTTP请求的类
import javax.servlet.http.HttpServletRequest;
+// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
+// 导入Apache Commons Lang库中的字符串处理工具类
import org.apache.commons.lang3.StringUtils;
+// 导入Spring框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
+// 导入Spring框架的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
+// 导入Spring框架的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
+// 导入Spring框架的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
+// 导入Spring框架的REST控制器注解
import org.springframework.web.bind.annotation.RestController;
+// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
+// 导入留言板实体类
import com.entity.MessagesEntity;
+// 导入留言板视图类
import com.entity.view.MessagesView;
+// 导入留言板服务类
import com.service.MessagesService;
+// 导入令牌服务类
import com.service.TokenService;
+// 导入分页工具类
import com.utils.PageUtils;
+// 导入自定义的响应类
import com.utils.R;
+// 导入MD5加密工具类
import com.utils.MD5Util;
+// 导入MyBatis-Plus工具类
import com.utils.MPUtil;
+// 导入通用工具类
import com.utils.CommonUtil;
/**
* 留言板
* 后端接口
- * @author
- * @email
+ * @author
+ * @email
* @date 2021-05-09 15:46:15
*/
+// 声明为REST控制器，用于处理HTTP请求
@RestController
+// 映射请求路径，所有以/messages开头的请求由该控制器处理
@RequestMapping("/messages")
public class MessagesController {
+ // 自动注入留言板服务类实例
@Autowired
private MessagesService messagesService;
-
/**
- * 后端列表
+ * 后端列表（分页查询）
*/
+ // 映射请求路径/messages/page
@RequestMapping("/page")
- public R page(@RequestParam Map params,MessagesEntity messages,
- HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- messages.setUserid((Long)request.getSession().getAttribute("userId"));
- }
+ // 处理后端分页查询请求，参数包括查询条件、实体对象、HTTP请求
+ public R page(@RequestParam Map params, MessagesEntity messages,
+ HttpServletRequest request) {
+ // 如果当前用户不是管理员
+ if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置留言的用户ID为当前登录用户的ID
+ messages.setUserid((Long) request.getSession().getAttribute("userId"));
+ }
+ // 创建实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = messagesService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, messages), params), params));
-
+ // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理
+ PageUtils page = messagesService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, messages), params), params));
+ // 返回成功响应，携带分页数据
return R.ok().put("data", page);
}
-
+
/**
- * 前端列表
+ * 前端列表（分页查询）
*/
+ // 映射请求路径/messages/list
@RequestMapping("/list")
- public R list(@RequestParam Map params,MessagesEntity messages,
- HttpServletRequest request){
- if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
- messages.setUserid((Long)request.getSession().getAttribute("userId"));
- }
+ // 处理前端分页查询请求，参数包括查询条件、实体对象、HTTP请求
+ public R list(@RequestParam Map params, MessagesEntity messages,
+ HttpServletRequest request) {
+ // 如果当前用户不是管理员
+ if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+ // 设置留言的用户ID为当前登录用户的ID
+ messages.setUserid((Long) request.getSession().getAttribute("userId"));
+ }
+ // 创建实体包装器，用于构建查询条件
EntityWrapper ew = new EntityWrapper();
- PageUtils page = messagesService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, messages), params), params));
+ // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理
+ PageUtils page = messagesService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, messages), params), params));
+ // 返回成功响应，携带分页数据
return R.ok().put("data", page);
}
- /**
- * 列表
+ /**
+ * 列表（不分页，全量查询）
*/
+ // 映射请求路径/messages/lists
@RequestMapping("/lists")
- public R list( MessagesEntity messages){
- EntityWrapper ew = new EntityWrapper();
- ew.allEq(MPUtil.allEQMapPre( messages, "messages"));
+ // 处理全量查询请求，参数为实体对象
+ public R list(MessagesEntity messages) {
+ // 创建实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件：所有字段与实体对象相等（前缀为"messages"）
+ ew.allEq(MPUtil.allEQMapPre(messages, "messages"));
+ // 返回成功响应，携带查询结果（视图列表）
return R.ok().put("data", messagesService.selectListView(ew));
}
- /**
- * 查询
+ /**
+ * 查询（单个对象）
*/
+ // 映射请求路径/messages/query
@RequestMapping("/query")
- public R query(MessagesEntity messages){
- EntityWrapper< MessagesEntity> ew = new EntityWrapper< MessagesEntity>();
- ew.allEq(MPUtil.allEQMapPre( messages, "messages"));
- MessagesView messagesView = messagesService.selectView(ew);
- return R.ok("查询留言板成功").put("data", messagesView);
+ // 处理单个对象查询请求，参数为实体对象
+ public R query(MessagesEntity messages) {
+ // 创建实体包装器
+ EntityWrapper ew = new EntityWrapper();
+ // 设置查询条件：所有字段与实体对象相等（前缀为"messages"）
+ ew.allEq(MPUtil.allEQMapPre(messages, "messages"));
+ // 调用服务类的视图查询方法
+ MessagesView messagesView = messagesService.selectView(ew);
+ // 返回成功响应，携带查询结果和提示信息
+ return R.ok("查询留言板成功").put("data", messagesView);
}
-
+
/**
- * 后端详情
+ * 后端详情（根据ID查询）
*/
+ // 映射请求路径/messages/info/{id}
@RequestMapping("/info/{id}")
- public R info(@PathVariable("id") Long id){
+ // 处理详情查询请求，参数为路径中的ID
+ public R info(@PathVariable("id") Long id) {
+ // 根据ID直接查询实体对象
MessagesEntity messages = messagesService.selectById(id);
+ // 返回成功响应，携带查询到的实体数据
return R.ok().put("data", messages);
}
/**
- * 前端详情
+ * 前端详情（根据ID查询）
*/
+ // 映射请求路径/messages/detail/{id}
@RequestMapping("/detail/{id}")
- public R detail(@PathVariable("id") Long id){
+ // 处理详情查询请求，参数为路径中的ID（前端调用）
+ public R detail(@PathVariable("id") Long id) {
+ // 根据ID直接查询实体对象
MessagesEntity messages = messagesService.selectById(id);
+ // 返回成功响应，携带查询到的实体数据
return R.ok().put("data", messages);
}
-
+
/**
- * 后端保存
+ * 后端保存（新增留言）
*/
+ // 映射请求路径/messages/save
@RequestMapping("/save")
- public R save(@RequestBody MessagesEntity messages, HttpServletRequest request){
- messages.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(messages);
+ // 处理后端新增请求，请求体为实体对象，携带HTTP请求
+ public R save(@RequestBody MessagesEntity messages, HttpServletRequest request) {
+ // 生成唯一ID（时间戳 + 随机数）
+ messages.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 实体验证（注释，未启用）
+ //ValidatorUtils.validateEntity(messages);
+ // 调用服务类的插入方法
messagesService.insert(messages);
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 前端保存
+ * 前端保存（新增留言）
*/
+ // 映射请求路径/messages/add
@RequestMapping("/add")
- public R add(@RequestBody MessagesEntity messages, HttpServletRequest request){
- messages.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
- //ValidatorUtils.validateEntity(messages);
- messages.setUserid((Long)request.getSession().getAttribute("userId"));
+ // 处理前端新增请求，请求体为实体对象，携带HTTP请求
+ public R add(@RequestBody MessagesEntity messages, HttpServletRequest request) {
+ // 生成唯一ID（时间戳 + 随机数）
+ messages.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+ // 实体验证（注释，未启用）
+ //ValidatorUtils.validateEntity(messages);
+ // 设置留言的用户ID为当前登录用户的ID
+ messages.setUserid((Long) request.getSession().getAttribute("userId"));
+ // 调用服务类的插入方法
messagesService.insert(messages);
+ // 返回成功响应
return R.ok();
}
/**
- * 修改
+ * 修改（更新留言）
*/
+ // 映射请求路径/messages/update
@RequestMapping("/update")
- public R update(@RequestBody MessagesEntity messages, HttpServletRequest request){
+ // 处理修改请求，请求体为实体对象，携带HTTP请求
+ public R update(@RequestBody MessagesEntity messages, HttpServletRequest request) {
+ // 实体验证（注释，未启用）
//ValidatorUtils.validateEntity(messages);
- messagesService.updateById(messages);//全部更新
+ // 调用服务类的更新方法（根据ID全量更新）
+ messagesService.updateById(messages); // 全部更新
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 删除
+ * 删除（批量删除留言）
*/
+ // 映射请求路径/messages/delete
@RequestMapping("/delete")
- public R delete(@RequestBody Long[] ids){
+ // 处理删除请求，请求体为ID数组
+ public R delete(@RequestBody Long[] ids) {
+ // 调用服务类的批量删除方法（根据ID列表）
messagesService.deleteBatchIds(Arrays.asList(ids));
+ // 返回成功响应
return R.ok();
}
-
+
/**
- * 提醒接口
+ * 提醒接口（统计符合条件的留言数）
*/
- @RequestMapping("/remind/{columnName}/{type}")
- public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
- @PathVariable("type") String type,@RequestParam Map map) {
- map.put("column", columnName);
- map.put("type", type);
-
- if(type.equals("2")) {
- SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
- Calendar c = Calendar.getInstance();
- Date remindStartDate = null;
- Date remindEndDate = null;
- if(map.get("remindstart")!=null) {
- Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindStart);
- remindStartDate = c.getTime();
- map.put("remindstart", sdf.format(remindStartDate));
- }
- if(map.get("remindend")!=null) {
- Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
- c.setTime(new Date());
- c.add(Calendar.DAY_OF_MONTH,remindEnd);
- remindEndDate = c.getTime();
- map.put("remindend", sdf.format(remindEndDate));
- }
- }
-
- Wrapper wrapper = new EntityWrapper();
- if(map.get("remindstart")!=null) {
- wrapper.ge(columnName, map.get("remindstart"));
- }
- if(map.get("remindend")!=null) {
- wrapper.le(columnName, map.get("remindend"));
- }
-
-
- int count = messagesService.selectCount(wrapper);
- return R.ok().put("count", count);
- }
-
-
-
-}
+ // 映射请求路径/messages/remind/{columnName}/{type}
+ @RequestMapping("/remind/{columnName}/{type}")
+ // 处理提醒统计请求，参数包括列名、类型、查询条件映射
+ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
+ @PathVariable("type") String type, @RequestParam Map