pull/11/head
zl 9 months ago
parent 32613a4bfd
commit aa602c41f7

Binary file not shown.

@ -0,0 +1,8 @@
# Default ignored files
/shelf/
/workspace.xml
# Editor-based HTTP Client requests
/httpRequests/
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml

@ -0,0 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<annotationProcessing>
<profile name="Maven default annotation processors profile" enabled="true">
<sourceOutputDir name="target/generated-sources/annotations" />
<sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
<outputRelativeToContentRoot value="true" />
<module name="exam-api" />
</profile>
</annotationProcessing>
</component>
</project>

@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="MavenProjectsManager">
<option name="originalFiles">
<list>
<option value="$PROJECT_DIR$/exam-api/pom.xml" />
</list>
</option>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="11" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/yfexam-exam-main.iml" filepath="$PROJECT_DIR$/.idea/yfexam-exam-main.iml" />
</modules>
</component>
</project>

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$" />
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

@ -0,0 +1,3 @@
{
"java.compile.nullAnalysis.mode": "automatic"
}

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2021 孤傲的小笼包
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

@ -0,0 +1,97 @@
# 云帆培训考试系统 开源版
# 项目演示
开源版本https://lite.yfhl.net
管理账号admin/admin
学员账号person/person
注意事项:演示环境数据每天晚上会重新初始化,不要往上面导入重要数据;如果账号密码被改无法登录,请联系我们;或等到第二天再访问 :joy:
# 商业版本
如果开源版本无法满足您的需求,或者有需求需要定制,可以考虑我们的商业版本
商业版演示地址https://exam.yfhl.net
商业版官网地址https://www.jeedocm.com/?plan=githuby
QQ交流群二757328773
QQ交流群一865330294已满
# 商业版咨询
杨经理:
邮箱626264481@qq.com
手机18710213152
微信号youyouwx0613
# 介绍
一款多角色在线培训考试系统,系统集成了用户管理、角色管理、部门管理、题库管理、试题管理、试题导入导出、考试管理、在线考试、错题训练等功能,考试流程完善。
# 技术栈
SpringBoot / Shiro / Vue / MySQL
# 产品功能
## 系统完善:完善的权限控制和用户系统
权限控制基于Shiro和JWT开发的权限控制功能。
用户系统:用户管理、部门管理、角色管理等。
## 多角色:多角色支持
考试端:学生学员角色、支持在线考试、查看分数、训练错题。
管理端:题库管理、试题管理、考试管理、用户部门管理、查看考试情况等等。
## 定员考试:考试权限定义
完全公开:任何人员都可以参与考试。
指定部门:只有选中部门的人员才可以看到考试。
## 多题型:常用题型支持
支持题型:单选题、多选题、判断题。
难易程度:普通、困难。
## 便捷组卷:题库组卷
题库组卷:指定题库、分数、数量;题目、选项随机排序、杜绝作弊
# 环境要求
JDK 1.8+ [点此下载](https://cdn.yfhl.net/java-win/jdk-8u181-windows-x64.exe)
Mysql5.7+ [点此下载](https://cdn.yfhl.net/java-win/mysql-installer-community-5.7.31.0.msi)
# 安装资源
1、安装JDK1.8
https://cdn.yfhl.net/java-win/jdk-8u181-windows-x64.exe
2、安装MySQL
https://cdn.yfhl.net/java-win/mysql-installer-community-5.7.31.0.msi
-- 安装过程可能需要VC++
-- https://www.microsoft.com/zh-CN/download/details.aspx?id=40784
-- 安装数据库管理工具
https://cdn.yfhl.net/java-win/SQLyog.12.3.1.0.zip
# 安装视频
https://www.ixigua.com/7041491265027834381?utm_source=xiguastudio
# 快速运行
1、自行安装MySQL数据库版本最好是5.7),将`安装资源中`的`数据库初始化.sql`导入到安装好的数据库
2、安装Java环境要求JDK版本大于1.8
3、请修改外置配置文件application-local.yml 改成您自己的MySQL配置
4、Windows通过start.bat运行Linux运行start.sh运行
5、如果无意外可通过http://localhost:8101 访问到项目了
6、管理员账号密码admin/admin 学员账号person/person
# 其它支持
网站https://www.jeedocm.com/?plan=githuby
QQ交流群二757328773
QQ交流群一865330294已满
![输入图片说明](https://images.gitee.com/uploads/images/2020/1207/173238_e6c22c67_2189748.jpeg "17-32-10.jpg")
![主界面](https://images.gitee.com/uploads/images/2020/1019/182239_4a87af30_2189748.jpeg "222.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/182532_04c42741_2189748.jpeg "444.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/182543_44dcc2d7_2189748.jpeg "555.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/182551_4d404492_2189748.jpeg "666.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/183109_fdc30de8_2189748.jpeg "777.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/183117_30b44530_2189748.jpeg "888.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/183023_2f3baeb9_2189748.jpeg "999.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/183032_f5016335_2189748.jpeg "1010.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/183040_38fd74ed_2189748.jpeg "1111.jpg")
![输入图片说明](https://images.gitee.com/uploads/images/2020/1019/183047_a31619cd_2189748.jpeg "1212.jpg")

@ -0,0 +1,847 @@
/*
Navicat Premium Data Transfer
Source Server : 127.0.0.1-
Source Server Type : MySQL
Source Server Version : 80028 (8.0.28)
Source Host : localhost:3306
Source Schema : yf_exam_lite
Target Server Type : MySQL
Target Server Version : 80028 (8.0.28)
File Encoding : 65001
Date: 20/02/2023 10:38:52
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for el_exam
-- ----------------------------
DROP TABLE IF EXISTS `el_exam`;
CREATE TABLE `el_exam` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`title` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '考试名称',
`content` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '考试描述',
`open_type` int NOT NULL DEFAULT '1' COMMENT '1公开2部门3定员',
`state` int NOT NULL DEFAULT '0' COMMENT '考试状态',
`time_limit` tinyint NOT NULL DEFAULT '0' COMMENT '是否限时',
`start_time` datetime DEFAULT NULL COMMENT '开始时间',
`end_time` datetime DEFAULT NULL COMMENT '结束时间',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
`total_score` int NOT NULL DEFAULT '0' COMMENT '总分数',
`total_time` int NOT NULL DEFAULT '0' COMMENT '总时长(分钟)',
`qualify_score` int NOT NULL DEFAULT '0' COMMENT '及格分数',
PRIMARY KEY (`id`) USING BTREE,
KEY `open_type` (`open_type`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='考试主表';
-- ----------------------------
-- Records of el_exam
-- ----------------------------
BEGIN;
INSERT INTO `el_exam` (`id`, `title`, `content`, `open_type`, `state`, `time_limit`, `start_time`, `end_time`, `create_time`, `update_time`, `total_score`, `total_time`, `qualify_score`) VALUES ('1587621704140427265', '【云帆演示】考试', '【云帆演示】考试', 1, 0, 0, NULL, NULL, '2022-11-02 09:44:46', '2022-11-02 09:44:46', 100, 30, 60);
COMMIT;
-- ----------------------------
-- Table structure for el_exam_depart
-- ----------------------------
DROP TABLE IF EXISTS `el_exam_depart`;
CREATE TABLE `el_exam_depart` (
`id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT 'ID',
`exam_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '考试ID',
`depart_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '部门ID',
PRIMARY KEY (`id`) USING BTREE,
KEY `exam_id` (`exam_id`),
KEY `depart_id` (`depart_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='考试部门';
-- ----------------------------
-- Records of el_exam_depart
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for el_exam_repo
-- ----------------------------
DROP TABLE IF EXISTS `el_exam_repo`;
CREATE TABLE `el_exam_repo` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`exam_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '考试ID',
`repo_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '题库ID',
`radio_count` int NOT NULL DEFAULT '0' COMMENT '单选题数量',
`radio_score` int NOT NULL DEFAULT '0' COMMENT '单选题分数',
`multi_count` int NOT NULL DEFAULT '0' COMMENT '多选题数量',
`multi_score` int NOT NULL DEFAULT '0' COMMENT '多选题分数',
`judge_count` int NOT NULL DEFAULT '0' COMMENT '判断题数量',
`judge_score` int NOT NULL DEFAULT '0' COMMENT '判断题分数',
`saq_count` int NOT NULL DEFAULT '0' COMMENT '简答题数量',
`saq_score` int NOT NULL DEFAULT '0' COMMENT '简答题分数',
PRIMARY KEY (`id`) USING BTREE,
UNIQUE KEY `exam_repo_id` (`exam_id`,`repo_id`),
KEY `rule_id` (`exam_id`) USING BTREE,
KEY `repo_id` (`repo_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='考试题库';
-- ----------------------------
-- Records of el_exam_repo
-- ----------------------------
BEGIN;
INSERT INTO `el_exam_repo` (`id`, `exam_id`, `repo_id`, `radio_count`, `radio_score`, `multi_count`, `multi_score`, `judge_count`, `judge_score`, `saq_count`, `saq_score`) VALUES ('1627496519370297345', '1587621704140427265', '1587622451624120321', 2, 10, 6, 10, 2, 10, 0, 0);
COMMIT;
-- ----------------------------
-- Table structure for el_paper
-- ----------------------------
DROP TABLE IF EXISTS `el_paper`;
CREATE TABLE `el_paper` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '试卷ID',
`user_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '用户ID',
`depart_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '部门ID',
`exam_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '规则ID',
`title` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '考试标题',
`total_time` int NOT NULL DEFAULT '0' COMMENT '考试时长',
`user_time` int NOT NULL DEFAULT '0' COMMENT '用户时长',
`total_score` int NOT NULL DEFAULT '0' COMMENT '试卷总分',
`qualify_score` int NOT NULL DEFAULT '0' COMMENT '及格分',
`obj_score` int NOT NULL DEFAULT '0' COMMENT '客观分',
`subj_score` int NOT NULL DEFAULT '0' COMMENT '主观分',
`user_score` int NOT NULL COMMENT '用户得分',
`has_saq` tinyint NOT NULL DEFAULT '0' COMMENT '是否包含简答题',
`state` int NOT NULL DEFAULT '1' COMMENT '试卷状态',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
`limit_time` datetime DEFAULT NULL COMMENT '截止时间',
PRIMARY KEY (`id`) USING BTREE,
KEY `user_id` (`user_id`) USING BTREE,
KEY `exam_id` (`exam_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='考试记录';
-- ----------------------------
-- Records of el_paper
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for el_paper_qu
-- ----------------------------
DROP TABLE IF EXISTS `el_paper_qu`;
CREATE TABLE `el_paper_qu` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`paper_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '试卷ID',
`qu_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '题目ID',
`qu_type` int NOT NULL COMMENT '题目类型',
`answered` tinyint NOT NULL DEFAULT '0' COMMENT '是否已答',
`answer` varchar(5000) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '主观答案',
`sort` int NOT NULL DEFAULT '0' COMMENT '问题排序',
`score` int NOT NULL DEFAULT '0' COMMENT '单题分分值',
`actual_score` int NOT NULL DEFAULT '0' COMMENT '实际得分(主观题)',
`is_right` tinyint NOT NULL DEFAULT '0' COMMENT '是否答对',
PRIMARY KEY (`id`) USING BTREE,
KEY `paper_id` (`paper_id`) USING BTREE,
KEY `qu_id` (`qu_id`) USING BTREE,
KEY `paper_qu_id` (`paper_id`,`qu_id`) USING BTREE,
KEY `sort` (`sort`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='考试记录考题';
-- ----------------------------
-- Records of el_paper_qu
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for el_paper_qu_answer
-- ----------------------------
DROP TABLE IF EXISTS `el_paper_qu_answer`;
CREATE TABLE `el_paper_qu_answer` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '自增ID',
`paper_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '试卷ID',
`answer_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '回答项ID',
`qu_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '题目ID',
`is_right` tinyint NOT NULL DEFAULT '0' COMMENT '是否正确项',
`checked` tinyint NOT NULL DEFAULT '0' COMMENT '是否选中',
`sort` int NOT NULL DEFAULT '0' COMMENT '排序',
`abc` varchar(64) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '选项标签',
PRIMARY KEY (`id`) USING BTREE,
KEY `paper_id` (`paper_id`) USING BTREE,
KEY `qu_id` (`qu_id`) USING BTREE,
KEY `paper_qu_id` (`paper_id`,`qu_id`) USING BTREE,
KEY `sort` (`sort`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='考试记录答案';
-- ----------------------------
-- Records of el_paper_qu_answer
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for el_qu
-- ----------------------------
DROP TABLE IF EXISTS `el_qu`;
CREATE TABLE `el_qu` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '题目ID',
`qu_type` int NOT NULL COMMENT '题目类型',
`level` int NOT NULL DEFAULT '1' COMMENT '1普通,2较难',
`image` varchar(500) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '题目图片',
`content` varchar(2000) COLLATE utf8mb4_general_ci NOT NULL COMMENT '题目内容',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '更新时间',
`remark` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '题目备注',
`analysis` varchar(2000) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '整题解析',
PRIMARY KEY (`id`) USING BTREE,
KEY `qu_type` (`qu_type`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='试题主表';
-- ----------------------------
-- Records of el_qu
-- ----------------------------
BEGIN;
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642263625729', 1, 1, '', '五个答案中哪个是最好的类比?女儿对于父亲相当于侄女对于', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642393649153', 1, 1, '', '五个答案中哪个是最好的类比?皮对于树相当于鳞对于', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642473340930', 1, 1, '', '火车守车(车尾)长6.4米。机车的长度等于守车的长加上半节车厢的长。车厢长度等于守车长加上机车长。火车的机车、车厢、守车共长多少米?', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642557227009', 1, 1, '', '角对于元相当于小时对于', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642641113089', 1, 1, '', '如果把这个大立方体的六个面全部涂上黑色然后按图中虚线把它切成36个小方块两面有黑色的小方块有多少个', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642699833345', 1, 1, '', '找出与众不同的一个:', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642762747906', 2, 1, '', '以下哪些是中国的特别行政区?', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642838245378', 2, 1, '', '中国东北三省是指()', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642909548545', 3, 1, '', '咖啡的故乡是非洲吗?', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622642976657410', 3, 1, '', '世界上最长的山脉安第斯山脉', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643039571970', 1, 1, '', '西亚波斯湾沿岸比较富裕,其原因是()', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '西亚波斯湾沿岸国家比较富裕,是因为大量出口石油资源.');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643102486530', 1, 1, '', '我国最北面的城市是哪个()', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '漠河市,隶属黑龙江省大兴安岭地区。 [1] 地处黑龙江省北部。西与内蒙古自治区呼伦贝尔市额尔古纳市为邻南与内蒙古自治区根河市和呼中区交界东与塔河县接壤北隔黑龙江与俄罗斯外贝加尔边疆区原赤塔州和阿穆尔州相望是中国最北端的县级行政区地势南高北低南北呈坡降趋势属于寒温带大陆性季风气候。下辖6个镇总面积18427平方千米。 [2] 根据第七次人口普查数据截至2020年11月1日零时漠河市常住人口为54036人。');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643173789698', 1, 1, '', '人们把社会生产的各个部门划分为三类产业,下列属于第三产业的是()', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '通常人们把生产的各部门划分为三类产业.农业是第一产业,包括种植业、林业、畜牧业、渔业等;工业和建筑业是第二产业;流通部门和服务部门是第三产业');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643240898561', 1, 1, '', '亚洲人中分布不是很均匀,其中人中较稀疏的部分是()', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '人口稠密地区都处在中低纬度、近海、平原地区,亚洲人口稀疏的地区在纬度位置较高的北亚,沙漠广布的西亚及气候干旱的中亚地区.');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643312201730', 1, 1, '', '亚洲各国经济发展不平衡,下列国家中人均国民生产总值最高的是()', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '本题还可以考查人口人口超亿的国家有中国、印度、印度尼西亚、巴基斯坦、日本、孟加拉国等6个各大洲人口排序亚非欧南北美大洋洲各大洲人口增长率非南美亚大洋北美欧著名的民族文化亚洲三个人类文明发祥地华夏文化(黄河——长江中下游地区)、印度河流域文化、两河流域文化(由幼法拉底河和底格里斯河冲积而成的美索不达米亚平原地区);还有恒河文化、阿拉伯文化等。亚洲只有日本属于发达国家。');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643396087810', 1, 1, '', '地球上0度经线和0度纬线的长度相比', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '0度经线和0度纬线相比()0度纬线的长度是0度经线的2倍。 因为经线是半圆,赤道是大圆。');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643467390977', 1, 1, '', '下列国家人口超过1亿的南亚国家是', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '世界人口超过一亿的国家从多到少依次为中国、印度、美国、印度尼西亚、巴西、巴基斯坦、俄罗斯、孟加拉国、尼日利亚、日本和墨西哥共有11个其中属于南亚的是印度、巴基斯坦和孟加拉国');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643551277058', 1, 1, '', '世界上跨东西、南北距离最长的大洲是()', '2022-11-02 09:48:29', '2022-11-02 09:48:29', '', '在全球的七大洲中,亚洲是世界上面积最大的一洲,也是南北跨纬度最多,热量差异大; 东西跨经度仅次于南极洲,东西距离最长的大洲;大洋洲是世界上最小的一洲 考点:本题主要考查大洲和大洋。');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643626774530', 1, 1, '', '地球公转会产生()', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '地球自转产生的现象有: 1、昼夜更替现象向着太阳的半球,是白天,背着太阳的半球,是黑夜; 2、南北半球的地转偏向力引起的各种运动旋转现象 3、地球上不同经度的地方,有不同的地方时经度每隔15度,地方时相差一小时; 4、东西部地区的时间差现象生物作息规律现象 5、对地球形状的影响.地球自转所产生的惯性离心力,使得地球由两级向赤道逐渐膨胀,成为目前略扁的旋转椭球体。 地球公转产生的现象有: 1、根据太阳高度的差异,划分出五带:北寒、北温、热带、南温、南寒; 2、根据获得热量多少的时间差异,划分出四季:春、夏、秋、冬; 3、昼夜长短的变化现象 4、天象位置的变化生物生长规律现象. 5、正午太阳高度的变化夏至日太阳直射北回归线全球正午太阳高度从北回归线向南北两侧逐渐递减二分日太阳直射赤道全球正午太阳高度从赤道向两极递减全球昼夜平分冬至日太阳直射南回归线全球正午高度从南回归线向南北两侧逐渐递减南回归线及其以南的地区正午太阳高度达到最大值北半球各纬度正午太阳高度达到最小值。');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643693883394', 2, 1, '', '南极旅游的兴起,请下列哪些因素有关()', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643760992258', 2, 1, '', '交通运输线路(公路、铁路),选址的原因有()', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643823906818', 2, 1, 'http://localhost:8201/upload/file/2022/11/07/1589528183307354113.jpg', '地球自转产生的现象有()', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643895209985', 2, 1, '', '地球公转产生的现象有()', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622643979096066', 3, 1, '', '地球上出现的潮汐是由于地月吸引力。', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622644054593538', 3, 1, '', '被称为“万园之园”的我国古典园林是颐和园。', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622644134285314', 3, 1, '', '世界最长的山脉是安第斯山脉。', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622644201394178', 3, 1, '', '仪表显示当前发动机转速是6000转克/分钟。', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '仪表显示当前车速是20公里/小时。');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622644281085953', 3, 1, '', '仪表显示当前冷却液的温度是90°C。', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '水温表:指示发动机冷却液的温度,单位为摄氏度(C)。水温表指针所指的位置显示当前冷却液的温度。\n如图所示指针指的位置是90表示当前冷却液的温度是9o°C。');
INSERT INTO `el_qu` (`id`, `qu_type`, `level`, `image`, `content`, `create_time`, `update_time`, `remark`, `analysis`) VALUES ('1587622644356583425', 1, 1, '', '我国面积最大的湖泊是()。', '2022-11-02 09:48:30', '2022-11-02 09:48:30', '', '青海湖是我国最大的湖泊它是一个咸水湖面积约4450平方公里说起来也不小了但是如果把它放到全世界范围来看的话青海湖实际上并非大型湖泊单就面积而言在全世界排名第34位和我国国土面积世界第三的位置很不相称世界最大湖泊里海的面积38万平方公里就相当于84个青海湖。');
COMMIT;
-- ----------------------------
-- Table structure for el_qu_answer
-- ----------------------------
DROP TABLE IF EXISTS `el_qu_answer`;
CREATE TABLE `el_qu_answer` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '答案ID',
`qu_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '问题ID',
`is_right` tinyint NOT NULL DEFAULT '0' COMMENT '是否正确',
`image` varchar(500) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '选项图片',
`content` varchar(5000) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '答案内容',
`analysis` varchar(5000) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '答案分析',
PRIMARY KEY (`id`) USING BTREE,
KEY `qu_id` (`qu_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='试题答案选项';
-- ----------------------------
-- Records of el_qu_answer
-- ----------------------------
BEGIN;
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642309763073', '1587622642263625729', 0, '', '母亲', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642318151681', '1587622642263625729', 0, '', '哥哥', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642318151682', '1587622642263625729', 0, '', '侄子', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642318151683', '1587622642263625729', 0, '', '表兄', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642318151684', '1587622642263625729', 1, '', '叔叔', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642402037761', '1587622642393649153', 0, '', '', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642402037762', '1587622642393649153', 0, '', '大海', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642402037763', '1587622642393649153', 0, '', '渔夫', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642402037764', '1587622642393649153', 1, '', '', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642402037765', '1587622642393649153', 0, '', '', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642490118145', '1587622642473340930', 0, '', '25.6米', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642490118146', '1587622642473340930', 0, '', '36米', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642490118147', '1587622642473340930', 1, '', '51.2米', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642490118148', '1587622642473340930', 0, '', '64.4米', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642490118149', '1587622642473340930', 0, '', '76.2米', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642569809922', '1587622642557227009', 1, '', '', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642569809923', '1587622642557227009', 0, '', '', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642569809924', '1587622642557227009', 0, '', '', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642569809925', '1587622642557227009', 0, '', '', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642569809926', '1587622642557227009', 0, '', '', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642649501697', '1587622642641113089', 0, '', '10', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642649501698', '1587622642641113089', 0, '', '12', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642649501699', '1587622642641113089', 1, '', '16', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642649501700', '1587622642641113089', 0, '', '20', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642649501701', '1587622642641113089', 0, '', '8', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642708221953', '1587622642699833345', 0, '', '西安', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642708221954', '1587622642699833345', 0, '', '郑州', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642708221955', '1587622642699833345', 1, '', '哈尔滨', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642708221956', '1587622642699833345', 0, '', '昆明', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642708221957', '1587622642699833345', 0, '', '南昌', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642771136513', '1587622642762747906', 1, '', '香港', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642775330818', '1587622642762747906', 1, '', '澳门', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642775330819', '1587622642762747906', 0, '', '珠海', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642775330820', '1587622642762747906', 0, '', '重庆', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642846633985', '1587622642838245378', 1, '', '黑龙江省', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642846633986', '1587622642838245378', 1, '', '吉林省', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642846633987', '1587622642838245378', 1, '', '辽宁省', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642846633988', '1587622642838245378', 0, '', '河北省', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642917937153', '1587622642909548545', 1, '', '正确', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642917937154', '1587622642909548545', 0, '', '错误', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642985046018', '1587622642976657410', 1, '', '正确', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622642989240321', '1587622642976657410', 0, '', '错误', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643047960578', '1587622643039571970', 0, '', '工亚基础雄厚', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643047960579', '1587622643039571970', 1, '', '拥有丰富的石油资源', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643047960580', '1587622643039571970', 0, '', '第三产业在国内生产总值中的比重大', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643052154882', '1587622643039571970', 0, '', '大力发展出口加工工业', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643110875137', '1587622643102486530', 0, '', '铁岭', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643110875138', '1587622643102486530', 0, '', '齐齐哈尔', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643110875139', '1587622643102486530', 0, '', '沈阳', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643110875140', '1587622643102486530', 1, '', '漠河', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643182178305', '1587622643173789698', 0, '', '工业', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643182178306', '1587622643173789698', 0, '', '建筑业', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643182178307', '1587622643173789698', 1, '', '服务业', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643182178308', '1587622643173789698', 0, '', '农业', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643249287170', '1587622643240898561', 0, '', '东亚', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643253481474', '1587622643240898561', 0, '', '东南亚', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643253481475', '1587622643240898561', 0, '', '南亚', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643253481476', '1587622643240898561', 1, '', '西亚', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643324784642', '1587622643312201730', 0, '', '韩国', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643324784643', '1587622643312201730', 0, '', '新加坡', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643324784644', '1587622643312201730', 1, '', '日本', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643324784645', '1587622643312201730', 0, '', '马来西亚', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643404476417', '1587622643396087810', 1, '', '0度纬线稍长', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643404476418', '1587622643396087810', 0, '', '0度经线稍长', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643404476419', '1587622643396087810', 0, '', '相等', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643404476420', '1587622643396087810', 0, '', '0度经线不到0度纬线的1/2', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643479973889', '1587622643467390977', 1, '', '孟加拉国', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643479973890', '1587622643467390977', 0, '', '印度尼西亚', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643479973891', '1587622643467390977', 0, '', '日本', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643479973892', '1587622643467390977', 0, '', '韩国', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643563859970', '1587622643551277058', 0, '', '非洲', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643563859971', '1587622643551277058', 0, '', '北美洲', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643563859972', '1587622643551277058', 0, '', '大洋洲', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643563859973', '1587622643551277058', 1, '', '亚洲', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643635163138', '1587622643626774530', 1, '', '四季现象', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643639357441', '1587622643626774530', 0, '', '昼夜交替', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643639357442', '1587622643626774530', 0, '', '时间差异', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643639357443', '1587622643626774530', 0, '', '日期差异', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643702272001', '1587622643693883394', 1, '', '人们的求知、探秘和猎奇欲望的增长', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643702272002', '1587622643693883394', 1, '', '交通工具的发展', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643702272003', '1587622643693883394', 0, '', '促使不同国家的地区的文化交增进友谊', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643702272004', '1587622643693883394', 1, '', '科学技术的进步', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643765186561', '1587622643760992258', 1, '', '等高线稀疏', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643769380865', '1587622643760992258', 1, '', '地形坡度和缓', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643769380866', '1587622643760992258', 0, '', '隧道多', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643769380867', '1587622643760992258', 0, '', '地形复杂', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643832295426', '1587622643823906818', 1, 'http://localhost:8201/upload/file/2022/11/07/1589528211451133954.jpg', '南北半球的地转偏向力引起的各种运动旋转现象;', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643832295427', '1587622643823906818', 1, '', '地球上不同经度的地方,有不同的地方时经度每隔15度,地方时相差一小时;', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643832295428', '1587622643823906818', 1, 'http://localhost:8201/upload/file/2022/11/07/1589528315486650369.jpeg', '东西部地区的时间差现象,生物作息规律现象;', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643832295429', '1587622643823906818', 1, '', '对地球形状的影响.地球自转所产生的惯性离心力,使得地球由两级向赤道逐渐膨胀,成为目前略扁的旋转椭球体。', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643832295430', '1587622643823906818', 1, '', '昼夜更替现象,向着太阳的半球,是白天,背着太阳的半球,是黑夜;', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643903598594', '1587622643895209985', 1, '', '根据太阳高度的差异,划分出五带:北寒、北温、热带、南温、南寒;', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643903598595', '1587622643895209985', 1, '', '根据获得热量多少的时间差异,划分出四季:春、夏、秋、冬;', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643903598596', '1587622643895209985', 1, '', '昼夜长短的变化现象;', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643903598597', '1587622643895209985', 1, '', '正午太阳高度的变化;夏至日太阳直射北回归线,全球正午太阳高度从北回归线向南北两侧逐渐递减;二分日太阳直射赤道,全球正午太阳高度从赤道向两极递减,全球昼夜平分;冬至日太阳直射南回归线,全球正午高度从南回归线向南北两侧逐渐递减,南回归线及其以南的地区正午太阳高度达到最大值,北半球各纬度正午太阳高度达到最小值。', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643983290369', '1587622643979096066', 1, '', '正确', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622643987484674', '1587622643979096066', 0, '', '错误', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644058787842', '1587622644054593538', 0, '', '正确', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644062982146', '1587622644054593538', 1, '', '错误', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644138479618', '1587622644134285314', 1, '', '正确', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644142673922', '1587622644134285314', 0, '', '错误', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644209782786', '1587622644201394178', 0, '', '正确', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644209782787', '1587622644201394178', 1, '', '错误', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644289474562', '1587622644281085953', 1, '', '正确', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644289474563', '1587622644281085953', 0, '', '错误', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644364972034', '1587622644356583425', 1, '', '青海湖', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644364972035', '1587622644356583425', 0, '', '太湖', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644364972036', '1587622644356583425', 0, '', '洞庭湖', '');
INSERT INTO `el_qu_answer` (`id`, `qu_id`, `is_right`, `image`, `content`, `analysis`) VALUES ('1587622644369166338', '1587622644356583425', 0, '', '鄱阳湖', '');
COMMIT;
-- ----------------------------
-- Table structure for el_qu_repo
-- ----------------------------
DROP TABLE IF EXISTS `el_qu_repo`;
CREATE TABLE `el_qu_repo` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL,
`qu_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '试题',
`repo_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '归属题库',
`qu_type` int NOT NULL DEFAULT '0' COMMENT '题目类型',
`sort` int NOT NULL DEFAULT '0' COMMENT '排序',
PRIMARY KEY (`id`) USING BTREE,
KEY `qu_id` (`qu_id`) USING BTREE,
KEY `repo_id` (`repo_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='试题题库关联';
-- ----------------------------
-- Records of el_qu_repo
-- ----------------------------
BEGIN;
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670122192897', '1587622643760992258', '1587622451624120321', 2, 1);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670143164418', '1587622644281085953', '1587622451624120321', 3, 2);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670159941633', '1587622643626774530', '1587622451624120321', 1, 3);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670180913153', '1587622644134285314', '1587622451624120321', 3, 4);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670201884673', '1587622643979096066', '1587622451624120321', 3, 5);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670243827714', '1587622644356583425', '1587622451624120321', 1, 6);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670268993537', '1587622643693883394', '1587622451624120321', 2, 7);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670315130881', '1587622644201394178', '1587622451624120321', 3, 8);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670340296706', '1587622644054593538', '1587622451624120321', 3, 9);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670361268226', '1587622643895209985', '1587622451624120321', 2, 10);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670382239745', '1587622642641113089', '1587622451624120321', 1, 11);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670411599873', '1587622643102486530', '1587622451624120321', 1, 12);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670436765698', '1587622642473340930', '1587622451624120321', 1, 13);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670461931522', '1587622642976657410', '1587622451624120321', 3, 14);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670491291650', '1587622642263625729', '1587622451624120321', 1, 15);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670520651778', '1587622643467390977', '1587622451624120321', 1, 16);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670545817602', '1587622642838245378', '1587622451624120321', 2, 17);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670575177730', '1587622643312201730', '1587622451624120321', 1, 18);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670604537858', '1587622642699833345', '1587622451624120321', 1, 19);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670638092289', '1587622643173789698', '1587622451624120321', 1, 20);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670667452417', '1587622642557227009', '1587622451624120321', 1, 21);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670696812545', '1587622643039571970', '1587622451624120321', 1, 22);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670721978369', '1587622643551277058', '1587622451624120321', 1, 23);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670751338497', '1587622642393649153', '1587622451624120321', 1, 24);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670776504322', '1587622642909548545', '1587622451624120321', 3, 25);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670810058754', '1587622643396087810', '1587622451624120321', 1, 26);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670843613186', '1587622642762747906', '1587622451624120321', 2, 27);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1587622670872973313', '1587622643240898561', '1587622451624120321', 1, 28);
INSERT INTO `el_qu_repo` (`id`, `qu_id`, `repo_id`, `qu_type`, `sort`) VALUES ('1589528323552296962', '1587622643823906818', '1587622451624120321', 2, 29);
COMMIT;
-- ----------------------------
-- Table structure for el_repo
-- ----------------------------
DROP TABLE IF EXISTS `el_repo`;
CREATE TABLE `el_repo` (
`id` varchar(64) CHARACTER SET utf8 NOT NULL COMMENT '题库ID',
`code` varchar(255) CHARACTER SET utf8 NOT NULL DEFAULT '' COMMENT '题库编号',
`title` varchar(255) CHARACTER SET utf8 NOT NULL COMMENT '题库名称',
`remark` varchar(255) CHARACTER SET utf8 NOT NULL DEFAULT '' COMMENT '题库备注',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='题库信息';
-- ----------------------------
-- Records of el_repo
-- ----------------------------
BEGIN;
INSERT INTO `el_repo` (`id`, `code`, `title`, `remark`, `create_time`, `update_time`) VALUES ('1587622451624120321', '', '【云帆】演示题库', '【云帆】演示题库', '2022-11-02 09:47:44', '2022-11-02 09:47:44');
COMMIT;
-- ----------------------------
-- Table structure for el_user_book
-- ----------------------------
DROP TABLE IF EXISTS `el_user_book`;
CREATE TABLE `el_user_book` (
`id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`exam_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '考试ID',
`user_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '用户ID',
`qu_id` varchar(64) COLLATE utf8mb4_general_ci NOT NULL COMMENT '题目ID',
`create_time` datetime DEFAULT NULL COMMENT '加入时间',
`update_time` datetime DEFAULT NULL COMMENT '最近错误时间',
`wrong_count` int NOT NULL COMMENT '错误时间',
`title` varchar(1000) COLLATE utf8mb4_general_ci NOT NULL COMMENT '题目标题',
`sort` int NOT NULL COMMENT '错题序号',
PRIMARY KEY (`id`) USING BTREE,
KEY `user_id` (`user_id`),
KEY `sort` (`sort`),
KEY `exam_id` (`exam_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='错题本';
-- ----------------------------
-- Records of el_user_book
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for el_user_exam
-- ----------------------------
DROP TABLE IF EXISTS `el_user_exam`;
CREATE TABLE `el_user_exam` (
`id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL,
`user_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '用户ID',
`exam_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '考试ID',
`try_count` int NOT NULL DEFAULT '1' COMMENT '考试次数',
`max_score` int NOT NULL DEFAULT '0' COMMENT '最高分数',
`passed` tinyint NOT NULL DEFAULT '0' COMMENT '是否通过',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`) USING BTREE,
UNIQUE KEY `user_id` (`user_id`,`exam_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='考试记录';
-- ----------------------------
-- Records of el_user_exam
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_BLOB_TRIGGERS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_BLOB_TRIGGERS`;
CREATE TABLE `QRTZ_BLOB_TRIGGERS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`BLOB_DATA` blob,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `QRTZ_TRIGGERS` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_BLOB_TRIGGERS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_CALENDARS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_CALENDARS`;
CREATE TABLE `QRTZ_CALENDARS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`CALENDAR_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`CALENDAR` blob NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`CALENDAR_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_CALENDARS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_CRON_TRIGGERS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_CRON_TRIGGERS`;
CREATE TABLE `QRTZ_CRON_TRIGGERS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`CRON_EXPRESSION` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`TIME_ZONE_ID` varchar(80) COLLATE utf8mb4_general_ci DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `QRTZ_TRIGGERS` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_CRON_TRIGGERS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_FIRED_TRIGGERS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_FIRED_TRIGGERS`;
CREATE TABLE `QRTZ_FIRED_TRIGGERS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`ENTRY_ID` varchar(95) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`INSTANCE_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`FIRED_TIME` bigint NOT NULL,
`SCHED_TIME` bigint NOT NULL,
`PRIORITY` int NOT NULL,
`STATE` varchar(16) COLLATE utf8mb4_general_ci NOT NULL,
`JOB_NAME` varchar(200) COLLATE utf8mb4_general_ci DEFAULT NULL,
`JOB_GROUP` varchar(200) COLLATE utf8mb4_general_ci DEFAULT NULL,
`IS_NONCONCURRENT` varchar(1) COLLATE utf8mb4_general_ci DEFAULT NULL,
`REQUESTS_RECOVERY` varchar(1) COLLATE utf8mb4_general_ci DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_FIRED_TRIGGERS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_JOB_DETAILS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_JOB_DETAILS`;
CREATE TABLE `QRTZ_JOB_DETAILS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`JOB_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`JOB_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`DESCRIPTION` varchar(250) COLLATE utf8mb4_general_ci DEFAULT NULL,
`JOB_CLASS_NAME` varchar(250) COLLATE utf8mb4_general_ci NOT NULL,
`IS_DURABLE` varchar(1) COLLATE utf8mb4_general_ci NOT NULL,
`IS_NONCONCURRENT` varchar(1) COLLATE utf8mb4_general_ci NOT NULL,
`IS_UPDATE_DATA` varchar(1) COLLATE utf8mb4_general_ci NOT NULL,
`REQUESTS_RECOVERY` varchar(1) COLLATE utf8mb4_general_ci NOT NULL,
`JOB_DATA` blob,
PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_JOB_DETAILS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_LOCKS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_LOCKS`;
CREATE TABLE `QRTZ_LOCKS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`LOCK_NAME` varchar(40) COLLATE utf8mb4_general_ci NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_LOCKS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_PAUSED_TRIGGER_GRPS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_PAUSED_TRIGGER_GRPS`;
CREATE TABLE `QRTZ_PAUSED_TRIGGER_GRPS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_PAUSED_TRIGGER_GRPS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_SCHEDULER_STATE
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_SCHEDULER_STATE`;
CREATE TABLE `QRTZ_SCHEDULER_STATE` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`INSTANCE_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`LAST_CHECKIN_TIME` bigint NOT NULL,
`CHECKIN_INTERVAL` bigint NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`INSTANCE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_SCHEDULER_STATE
-- ----------------------------
BEGIN;
INSERT INTO `QRTZ_SCHEDULER_STATE` (`SCHED_NAME`, `INSTANCE_NAME`, `LAST_CHECKIN_TIME`, `CHECKIN_INTERVAL`) VALUES ('examScheduler', 'MacBook-Pro-16.local1676860344454', 1676860726631, 10000);
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_SIMPLE_TRIGGERS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_SIMPLE_TRIGGERS`;
CREATE TABLE `QRTZ_SIMPLE_TRIGGERS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`REPEAT_COUNT` bigint NOT NULL,
`REPEAT_INTERVAL` bigint NOT NULL,
`TIMES_TRIGGERED` bigint NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `QRTZ_TRIGGERS` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_SIMPLE_TRIGGERS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_SIMPROP_TRIGGERS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_SIMPROP_TRIGGERS`;
CREATE TABLE `QRTZ_SIMPROP_TRIGGERS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`STR_PROP_1` varchar(512) COLLATE utf8mb4_general_ci DEFAULT NULL,
`STR_PROP_2` varchar(512) COLLATE utf8mb4_general_ci DEFAULT NULL,
`STR_PROP_3` varchar(512) COLLATE utf8mb4_general_ci DEFAULT NULL,
`INT_PROP_1` int DEFAULT NULL,
`INT_PROP_2` int DEFAULT NULL,
`LONG_PROP_1` bigint DEFAULT NULL,
`LONG_PROP_2` bigint DEFAULT NULL,
`DEC_PROP_1` decimal(13,4) DEFAULT NULL,
`DEC_PROP_2` decimal(13,4) DEFAULT NULL,
`BOOL_PROP_1` varchar(1) COLLATE utf8mb4_general_ci DEFAULT NULL,
`BOOL_PROP_2` varchar(1) COLLATE utf8mb4_general_ci DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `QRTZ_TRIGGERS` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_SIMPROP_TRIGGERS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for QRTZ_TRIGGERS
-- ----------------------------
DROP TABLE IF EXISTS `QRTZ_TRIGGERS`;
CREATE TABLE `QRTZ_TRIGGERS` (
`SCHED_NAME` varchar(120) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`JOB_NAME` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`JOB_GROUP` varchar(200) COLLATE utf8mb4_general_ci NOT NULL,
`DESCRIPTION` varchar(250) COLLATE utf8mb4_general_ci DEFAULT NULL,
`NEXT_FIRE_TIME` bigint DEFAULT NULL,
`PREV_FIRE_TIME` bigint DEFAULT NULL,
`PRIORITY` int DEFAULT NULL,
`TRIGGER_STATE` varchar(16) COLLATE utf8mb4_general_ci NOT NULL,
`TRIGGER_TYPE` varchar(8) COLLATE utf8mb4_general_ci NOT NULL,
`START_TIME` bigint NOT NULL,
`END_TIME` bigint DEFAULT NULL,
`CALENDAR_NAME` varchar(200) COLLATE utf8mb4_general_ci DEFAULT NULL,
`MISFIRE_INSTR` smallint DEFAULT NULL,
`JOB_DATA` blob,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
KEY `SCHED_NAME` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `QRTZ_JOB_DETAILS` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-- ----------------------------
-- Records of QRTZ_TRIGGERS
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for sys_config
-- ----------------------------
DROP TABLE IF EXISTS `sys_config`;
CREATE TABLE `sys_config` (
`id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`site_name` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '系统名称',
`front_logo` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '前端LOGO',
`back_logo` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '后台LOGO',
`copy_right` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '版权信息',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
`create_by` varchar(255) COLLATE utf8mb4_general_ci DEFAULT '' COMMENT '创建人',
`update_by` varchar(255) COLLATE utf8mb4_general_ci DEFAULT '' COMMENT '修改人',
`data_flag` int DEFAULT '0' COMMENT '数据标识',
PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='系统设置';
-- ----------------------------
-- Records of sys_config
-- ----------------------------
BEGIN;
INSERT INTO `sys_config` (`id`, `site_name`, `front_logo`, `back_logo`, `copy_right`, `create_time`, `update_time`, `create_by`, `update_by`, `data_flag`) VALUES ('1', '云帆在线培训考试系统', NULL, NULL, NULL, '2020-12-03 16:51:30', '2020-12-03 16:51:30', '', '', 1);
COMMIT;
-- ----------------------------
-- Table structure for sys_depart
-- ----------------------------
DROP TABLE IF EXISTS `sys_depart`;
CREATE TABLE `sys_depart` (
`id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`dept_type` int NOT NULL DEFAULT '1' COMMENT '1公司2部门',
`parent_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '所属上级',
`dept_name` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '部门名称',
`dept_code` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '部门编码',
`sort` int NOT NULL DEFAULT '0' COMMENT '排序',
PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='部门信息';
-- ----------------------------
-- Records of sys_depart
-- ----------------------------
BEGIN;
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1302853644578000898', 1, '0', '北京云帆互联科技有限公司', 'A01', 1);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1302855940200284161', 1, '1302855776496599041', '后端组', 'A01A01A01', 2);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1302855994843676674', 1, '1302855776496599041', '前端组', 'A01A01A02', 1);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1302856017283203073', 1, '1302855776496599041', '产品组', 'A01A01A03', 3);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1302856084475953154', 1, '1302855776496599041', '测试组', 'A01A01A05', 5);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1302856266567467010', 1, '1302855896415944705', '客户一组', 'A01A05A01', 1);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1302856320602685442', 1, '1302855896415944705', '客服二组', 'A01A05A02', 2);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1318103313740320770', 1, '1302853644578000898', '技术部', 'A01A01', 1);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1318103339229106178', 1, '1302853644578000898', '人事部', 'A01A02', 2);
INSERT INTO `sys_depart` (`id`, `dept_type`, `parent_id`, `dept_name`, `dept_code`, `sort`) VALUES ('1318103362494910465', 1, '1302853644578000898', '财务部', 'A01A03', 3);
COMMIT;
-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
`id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '角色ID',
`role_name` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '角色名称',
PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='角色';
-- ----------------------------
-- Records of sys_role
-- ----------------------------
BEGIN;
INSERT INTO `sys_role` (`id`, `role_name`) VALUES ('sa', '超级管理员');
INSERT INTO `sys_role` (`id`, `role_name`) VALUES ('student', '学员');
COMMIT;
-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user` (
`id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`user_name` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '用户名',
`real_name` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '真实姓名',
`password` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '密码',
`salt` varchar(255) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '密码盐',
`role_ids` varchar(500) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '角色列表',
`depart_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '部门ID',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
`state` int NOT NULL DEFAULT '0' COMMENT '状态',
`data_flag` int NOT NULL DEFAULT '0' COMMENT '0正常,1隐藏',
PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='管理用户';
-- ----------------------------
-- Records of sys_user
-- ----------------------------
BEGIN;
INSERT INTO `sys_user` (`id`, `user_name`, `real_name`, `password`, `salt`, `role_ids`, `depart_id`, `create_time`, `update_time`, `state`, `data_flag`) VALUES ('10001', 'admin', '超管A', '06681cd08837b21adf6b5ef9279d403d', 'XoFFuS', 'sa', '1318103313740320770', '2020-04-20 13:51:03', '2020-04-20 13:51:03', 0, 0);
INSERT INTO `sys_user` (`id`, `user_name`, `real_name`, `password`, `salt`, `role_ids`, `depart_id`, `create_time`, `update_time`, `state`, `data_flag`) VALUES ('1252125239901696002', 'person', '张三', '6dfdd6761a3e8319719f32abb9aeae9c', 'tZCjLq', 'student', '1318103339229106178', '2020-04-20 14:41:35', '2020-04-20 14:41:35', 0, 0);
COMMIT;
-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
`id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`user_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '用户ID',
`role_id` varchar(32) COLLATE utf8mb4_general_ci NOT NULL COMMENT '角色ID',
PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户角色';
-- ----------------------------
-- Records of sys_user_role
-- ----------------------------
BEGIN;
INSERT INTO `sys_user_role` (`id`, `user_id`, `role_id`) VALUES ('1318103579445284865', '10001', 'sa');
INSERT INTO `sys_user_role` (`id`, `user_id`, `role_id`) VALUES ('1318128865264132097', '1252125239901696002', 'student');
INSERT INTO `sys_user_role` (`id`, `user_id`, `role_id`) VALUES ('1587574421424279555', '1587574421424279554', 'student');
COMMIT;
SET FOREIGN_KEY_CHECKS = 1;

@ -0,0 +1,4 @@
1、把运行包中的exam-api.jar和application-local.yml复制到本目录
2、运行命令注册为Windows系统服务yf-exam.exe install
3、在服务中即可找到名称为CloudExam的服务启动即可告别黑窗烦恼
注:本功能适合.NetFramework 4.0版本,如果无法注册,请检查环境是否匹配

@ -0,0 +1,8 @@
<service>
<id>yf-exam</id>
<name>CloudExam</name>
<description>云帆在线考试系统服务运行在http://localhost:8101</description>
<executable>java</executable>
<arguments>-jar exam-api.jar --spring.config.location=application-local.yml</arguments>
<log mode="roll"></log>
</service>

@ -0,0 +1,85 @@
# 独立配置文件可以拿到jar外面跑
spring:
application:
name: yf-exam-lite
profiles:
active: dev
main:
allow-bean-definition-overriding: true
# 数据库配置
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/yf_exam?useSSL=false&serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&allowPublicKeyRetrieval=true
username: root
password: 123456
# druid相关配置
druid:
max-active: 5000
initial-size: 20
min-idle: 5
async-init: true
# 监控统计
filters: stat,wall
filter:
stat:
log-slow-sql: true
slow-sql-millis: 5000
wall:
config:
create-table-allow: false
alter-table-allow: false
drop-table-allow: false
truncate-allow: false
# 定时任务配置
quartz:
# 数据库方式
job-store-type: jdbc
# quartz 相关属性配置
properties:
org:
quartz:
scheduler:
instanceName: examScheduler
instanceId: AUTO
jobStore:
class: org.quartz.impl.jdbcjobstore.JobStoreTX
driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
tablePrefix: QRTZ_
isClustered: true
clusterCheckinInterval: 10000
useProperties: false
threadPool:
class: org.quartz.simpl.SimpleThreadPool
threadCount: 10
threadPriority: 5
threadsInheritContextClassLoaderOfInitializingThread: true
server:
port: 8101
# 启用服务端压缩
compression:
enabled: true
min-response-size: 10
mime-types: application/json,application/xml,text/html,text/xml,text/plain,application/javascript,text/css
# 文件上传配置
conf:
upload:
# 物理文件存储位置,以/结束windows已正斜杠d:/exam-upload/
dir: S:/upload/
# 访问地址,注意不要去除/upload/file/,此节点为虚拟标识符
# 如http://localhost:8101/upload/file/exam.jpg对应物理文件为/data/upload/exam.jpg
url: http://localhost:8101/upload/file/
# 允许上传的文件后缀
allow-extensions: jpg,jpeg,png
# 开启文档
swagger:
enable: true
logging:
level:
root: debug
path: logs/${spring.application.name}/

File diff suppressed because one or more lines are too long

@ -0,0 +1 @@
java -jar exam-api.jar --spring.config.location=application-local.yml

@ -0,0 +1 @@
java -jar exam-api.jar --spring.config.location=application-local.yml

@ -0,0 +1,7 @@
1、下载编译好的jar包到本目录或您自行编译https://cdn.yfhl.net/lite/exam-api.jar
2、自行安装MySQL数据库版本最好是5.7),将`安装资源中`的`数据库初始化.sql`导入到安装好的数据库
3、安装Java环境要求JDK版本大于1.8
4、请修改外置配置文件application-local.yml 改成您自己的MySQL配置
5、Windows通过start.bat运行Linux运行start.sh运行
6、如果无意外可通过http://localhost:8101 访问到项目了
7、管理员账号密码admin/admin 学员账号person/person

@ -0,0 +1,8 @@
# Default ignored files
/shelf/
/workspace.xml
# Editor-based HTTP Client requests
/httpRequests/
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml

@ -0,0 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<annotationProcessing>
<profile name="Maven default annotation processors profile" enabled="true">
<sourceOutputDir name="target/generated-sources/annotations" />
<sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
<outputRelativeToContentRoot value="true" />
<module name="exam-api" />
</profile>
</annotationProcessing>
</component>
</project>

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="MavenProjectsManager">
<option name="originalFiles">
<list>
<option value="$PROJECT_DIR$/pom.xml" />
</list>
</option>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="11" project-jdk-type="JavaSDK" />
</project>

@ -0,0 +1,215 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.yfhl</groupId>
<artifactId>exam-api</artifactId>
<packaging>jar</packaging>
<version>1.0</version>
<name>exam-api</name>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<properties>
<fastjson.version>2.0.24</fastjson.version>
<oss.version>3.7.0</oss.version>
<aliyun.sdk.version>4.1.1</aliyun.sdk.version>
<swagger.version>2.9.2</swagger.version>
<dozer.version>5.5.1</dozer.version>
<apache.commons.version>3.8</apache.commons.version>
<mysql.driver.version>8.0.11</mysql.driver.version>
<mybatis-plus.version>3.4.1</mybatis-plus.version>
<lombok.version>1.18.4</lombok.version>
<thymeleaf.version>3.0.11.RELEASE</thymeleaf.version>
<alicloud.version>2.1.1.RELEASE</alicloud.version>
<poi.version>3.9</poi.version>
<log4j2.version>2.17.2</log4j2.version>
</properties>
<dependencies>
<!-- WEB支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--spring quartz依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.5</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<dependency>
<groupId>net.sf.dozer</groupId>
<artifactId>dozer</artifactId>
<version>${dozer.version}</version>
<exclusions>
<exclusion>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
</exclusion>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.driver.version}</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>2.1.1</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>${swagger.version}</version>
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>swagger-bootstrap-ui</artifactId>
<version>1.9.3</version>
</dependency>
<!-- poi office -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>${poi.version}</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>${poi.version}</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml-schemas</artifactId>
<version>${poi.version}</version>
</dependency>
<!--JWT-->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.7.0</version>
</dependency>
<!-- Shiro -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring-boot-starter</artifactId>
<version>1.8.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.6</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.11.0</version>
</dependency>
</dependencies>
<build>
<finalName>${project.name}</finalName>
<defaultGoal>compile</defaultGoal>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
<configuration>
<skipTests>true</skipTests>
</configuration>
</plugin>
</plugins>
</build>
</project>

@ -0,0 +1,18 @@
// 定义包路径,用于存放系统基础功能相关的类
package com.yf.exam.ability;
/**
*
* 使访
* @author bool
*/
public class Constant {
/**
*
* URL
* : /upload/file/example.jpg
* URL便访
*/
public static final String FILE_PREFIX = "/upload/file/";
}

@ -0,0 +1,19 @@
// 定义包路径,用于存放任务分组相关的枚举类
package com.yf.exam.ability.job.enums;
/**
*
*
*
*
* @author van
*/
public interface JobGroup {
/**
*
*
* 便
*/
String SYSTEM = "system"; // 系统任务组的标识符
}

@ -0,0 +1,19 @@
// 定义包路径,用于存放任务前缀相关的枚举类
package com.yf.exam.ability.job.enums;
/**
*
*
*
*
* @author bool
*/
public interface JobPrefix {
/**
*
* 便
* break_exam_12345 ID12345
*/
String BREAK_EXAM = "break_exam_"; // 强制交卷任务的前缀标识符
}

@ -0,0 +1,66 @@
// 定义包路径,用于存放任务服务接口
package com.yf.exam.ability.job.service;
/**
*
*
*
* @author bool
* @date 2020/11/29 2:17
*/
public interface JobService {
/**
*
* JobDataMap
*/
String TASK_DATA = "taskData"; // 用于存储任务相关数据的键名
/**
*
* cron
*
* @param jobClass
* @param jobName
* @param cron cron
* @param data
*/
void addCronJob(Class jobClass, String jobName, String cron, String data);
/**
*
*
*
* @param jobClass
* @param jobName
* @param data
*/
void addCronJob(Class jobClass, String jobName, String data);
/**
*
*
*
* @param jobName
* @param jobGroup
*/
void pauseJob(String jobName, String jobGroup);
/**
*
*
*
* @param triggerName
* @param triggerGroup
*/
void resumeJob(String triggerName, String triggerGroup);
/**
*
*
*
* @param jobName
* @param jobGroup
*/
void deleteJob(String jobName, String jobGroup);
}

@ -0,0 +1,186 @@
// 定义包路径,用于存放任务服务实现类
package com.yf.exam.ability.job.service.impl;
// 导入所需的外部依赖包
import com.alibaba.fastjson.JSON; // 用于JSON数据处理
import com.baomidou.mybatisplus.core.toolkit.IdWorker; // 用于生成唯一ID
import com.yf.exam.ability.job.enums.JobGroup; // 任务分组枚举
import com.yf.exam.ability.job.service.JobService; // 任务服务接口
import lombok.extern.log4j.Log4j2; // 日志注解
import org.quartz.*; // Quartz定时任务框架相关类
import org.springframework.beans.factory.annotation.Autowired; // Spring自动注入注解
import org.springframework.scheduling.quartz.SchedulerFactoryBean; // Quartz调度器工厂Bean
import org.springframework.stereotype.Service; // Spring服务注解
import org.springframework.util.StringUtils; // Spring字符串工具类
/**
*
*
* @author bool
*/
@Log4j2 // 启用Log4j2日志
@Service // 标记为Spring服务组件
public class JobServiceImpl implements JobService {
/**
* Quartz
*
*/
private Scheduler scheduler; // 定时任务调度器实例
/**
* SchedulerFactoryBean
* SpringQuartzBean
* @param schedulerFactoryBean QuartzBean
*/
public JobServiceImpl(@Autowired SchedulerFactoryBean schedulerFactoryBean) {
// 从工厂Bean中获取调度器实例
scheduler = schedulerFactoryBean.getScheduler();
}
/**
*
* cron
*
* @param jobClass
* @param jobName
* @param cron cron
* @param data
*/
@Override
public void addCronJob(Class jobClass, String jobName, String cron, String data) {
// 设置任务组为系统任务组
String jobGroup = JobGroup.SYSTEM;
// 如果任务名为空,则自动生成任务名
if(StringUtils.isEmpty(jobName)){
// 使用类名大写+下划线+唯一ID作为任务名
jobName = jobClass.getSimpleName().toUpperCase() + "_" + IdWorker.getIdStr();
}
try {
// 创建任务键,用于唯一标识任务
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
// 获取任务详情
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
// 如果任务已存在,则删除旧任务
if (jobDetail != null) {
log.info("++++++++++任务:{} 已存在", jobName);
this.deleteJob(jobName, jobGroup);
}
// 记录任务构建信息
log.info("++++++++++构建任务:{},{},{},{},{} ", jobClass.toString(), jobName, jobGroup, cron, data);
// 构建新的任务详情
jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).build();
// 设置任务数据
jobDetail.getJobDataMap().put(TASK_DATA, data);
// 声明触发器
Trigger trigger = null;
// 如果有cron表达式则创建cron触发器
if(!StringUtils.isEmpty(cron)){
log.info("+++++表达式执行:"+ JSON.toJSONString(jobDetail));
// 创建cron调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
// 构建触发器
trigger = TriggerBuilder.newTrigger()
.withIdentity(jobName, jobGroup)
.withSchedule(scheduleBuilder)
.build();
}else{
// 无cron表达式则立即执行一次
log.info("+++++立即执行:"+ JSON.toJSONString(jobDetail));
// 构建立即执行的触发器
trigger = TriggerBuilder.newTrigger()
.withIdentity(jobName, jobGroup)
.startNow()
.build();
}
// 调度任务
scheduler.scheduleJob(jobDetail, trigger);
} catch (Exception e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
/**
*
* cron
*
* @param jobClass
* @param jobName
* @param data
*/
@Override
public void addCronJob(Class jobClass, String jobName, String data) {
// 立即执行任务不需要cron表达式传入null
this.addCronJob(jobClass, jobName, null, data);
}
/**
*
*
*
* @param jobName
* @param jobGroup
*/
@Override
public void pauseJob(String jobName, String jobGroup) {
try {
// 创建触发器键并暂停触发器
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
scheduler.pauseTrigger(triggerKey);
log.info("++++++++++暂停任务:{}", jobName);
} catch (SchedulerException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
/**
*
*
*
* @param jobName
* @param jobGroup
*/
@Override
public void resumeJob(String jobName, String jobGroup) {
try {
// 创建触发器键并恢复触发器
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
scheduler.resumeTrigger(triggerKey);
log.info("++++++++++重启任务:{}", jobName);
} catch (SchedulerException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
/**
*
*
*
* @param jobName
* @param jobGroup
*/
@Override
public void deleteJob(String jobName, String jobGroup) {
try {
// 创建任务键并删除任务
JobKey jobKey = JobKey.jobKey(jobName,jobGroup);
scheduler.deleteJob(jobKey);
log.info("++++++++++删除任务:{}", jobKey);
} catch (SchedulerException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
}

@ -0,0 +1,39 @@
// 定义包路径,用于存放自定义过滤器相关的类
package com.yf.exam.ability.shiro;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean; // Shiro过滤器工厂类用于配置Shiro过滤器
import org.apache.shiro.web.filter.InvalidRequestFilter; // Shiro无效请求过滤器用于处理无效请求
import org.apache.shiro.web.filter.mgt.DefaultFilter; // Shiro默认过滤器提供默认的过滤逻辑
import org.apache.shiro.web.filter.mgt.FilterChainManager; // Shiro过滤器链管理器管理过滤器链的配置
import javax.servlet.Filter; // Servlet过滤器接口定义了过滤器的基本操作
import java.util.Map; // Map集合类用于存储键值对
/**
* Shiro
* URL400
* https://youdomain.com/upload/file/云帆考试系统用户手册.pdf 这样的URL可能会因为中文字符而导致问题。
* @author van
*/
public class CNFilterFactoryBean extends ShiroFilterFactoryBean {
/**
*
*
* @return FilterChainManager
*/
@Override
protected FilterChainManager createFilterChainManager() {
FilterChainManager manager = super.createFilterChainManager(); // 调用父类方法创建过滤器链管理器
// 获取过滤器映射,以便修改特定过滤器的配置
Map<String, Filter> filterMap = manager.getFilters();
// 获取无效请求过滤器实例
Filter invalidRequestFilter = filterMap.get(DefaultFilter.invalidRequest.name());
if (invalidRequestFilter instanceof InvalidRequestFilter) {
// 设置无效请求过滤器不阻止非ASCII字符以允许中文URL
((InvalidRequestFilter) invalidRequestFilter).setBlockNonAscii(false);
}
return manager; // 返回配置好的过滤器链管理器
}
}

@ -0,0 +1,135 @@
// 定义包路径用于存放Shiro领域相关的类
package com.yf.exam.ability.shiro;
import com.yf.exam.ability.shiro.jwt.JwtToken; // JWT令牌类
import com.yf.exam.ability.shiro.jwt.JwtUtils; // JWT工具类
import com.yf.exam.modules.sys.user.dto.response.SysUserLoginDTO; // 用户登录DTO
import com.yf.exam.modules.sys.user.service.SysUserRoleService; // 用户角色服务
import com.yf.exam.modules.sys.user.service.SysUserService; // 用户服务
import lombok.extern.slf4j.Slf4j; // 日志注解
import org.apache.shiro.authc.AuthenticationException; // 认证异常
import org.apache.shiro.authc.AuthenticationInfo; // 认证信息
import org.apache.shiro.authc.AuthenticationToken; // 认证令牌
import org.apache.shiro.authc.SimpleAuthenticationInfo; // 简单认证信息
import org.apache.shiro.authz.AuthorizationInfo; // 授权信息
import org.apache.shiro.authz.SimpleAuthorizationInfo; // 简单授权信息
import org.apache.shiro.realm.AuthorizingRealm; // 授权领域
import org.apache.shiro.subject.PrincipalCollection; // 主体集合
import org.springframework.beans.factory.annotation.Autowired; // Spring自动注入注解
import org.springframework.context.annotation.Lazy; // 延迟注入注解
import org.springframework.stereotype.Component; // Spring组件注解
import java.util.HashSet; // 哈希集合
import java.util.List; // 列表
/**
* Shiro
* Shiro
* @author bool
*/
@Component // 标记为Spring组件
@Slf4j // 启用Slf4j日志
public class ShiroRealm extends AuthorizingRealm {
@Autowired
@Lazy // 延迟注入,避免循环依赖
private SysUserService sysUserService; // 用户服务
@Autowired
@Lazy // 延迟注入,避免循环依赖
private SysUserRoleService sysUserRoleService; // 用户角色服务
/**
* JWT
* JWT
* @param token
* @return JWT
*/
@Override
public boolean supports(AuthenticationToken token) {
// 判断是否支持JWT令牌
return token instanceof JwtToken; // 返回是否为JwtToken
}
/**
*
*
* @param principals
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String userId = null; // 用户ID
if (principals != null) {
SysUserLoginDTO user = (SysUserLoginDTO) principals.getPrimaryPrincipal(); // 获取用户信息
userId = user.getId(); // 获取用户ID
}
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(); // 创建授权信息
// 查找用户角色
List<String> roles = sysUserRoleService.listRoles(userId); // 获取用户角色列表
info.setRoles(new HashSet<>(roles)); // 设置角色
log.info("++++++++++校验详细权限完成"); // 日志记录
return info; // 返回授权信息
}
/**
*
*
* @param auth
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
String token = (String) auth.getCredentials(); // 获取token
if (token == null) {
throw new AuthenticationException("token为空!"); // 抛出异常
}
// 校验token有效性
SysUserLoginDTO user = this.checkToken(token); // 验证token并获取用户信息
return new SimpleAuthenticationInfo(user, token, getName()); // 返回认证信息
}
/**
* Token
* JWT
* @param token JWT
* @return DTO
* @throws AuthenticationException
*/
public SysUserLoginDTO checkToken(String token) throws AuthenticationException {
// 查询用户信息
log.debug("++++++++++校验用户token "+ token); // 日志记录
// 从token中获取用户名
String username = JwtUtils.getUsername(token); // 获取用户名
log.debug("++++++++++用户名: "+ username); // 日志记录
if (username == null) {
throw new AuthenticationException("无效的token"); // 抛出异常
}
// 查找登录用户对象
SysUserLoginDTO user = sysUserService.token(token); // 获取用户信息
// 校验token是否失效
if (!JwtUtils.verify(token, username)) {
throw new AuthenticationException("登陆失效,请重试登陆!"); // 抛出异常
}
return user; // 返回用户信息
}
/**
*
*
* @param principals
*/
@Override
public void clearCache(PrincipalCollection principals) {
super.clearCache(principals); // 清除缓存
}
}

@ -0,0 +1,84 @@
// 定义包路径用于存放Shiro JWT认证过滤器相关的类
package com.yf.exam.ability.shiro.aop;
// 导入所需的外部依赖包
import com.yf.exam.ability.shiro.jwt.JwtToken; // JWT令牌类
import com.yf.exam.aspect.utils.InjectUtils; // 工具类,用于注入错误信息
import com.yf.exam.modules.Constant; // 常量类
import lombok.extern.slf4j.Slf4j; // 日志注解
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter; // Shiro基础认证过滤器
import javax.servlet.ServletRequest; // Servlet请求接口
import javax.servlet.ServletResponse; // Servlet响应接口
import javax.servlet.http.HttpServletRequest; // HTTP请求类
import javax.servlet.http.HttpServletResponse; // HTTP响应类
/**
* JWT
* JWTJWT访
* @author bool
*/
@Slf4j // 启用Slf4j日志
public class JwtFilter extends BasicHttpAuthenticationFilter {
/**
* 访
*
* 访true访
* 访
*
* @param request
* @param response
* @param mappedValue
* @return 访
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
try {
// 尝试执行登录认证
executeLogin(request, response);
// 认证成功返回true
return true;
} catch (Exception e) {
// 认证失败时写入错误信息
InjectUtils.restError((HttpServletResponse) response);
// 返回false表示不允许访问
return false;
}
}
/**
*
* JWT token
* tokenisAccessAllowed
*
* @param request
* @param response
* @return
*/
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
// 将ServletRequest转换为HttpServletRequest
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
// 从请求头中获取token
String token = httpServletRequest.getHeader(Constant.TOKEN);
// 如果token为空则抛出异常
if (token == null || "".equals(token)) {
throw new Exception("token不能为空");
}
// 创建JWT token对象
JwtToken jwtToken = new JwtToken(token);
// 提交给realm进行登录认证
try {
getSubject(request, response).login(jwtToken);
// 如果没有抛出异常则表示登录成功
return true;
} catch (Exception e) {
// 登录失败,记录日志
log.error("JWT认证失败", e);
throw e;
}
}
}

@ -0,0 +1,50 @@
// 定义包路径用于存放JWT令牌相关的类
package com.yf.exam.ability.shiro.jwt;
import lombok.Data; // Lombok注解用于生成getter和setter
import org.apache.shiro.authc.AuthenticationToken; // Shiro认证令牌接口
/**
* JWT
* ShiroAuthenticationTokenJWT
* @author bool
*/
@Data // 自动生成getter和setter方法
public class JwtToken implements AuthenticationToken {
private static final long serialVersionUID = 1L; // 序列化ID
/**
* JWTtoken
* JWT
*/
private String token; // JWT令牌字符串
/**
*
* @param token JWT
*/
public JwtToken(String token) {
this.token = token; // 设置token
}
/**
*
* AuthenticationToken
* @return token
*/
@Override
public Object getPrincipal() {
return token; // 返回token作为身份信息
}
/**
*
* AuthenticationToken
* @return token
*/
@Override
public Object getCredentials() {
return token; // 返回token作为凭证信息
}
}

@ -0,0 +1,93 @@
// 定义包路径用于存放JWT工具类
package com.yf.exam.ability.shiro.jwt;
import com.auth0.jwt.JWT; // JWT工具类
import com.auth0.jwt.JWTVerifier; // JWT验证器
import com.auth0.jwt.algorithms.Algorithm; // JWT算法
import com.auth0.jwt.exceptions.JWTDecodeException; // JWT解码异常
import com.auth0.jwt.interfaces.DecodedJWT; // 解码后的JWT
import com.yf.exam.core.utils.file.Md5Util; // MD5工具类
import java.util.Calendar; // 日历类
import java.util.Date; // 日期类
/**
* JWT
* @author bool
*/
public class JwtUtils {
/**
* 24
*/
private static final long EXPIRE_TIME = 24 * 60 * 60 * 1000; // JWT有效期
/**
*
* @param token JWT
* @param username
* @return
*/
public static boolean verify(String token, String username) {
try {
// 根据密码生成JWT效验器
Algorithm algorithm = Algorithm.HMAC256(encryptSecret(username)); // 创建算法
JWTVerifier verifier = JWT.require(algorithm) // 创建验证器
.withClaim("username", username) // 添加用户名声明
.build(); // 构建验证器
// 效验TOKEN
verifier.verify(token); // 验证token
return true; // 返回验证成功
} catch (Exception exception) {
return false; // 返回验证失败
}
}
/**
* Token
* @param token JWT
* @return
*/
public static String getUsername(String token) {
try {
DecodedJWT jwt = JWT.decode(token); // 解码JWT
return jwt.getClaim("username").asString(); // 获取用户名
} catch (JWTDecodeException e) {
return null; // 返回null表示解码失败
}
}
/**
* JWT Token
* @param username
* @return JWT
*/
public static String sign(String username) {
Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME); // 设置过期时间
Algorithm algorithm = Algorithm.HMAC256(encryptSecret(username)); // 创建算法
// 附带username信息
return JWT.create() // 创建JWT
.withClaim("username", username) // 添加用户名声明
.withExpiresAt(date).sign(algorithm); // 设置过期时间并签名
}
/**
* JWT
* @param userName
* @return
*/
private static String encryptSecret(String userName){
// 一个简单的登录规则,用户名+当前月份为加密串,意思每个月会变,要重新登录
// 可自行修改此规则
Calendar cl = Calendar.getInstance(); // 获取当前日历
cl.setTimeInMillis(System.currentTimeMillis()); // 设置当前时间
StringBuffer sb = new StringBuffer(userName) // 创建字符串缓冲区
.append("&") // 添加分隔符
.append(cl.get(Calendar.MONTH)); // 添加当前月份
// 获取MD5
String secret = Md5Util.md5(sb.toString()); // 生成MD5秘钥
return Md5Util.md5(userName + "&" + secret); // 返回加密后的秘钥
}
}

@ -0,0 +1,36 @@
// 定义包路径,用于存放文件上传配置相关的类
package com.yf.exam.ability.upload.config;
import lombok.Data; // Lombok注解用于简化数据类的编写自动生成getter和setter
import org.springframework.boot.context.properties.ConfigurationProperties; // Spring Boot配置属性注解用于将配置文件中的属性绑定到Java对象
import org.springframework.context.annotation.Configuration; // Spring配置注解标记为配置类
/**
*
* 访
* application.ymlapplication.propertiesSpring Boot
* @author van
*/
@Data // 使用Lombok注解自动生成getter和setter方法
@Configuration // 标记为Spring配置类表示这是一个配置类
@ConfigurationProperties(prefix = "conf.upload") // 指定配置文件中属性的前缀,这里是"conf.upload"
public class UploadConfig {
/**
* 访
* 访URL
*/
private String url; // 文件访问的URL
/**
*
*
*/
private String dir; // 文件存储的物理目录
/**
*
*
*/
private String[] allowExtensions; // 允许上传的文件后缀
}

@ -0,0 +1,62 @@
// 定义包路径,用于存放文件上传下载请求类
package com.yf.exam.ability.upload.controller;
import com.yf.exam.ability.Constant; // 常量类,包含系统配置的常量值
import com.yf.exam.ability.upload.dto.UploadReqDTO; // 文件上传请求DTO封装上传文件所需的数据
import com.yf.exam.ability.upload.dto.UploadRespDTO; // 文件上传响应DTO封装上传文件后的响应数据
import com.yf.exam.ability.upload.service.UploadService; // 文件上传服务,提供文件上传和下载的业务逻辑
import com.yf.exam.core.api.ApiRest; // API响应类封装统一的API响应格式
import com.yf.exam.core.api.controller.BaseController; // 基础控制器,提供基础的控制器功能
import io.swagger.annotations.Api; // Swagger API注解用于描述API信息
import io.swagger.annotations.ApiOperation; // Swagger API操作注解用于描述单个API操作
import lombok.extern.log4j.Log4j2; // 日志注解,提供日志功能
import org.springframework.beans.factory.annotation.Autowired; // Spring自动注入注解用于注入Spring管理的Bean
import org.springframework.web.bind.annotation.GetMapping; // GET请求映射注解用于映射GET请求到方法
import org.springframework.web.bind.annotation.ModelAttribute; // 模型属性注解,用于将请求参数绑定到模型对象
import org.springframework.web.bind.annotation.PostMapping; // POST请求映射注解用于映射POST请求到方法
import org.springframework.web.bind.annotation.RestController; // REST控制器注解标记为REST风格的控制器
import javax.servlet.http.HttpServletRequest; // HTTP请求类表示HTTP请求
import javax.servlet.http.HttpServletResponse; // HTTP响应类表示HTTP响应
/**
*
* RESTful API
* @author bool
*/
@Log4j2 // 启用Log4j2日志
@Api(tags = {"文件上传"}) // Swagger API标签用于分类API
@RestController // 标记为REST控制器表示该类是一个REST风格的控制器
public class UploadController extends BaseController {
@Autowired
private UploadService uploadService; // 文件上传服务,自动注入
/**
*
*
*
* @param reqDTO DTO
* @return
*/
@PostMapping("/common/api/file/upload") // POST请求映射指定请求路径
@ApiOperation(value = "文件上传", notes = "此接口较为特殊参数都通过表单方式提交而非JSON") // Swagger API操作描述
public ApiRest<UploadRespDTO> upload(@ModelAttribute UploadReqDTO reqDTO) {
// 上传并返回URL
UploadRespDTO respDTO = uploadService.upload(reqDTO); // 调用上传服务
return super.success(respDTO); // 返回成功响应
}
/**
*
*
*
* @param request HTTP
* @param response HTTP
*/
@GetMapping(Constant.FILE_PREFIX+"**") // GET请求映射指定请求路径前缀
@ApiOperation(value = "文件下载", notes = "文件下载") // Swagger API操作描述
public void download(HttpServletRequest request, HttpServletResponse response) {
uploadService.download(request, response); // 调用下载服务
}
}

@ -0,0 +1,26 @@
// 定义包路径用于存放文件上传请求DTO
package com.yf.exam.ability.upload.dto;
import com.yf.exam.core.api.dto.BaseDTO; // 导入基础DTO类提供通用的数据传输对象功能
import io.swagger.annotations.ApiModel; // 导入Swagger API模型注解用于描述API模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger API模型属性注解用于描述API模型的属性
import lombok.Data; // 导入Lombok注解用于简化数据类的编写自动生成getter和setter
import org.springframework.web.multipart.MultipartFile; // 导入Spring文件上传类用于处理上传的文件
/**
*
*
* @author van
* @date 2019-12-26 17:54
*/
@Data // 使用Lombok注解自动生成getter和setter方法
@ApiModel(value="文件上传参数", description="文件上传参数") // 使用Swagger注解描述API模型
public class UploadReqDTO extends BaseDTO {
/**
*
*
*/
@ApiModelProperty(value = "上传文件内容", required=true) // 使用Swagger注解描述API模型属性
private MultipartFile file; // 上传的文件内容
}

@ -0,0 +1,28 @@
// 定义包路径用于存放文件上传响应DTO
package com.yf.exam.ability.upload.dto;
import com.yf.exam.core.api.dto.BaseDTO; // 导入基础DTO类提供通用的数据传输对象功能
import io.swagger.annotations.ApiModel; // 导入Swagger API模型注解用于描述API模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger API模型属性注解用于描述API模型的属性
import lombok.AllArgsConstructor; // 导入Lombok注解用于生成全参构造函数
import lombok.Data; // 导入Lombok注解用于生成getter和setter方法
import lombok.NoArgsConstructor; // 导入Lombok注解用于生成无参构造函数
/**
* DTO
* URL
* @author bool
*/
@Data // 使用Lombok注解自动生成getter和setter方法
@AllArgsConstructor // 使用Lombok注解生成全参构造函数
@NoArgsConstructor // 使用Lombok注解生成无参构造函数
@ApiModel(value="文件上传响应", description="文件上传响应") // 使用Swagger注解描述API模型
public class UploadRespDTO extends BaseDTO {
/**
* URL
* 访URL
*/
@ApiModelProperty(value = "上传后的完整的URL地址", required=true) // 使用Swagger注解描述API模型属性
private String url; // 上传后的完整URL地址
}

@ -0,0 +1,62 @@
package com.yf.exam.ability.upload.service;
// 这一行声明了该Java类所属的包名为com.yf.exam.ability.upload.service。
// 包用于组织和管理相关的Java类避免类名冲突方便代码的模块化和复用。
import com.yf.exam.ability.upload.dto.UploadReqDTO; // 导入文件上传请求DTO
// 导入了名为UploadReqDTO的类它位于com.yf.exam.ability.upload.dto包下。
// 这个类通常用于封装文件上传请求相关的数据,比如要上传的文件信息、上传的相关参数等。
import com.yf.exam.ability.upload.dto.UploadRespDTO; // 导入文件上传响应DTO
// 导入了名为UploadRespDTO的类同样位于com.yf.exam.ability.upload.dto包下。
// 它主要用于封装文件上传操作完成后返回的响应数据,例如上传是否成功的标识、上传后的文件存储路径等信息。
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求类
// 引入了Java EE中用于处理HTTP请求的标准类HttpServletRequest。
// 在文件下载等操作中会通过这个类获取客户端发送过来的关于下载请求的各种信息如请求的URL、请求头信息等。
import javax.servlet.http.HttpServletResponse; // 导入HTTP响应类
// 引入了Java EE中用于处理HTTP响应的标准类HttpServletResponse。
// 在文件下载操作中,会使用这个类来设置响应的状态码、响应头信息以及将文件内容返回给客户端。
/**
*
*
* @author bool
* @date 2019-07-12 16:45
*/
// 这是一个Java接口的文档注释用于描述该接口的整体功能和用途。
// 说明这个接口主要是用来定义与文件上传和下载相关的业务操作方法,
// 并且其他类可以通过实现这个接口来提供具体的实现,以达到统一调用的目的。
// 同时标注了接口的作者是bool创建日期是2019年7月12日16:45。
public interface UploadService {
// 这里定义了一个名为UploadService的公共接口。
// 接口中只包含方法的声明,不包含方法的具体实现,具体实现由实现该接口的类来完成。
/**
*
*
*
* @param reqDTO DTO
* @return DTO
*/
// 这是接口中定义的一个方法声明名为upload。
// 它的功能是处理文件上传请求通过接收传入的UploadReqDTO对象其中包含了上传文件所需的各种数据
// 然后在具体实现类中执行实际的上传操作最后返回一个UploadRespDTO对象该对象封装了上传文件后的响应数据。
UploadRespDTO upload(UploadReqDTO reqDTO);
/**
*
*
*
* @param request HTTP
* @param response HTTP
*/
// 这是接口中定义的另一个方法声明名为download。
// 它用于处理文件下载请求会接收一个HttpServletRequest对象其中包含了客户端发送的关于下载请求的所有信息
// 和一个HttpServletResponse对象用于设置响应相关的信息并将文件内容返回给客户端
// 在具体实现类中根据请求参数找到对应的要下载的文件并通过HttpServletResponse将文件内容返回给客户端。
void download(HttpServletRequest request, HttpServletResponse response);
}

@ -0,0 +1,143 @@
// 定义包路径,用于存放文件上传服务实现类
package com.yf.exam.ability.upload.service.impl;
import com.yf.exam.ability.Constant; // 导入常量类,包含系统配置的常量值
import com.yf.exam.ability.upload.config.UploadConfig; // 导入文件上传配置类,包含文件上传的相关配置
import com.yf.exam.ability.upload.dto.UploadReqDTO; // 导入文件上传请求DTO封装上传文件所需的数据
import com.yf.exam.ability.upload.dto.UploadRespDTO; // 导入文件上传响应DTO封装上传文件后的响应数据
import com.yf.exam.ability.upload.service.UploadService; // 导入文件上传服务接口,定义文件上传的相关业务操作
import com.yf.exam.ability.upload.utils.FileUtils; // 导入文件工具类,提供文件操作的辅助功能
import com.yf.exam.core.exception.ServiceException; // 导入服务异常类,处理业务逻辑中的异常情况
import lombok.extern.log4j.Log4j2; // 导入日志注解,提供日志功能
import org.apache.commons.io.FilenameUtils; // 导入文件名工具类,提供文件名和扩展名操作的辅助功能
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring自动注入注解用于注入Spring管理的Bean
import org.springframework.stereotype.Service; // 导入Spring服务注解标记为服务组件
import org.springframework.util.FileCopyUtils; // 导入文件复制工具类,提供文件复制的功能
import org.springframework.web.multipart.MultipartFile; // 导入Spring文件上传类处理上传的文件
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求类表示HTTP请求
import javax.servlet.http.HttpServletResponse; // 导入HTTP响应类表示HTTP响应
import java.io.FileOutputStream; // 导入文件输出流,用于将文件内容写入文件
import java.io.IOException; // 导入IO异常类处理IO操作中的异常情况
import java.io.UnsupportedEncodingException; // 导入不支持的编码异常类,处理编码问题
import java.net.URLDecoder; // 导入URL解码类用于解码URL
import java.util.regex.Matcher; // 导入正则表达式匹配器,用于匹配正则表达式
import java.util.regex.Pattern; // 导入正则表达式类,用于编译正则表达式
/**
*
*
* @author bool
* @date 2019-07-30 21:02
*/
@Log4j2 // 使用Log4j2日志注解启用日志功能
@Service // 使用Spring服务注解标记为服务组件
public class UploadServiceImpl implements UploadService {
@Autowired
private UploadConfig conf; // 自动注入文件上传配置
/**
*
*
*
* @param reqDTO DTO
* @return DTO
*/
@Override
public UploadRespDTO upload(UploadReqDTO reqDTO) {
// 文件内容
MultipartFile file = reqDTO.getFile(); // 获取上传的文件
// 验证文件后缀
boolean allow = FilenameUtils.isExtension(file.getOriginalFilename(), conf.getAllowExtensions()); // 验证文件后缀
if(!allow){
throw new ServiceException("文件类型不允许上传!"); // 抛出异常
}
// 上传文件夹
String fileDir = conf.getDir(); // 获取文件存储目录
// 真实物理地址
String fullPath;
try {
// 新文件
String filePath = FileUtils.processPath(file); // 处理文件路径
// 文件保存地址
fullPath = fileDir + filePath; // 拼接完整路径
// 创建文件夹
FileUtils.checkDir(fullPath); // 检查并创建文件夹
// 上传文件
FileCopyUtils.copy(file.getInputStream(), new FileOutputStream(fullPath)); // 复制文件内容到指定路径
return this.generateResult(filePath); // 返回上传结果
} catch (IOException e) {
e.printStackTrace(); // 打印异常堆栈
throw new ServiceException("文件上传失败:"+e.getMessage()); // 抛出异常
}
}
/**
*
*
*
* @param request HTTP
* @param response HTTP
*/
@Override
public void download(HttpServletRequest request, HttpServletResponse response) {
// 获取真实的文件路径
String filePath = this.getRealPath(request.getRequestURI()); // 获取文件的真实路径
// 处理中文问题
try {
filePath = URLDecoder.decode(filePath, "utf-8"); // 解码文件路径
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e); // 抛出运行时异常
}
System.out.println("++++完整路径为:"+filePath); // 打印完整路径
try {
FileUtils.writeRange(request, response, filePath); // 调用文件工具类进行文件写入
} catch (IOException e) {
response.setStatus(404); // 设置响应状态为404
log.error("预览文件失败" + e.getMessage()); // 打印错误日志
}
}
/**
*
* DTOURL
*
* @param fileName
* @return DTO
*/
private UploadRespDTO generateResult(String fileName) {
//获取加速域名
String domain = conf.getUrl(); // 获取文件访问的URL
// 返回结果
return new UploadRespDTO(domain + fileName); // 返回上传响应DTO
}
/**
*
* URI
*
* @param uri URI
* @return
*/
public String getRealPath(String uri){
String regx = Constant.FILE_PREFIX+"(.*)"; // 正则表达式匹配文件路径
// 查找全部变量
Pattern pattern = Pattern.compile(regx); // 编译正则表达式
Matcher m = pattern.matcher(uri); // 创建匹配器
if (m.find()) {
String str = m.group(1); // 获取匹配的文件路径
return conf.getDir() + str; // 返回真实文件路径
}
return null; // 返回null表示未找到
}
}

@ -0,0 +1,169 @@
// 定义包路径,用于存放文件工具类
package com.yf.exam.ability.upload.utils;
import com.baomidou.mybatisplus.core.toolkit.IdWorker; // 导入ID生成工具用于生成唯一的文件名
import com.yf.exam.core.utils.DateUtils; // 导入日期工具类,用于处理日期相关的操作
import org.apache.commons.io.FilenameUtils; // 导入文件名工具类,用于处理文件名和扩展名
import org.springframework.web.multipart.MultipartFile; // 导入Spring文件上传类用于处理上传的文件
import javax.servlet.ServletOutputStream; // 导入Servlet输出流用于写入HTTP响应
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求类表示客户端的请求
import javax.servlet.http.HttpServletResponse; // 导入HTTP响应类表示服务器的响应
import java.io.File; // 导入文件类,用于操作文件和目录
import java.io.IOException; // 导入IO异常类处理IO操作中的异常
import java.io.RandomAccessFile; // 导入随机访问文件类,用于高效地读写文件
import java.util.Date; // 导入日期类,用于处理日期和时间
/**
*
*
* @author bool
*/
public class FileUtils {
/**
*
*
*/
private static final String SUFFIX_SPLIT = "."; // 文件后缀分隔符
/**
* 线线
* HTTP线线
*
* @param request HTTP
* @param response HTTP
* @param filePath
* @throws IOException IO
*/
public static void writeRange(HttpServletRequest request, HttpServletResponse response, String filePath) throws IOException {
// 读取文件
File file = new File(filePath); // 创建文件对象
// 只读模式
RandomAccessFile randomFile = new RandomAccessFile(file, "r"); // 创建随机访问文件对象
long contentLength = randomFile.length(); // 获取文件长度
String range = request.getHeader("Range"); // 获取请求头中的Range
int start = 0, end = 0; // 初始化起始和结束位置
if (range != null && range.startsWith("bytes=")) {
String[] values = range.split("=")[1].split("-"); // 解析Range
start = Integer.parseInt(values[0]); // 获取起始位置
if (values.length > 1) {
end = Integer.parseInt(values[1]); // 获取结束位置
}
}
int requestSize; // 请求大小
if (end != 0 && end > start) {
requestSize = end - start + 1; // 计算请求大小
} else {
requestSize = Integer.MAX_VALUE; // 设置为最大值
}
byte[] buffer = new byte[128]; // 创建缓冲区
response.setContentType(MediaUtils.getContentType(filePath)); // 设置响应内容类型
response.setHeader("Accept-Ranges", "bytes"); // 设置支持的范围
response.setHeader("ETag", file.getName()); // 设置文件名
response.setHeader("Last-Modified", new Date().toString()); // 设置最后修改时间
// 第一次请求只返回content length来让客户端请求多次实际数据
if (range == null) {
response.setHeader("Content-length", contentLength + ""); // 设置内容长度
} else {
// 以后的多次以断点续传的方式来返回视频数据
response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT); // 设置部分内容状态
long requestStart = 0, requestEnd = 0; // 初始化请求起始和结束位置
String[] ranges = range.split("="); // 解析Range
if (ranges.length > 1) {
String[] rangeData = ranges[1].split("-"); // 获取范围数据
requestStart = Integer.parseInt(rangeData[0]); // 获取请求起始位置
if (rangeData.length > 1) {
requestEnd = Integer.parseInt(rangeData[1]); // 获取请求结束位置
}
}
long length; // 请求长度
if (requestEnd > 0) {
length = requestEnd - requestStart + 1; // 计算请求长度
response.setHeader("Content-length", "" + length); // 设置内容长度
response.setHeader("Content-Range", "bytes " + requestStart + "-" + requestEnd + "/" + contentLength); // 设置内容范围
} else {
length = contentLength - requestStart; // 计算请求长度
response.setHeader("Content-length", "" + length); // 设置内容长度
response.setHeader("Content-Range", "bytes " + requestStart + "-" + (contentLength - 1) + "/" + contentLength); // 设置内容范围
}
}
ServletOutputStream out = response.getOutputStream(); // 获取输出流
int needSize = requestSize; // 需要的大小
randomFile.seek(start); // 移动到起始位置
while (needSize > 0) {
int len = randomFile.read(buffer); // 读取文件内容
if (needSize < buffer.length) {
out.write(buffer, 0, needSize); // 写入需要的大小
} else {
out.write(buffer, 0, len); // 写入缓冲区内容
if (len < buffer.length) {
break; // 如果读取的长度小于缓冲区长度,退出循环
}
}
needSize -= buffer.length; // 减少需要的大小
}
randomFile.close(); // 关闭随机访问文件
out.close(); // 关闭输出流
}
/**
*
*
*
* @param fileName
* @return
*/
public static String renameFile(String fileName) {
// 没有后缀名不处理
if (!fileName.contains(SUFFIX_SPLIT)) {
return fileName; // 返回原文件名
}
// 文件后缀
String extension = FilenameUtils.getExtension(fileName); // 获取文件后缀
// 以系统时间命名
return IdWorker.getIdStr() + "." + extension; // 返回新文件名
}
/**
* 2021/01/01/xxx.jpg
*
*
* @param file
* @return
*/
public static String processPath(MultipartFile file) {
// 创建OSSClient实例。
String fileName = file.getOriginalFilename(); // 获取原始文件名
// 需要重命名
fileName = renameFile(fileName); // 重命名文件
// 获得上传的文件夹
String dir = DateUtils.formatDate(new Date(), "yyyy/MM/dd/"); // 获取当前日期格式化后的目录
return new StringBuffer(dir).append(fileName).toString(); // 返回处理后的文件路径
}
/**
*
*
*
* @param fileName
*/
public static void checkDir(String fileName) {
int index = fileName.lastIndexOf("/"); // 获取最后一个斜杠的位置
if (index == -1) {
return; // 如果没有斜杠,返回
}
File file = new File(fileName.substring(0, index)); // 创建文件对象
if (!file.exists()) {
file.mkdirs(); // 如果文件夹不存在,创建文件夹
}
}
}

@ -0,0 +1,75 @@
package com.yf.exam.ability.upload.utils;
// 这一行声明了该Java类所属的包名为com.yf.exam.ability.upload.utils。
// 包用于对相关的Java类进行组织和管理方便代码的分类、复用以及避免类名冲突。
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的字符串工具类用于字符串操作
// 引入了Apache Commons Lang库中的StringUtils类。
// 这个类提供了许多方便的字符串操作方法,比如判断字符串是否为空、是否空白(包含空格等空白字符)、字符串的拼接、截取等操作,在这里主要用于对文件路径字符串进行相关判断。
import java.util.HashMap; // 导入Java的HashMap类用于创建映射
// 导入了Java标准库中的HashMap类。
// HashMap是实现了Map接口的一个具体类它用于存储键值对形式的数据通过键可以快速获取对应的值在这里用于创建文件后缀名到MIME类型的映射关系。
import java.util.Map; // 导入Java的Map接口用于键值对映射
// 引入了Java标准库中的Map接口。
// Map接口定义了键值对数据结构的通用操作规范如添加键值对、根据键获取值、删除键值对等操作。
// 虽然这里同时导入了HashMap类但导入Map接口使得代码在使用映射数据结构时更具通用性方便后续可能的替换为其他实现Map接口的类。
/**
* MIME
* MIME便
* @author bool
* @date 2019-11-14 16:21
*/
// 这是一个Java类的文档注释用于描述该类的整体功能和用途。
// 说明这个类主要是作为媒体工具类其核心功能是判断和获取媒体文件的MIME类型。
// 通过维护一个静态的映射关系文件后缀名到MIME类型的映射在文件上传和下载的业务场景中能够依据文件的后缀名准确地确定其对应的MIME类型从而正确处理文件的传输和展示等操作。
// 同时标注了类的作者是bool创建日期是2019年11月14日16:21。
public class MediaUtils {
/**
*
* MIME
*/
// 这是对下面定义的MEDIA_MAP成员变量的文档注释说明它是一个静态的映射用于存储文件后缀名和对应的MIME类型之间的映射关系。
public static final Map<String, String> MEDIA_MAP = new HashMap<String, String>() {{
// 初始化映射
// PDF文件的MIME类型
put(".pdf", "application/pdf");
// 视频文件的MIME类型
put(".mp4", "video/mp4");
}};
// 这里定义了一个名为MEDIA_MAP的公共静态最终变量它是一个HashMap类型的映射。
// 通过匿名内部类的初始化方式在创建HashMap实例的同时向其中添加了一些常见的文件后缀名到MIME类型的映射关系比如将".pdf"后缀名映射到"application/pdf"这个MIME类型将".mp4"后缀名映射到"video/mp4"这个MIME类型。
// 由于被声明为静态最终变量它在类加载时就会被初始化并且其值不能再被修改方便在整个类的其他地方直接使用这个映射关系来获取文件的MIME类型。
/**
* MIME
* MEDIA_MAPMIME
*
* @param filePath
* @return MIME
*/
// 这是对下面定义的getContentType方法的文档注释说明该方法的功能是根据传入的文件路径提取出文件的后缀名然后从MEDIA_MAP这个静态映射中获取对应的MIME类型并返回。
public static String getContentType(String filePath) {
if (!StringUtils.isBlank(filePath) && filePath.indexOf(".")!= -1) {
// 提取文件后缀名,并转换为小写
String suffix = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
// 从映射中获取MIME类型
if (MEDIA_MAP.containsKey(suffix)) {
return MEDIA_MAP.get(suffix);
}
}
// 如果没有找到对应的MIME类型返回默认值
return "application/octet-stream";
}
// 这是定义的一个公共静态方法getContentType它接受一个字符串类型的参数filePath表示文件的路径。
// 首先通过StringUtils.isBlank方法判断文件路径是否不为空且包含小数点即有文件后缀名
// 如果满足条件就使用substring方法从文件路径中提取出文件的后缀名并通过toLowerCase方法将其转换为小写形式。
// 然后检查提取出的后缀名是否存在于MEDIA_MAP这个静态映射中如果存在就返回对应的MIME类型如果不存在就返回默认的MIME类型"application/octet-stream",这个默认值通常用于表示未知类型的二进制数据文件。
}

@ -0,0 +1,350 @@
package com.yf.exam.aspect;
// 导入FastJSON库用于将Java对象转换为JSON字符串以及从JSON字符串解析为Java对象等操作
// 在本类的多个方法中用于对象与JSON字符串之间的转换以便于处理数据字典相关的值。
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
// 导入MyBatis Plus的接口用于处理分页相关的数据结构在本类中用于判断和处理分页数据中的数据字典值。
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入Jackson库的注解用于指定日期格式的序列化和反序列化方式
// 在本类的parseObject方法中用于根据注解设置日期字段的格式化输出。
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入自定义的注解,可能用于标记与数据字典相关的字段,以便在本类中识别并处理这些字段的数据字典值。
import com.yf.exam.core.annon.Dict;
// 导入自定义的API响应类用于封装API调用的返回结果包括数据、状态码等信息
// 在本类的多个方法中用于获取和设置返回结果中的数据部分,以便处理其中的数据字典值。
import com.yf.exam.core.api.ApiRest;
// 导入自定义的反射工具类,可能用于获取对象的所有字段等反射相关操作,
// 在本类的parseObject方法中用于获取对象的所有字段以便遍历处理数据字典值。
import com.yf.exam.core.utils.Reflections;
// 导入系统数据字典服务类,用于查询数据字典表以获取数据字典值的翻译文本,
// 在本类的translateDictValue方法中用于根据字典代码、文本、表名和键值查询对应的字典文本。
import com.yf.exam.modules.sys.system.service.SysDictService;
// 导入Lombok的Log4j2注解用于简化日志记录的配置通过该注解可以方便地在类中使用Log4j2进行日志输出。
import lombok.extern.log4j.Log4j2;
// 导入AspectJ的相关类用于定义切面、切点和环绕通知等AOP相关的操作
// 在本类中用于实现对特定方法的拦截和处理,以实现数据字典值的翻译等功能。
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
// 导入Spring框架的注解用于自动注入依赖对象和标记类为Spring组件
// 在本类中通过@Autowired注入SysDictService对象并通过@Component标记本类为Spring组件使其可被Spring容器管理。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
// 导入Spring框架的工具类用于判断字符串是否为空等操作
// 在本类的多个方法中用于判断字符串是否为空,以便进行相应的处理逻辑。
import org.springframework.util.StringUtils;
// 导入Java标准库中的反射相关类用于通过反射操作对象的字段、获取类型信息等
// 在本类的多个方法中广泛用于获取对象的字段、判断字段类型、获取字段注解等操作。
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
// 导入Java标准库中的日期格式化类和日期类用于处理日期格式的转换和操作
// 在本类的parseObject方法中用于根据注解或默认格式对日期字段进行格式化输出。
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* AOP
*
*
* @author bool
*/
@Aspect // 标记该类为一个AspectJ切面类用于定义切面相关的逻辑。
@Component // 标记该类为Spring组件使其能够被Spring容器管理和实例化以便在应用中使用。
@Log4j2 // 使用Log4j2注解启用日志记录功能方便在类中记录相关操作的日志信息。
public class DictAspect {
@Autowired
private SysDictService sysDictService; // 通过自动注入获取系统数据字典服务对象,用于查询数据字典值。
/**
* Controller
* com.yf.examController
*
* @param pjp
* @return
* @throws Throwable
*/
@Around("execution(public * com.yf.exam..*.*Controller.*(..))")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
return this.translate(pjp); // 调用translate方法对被拦截方法的执行结果进行处理主要是处理数据字典值。
}
/**
*
* BaseDictService
*
* @param pjp
* @return
* @throws Throwable
*/
public Object translate(ProceedingJoinPoint pjp) throws Throwable {
// 调用被拦截方法获取原始结果然后调用parseAllDictText方法对结果进行数据字典值的处理。
return this.parseAllDictText(pjp.proceed());
}
/**
*
* ApiRestparseFullDictText
*
* @param result
*/
private Object parseAllDictText(Object result) {
// 判断结果对象是否是ApiRest类型如果是则进行数据字典值的处理。
if (result instanceof ApiRest) {
parseFullDictText(result);
}
return result;
}
/**
* ApiRest
*
* @param result ApiRest
*/
private void parseFullDictText(Object result) {
try {
Object rest = ((ApiRest) result).getData(); // 获取ApiRest对象中的数据部分这部分数据可能包含数据字典相关字段。
// 如果数据部分为空或者是基本数据类型,则不需要进行数据字典值的处理,直接返回。
if (rest == null || this.isBaseType(rest.getClass())) {
return;
}
// 如果数据部分是分页数据类型IPage则对分页数据中的每条记录进行数据字典值处理。
if (rest instanceof IPage) {
List<Object> items = new ArrayList<>(16);
for (Object record : ((IPage) rest).getRecords()) {
Object item = this.parseObject(record); // 调用parseObject方法对每条记录进行数据字典值处理。
items.add(item);
}
((IPage) rest).setRecords(items); // 将处理后的记录列表重新设置回分页对象中。
return;
}
// 如果数据部分是列表数据类型List则对列表中的每条记录进行数据字典值处理。
if (rest instanceof List) {
List<Object> items = new ArrayList<>();
for (Object record : ((List) rest)) {
Object item = this.parseObject(record); // 调用parseObject方法对每条记录进行数据字典值处理。
items.add(item);
}
// 将处理后的记录列表重新设置回ApiRest对象的数据部分。
((ApiRest) result).setData(items);
return;
}
// 如果数据部分是单对象数据,则对该单对象进行数据字典值处理。
Object item = this.parseObject(((ApiRest) result).getData());
((ApiRest) result).setData(item);
} catch (Exception e) {
e.printStackTrace(); // 如果在处理过程中出现异常,则打印异常堆栈信息。
}
}
/**
*
*
* @param record
* @return
*/
public Object parseObject(Object record) {
if (record == null) {
return null;
}
// 如果记录对象是基本数据类型,则不需要进行数据字典值处理,直接返回原对象。
if (this.isBaseType(record.getClass())) {
return record;
}
// 将记录对象转换为JSON字符串再解析为JSONObject对象以便于通过字段名获取和设置值。
String json = JSON.toJSONString(record);
JSONObject item = JSONObject.parseObject(json);
for (Field field : Reflections.getAllFields(record)) { // 遍历记录对象的所有字段。
// 如果字段类型是List类型则对列表字段进行特殊处理。
if (List.class.isAssignableFrom(field.getType())) {
try {
List list = this.processList(field, item.getObject(field.getName(), List.class)); // 调用processList方法处理列表字段。
item.put(field.getName(), list);
continue;
} catch (Exception e) {
e.printStackTrace();
}
continue;
}
// 如果字段带有数据字典注解Dict则对该字段进行数据字典值的翻译处理。
if (field.getAnnotation(Dict.class)!= null) {
String code = field.getAnnotation(Dict.class).dicCode();
String text = field.getAnnotation(Dict.class).dicText();
String table = field.getAnnotation(Dict.class).dictTable();
String key = String.valueOf(item.get(field.getName()));
// 调用translateDictValue方法翻译字典值对应的文本根据字典代码、文本、表名和键值查询对应的字典文本。
String textValue = this.translateDictValue(code, text, table, key);
if (StringUtils.isEmpty(textValue)) {
textValue = "";
}
item.put(field.getName() + "_dictText", textValue);
continue;
}
// 如果字段类型是日期类型java.util.Date且字段值不为空则对日期字段进行格式转换处理。
if ("java.util.Date".equals(field.getType().getName()) && item.get(field.getName())!= null) {
// 获取字段上的JsonFormat注解。
JsonFormat ann = field.getAnnotation(JsonFormat.class);
// 定义日期格式化对象。
SimpleDateFormat fmt;
// 如果注解不为空且指定了日期格式模式,则使用注解指定的格式创建日期格式化对象。
if (ann!= null &&!StringUtils.isEmpty(ann.pattern())) {
fmt = new SimpleDateFormat(ann.pattern());
} else {
// 如果注解为空或未指定格式,则使用默认的日期格式创建日期格式化对象。
fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
item.put(field.getName(), fmt.format(new Date((Long) item.get(field.getName()))));
continue;
}
}
return item;
}
/**
* List
*
* @param field List
* @param list
* @return
*/
private List<Object> processList(Field field, List list) {
// 如果列表为空则返回一个空的ArrayList对象。
if (list == null || list.size() == 0) {
return new ArrayList<>();
}
// 获取List属性的真实类型通过反射获取字段的泛型类型再尝试获取其实际的类型参数。
Type genericType = field.getGenericType();
Class<?> actualType = null;
if (genericType instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) genericType;
try {
actualType = (Class) pt.getActualTypeArguments()[0];
} catch (Exception e) {
return list;
}
}
// 如果列表元素的类型是基本数据类型,则不需要进行数据字典值处理,直接返回原列表。
if (isBaseType(actualType)) {
return list;
}
// 创建一个新的ArrayList对象用于存储处理后的列表元素。
List<Object> result = new ArrayList<>(16);
for (int i = 0; i < list.size(); i++) {
// 获取列表中的每个元素。
Object data = list.get(i);
try {
// 将列表元素转换为JSON字符串再解析为其真实类型的对象以便进行数据字典值处理。
data = JSON.parseObject(JSON.toJSONString(data), actualType);
} catch (Exception e) {
// 如果转换过程中出现错误,则不进行处理,直接使用原元素。
// 这里可以根据实际需求进一步处理错误情况,比如记录日志等。
// 目前只是简单地忽略错误,继续处理下一个元素。
;
}
// 对处理后的元素进行数据字典值处理调用parseObject方法。
Object pds = this.parseObject(data);
result.add(pds);
}
return result;
}
/**
*
*
* @param code
* @param text
* @param table
* @param key
* @return
*/
private String translateDictValue(String code, String text, String table, String) {
if (StringUtils.isEmpty(key)) {
return null;
}
try {
// 定义变量用于存储翻译后的字典文本值。
String dictText = null;
if (!StringUtils.isEmpty(table)) {
// 如果字典表名不为空则调用sysDictService的findDict方法查询数据字典表获取对应的字典文本值。
dictText = sysDictService.findDict(table, text, code, key.trim());
}
if (!StringUtils.isEmpty(dictText)) {
return dictText;
}
} catch (Exception e) {
e.printStackTrace();
}
return "";
}
/**
*
*
* @param clazz
* @return truefalse
*/
private boolean isBaseType(Class clazz) {
// 判断是否是常见的基本数据类型,如整数、字节、长整数等。
if (clazz.equals(java.lang.Integer.class) ||
clazz.equals(java.lang.Byte.class) ||
clazz.equals(java.lang.Long.class) ||
clazz.equals(java.lang.Double.class) ||
clazz.equals(java.lang.Float.class) ||
clazz.equals(java.lang.Character.class) ||
clazz.equals(java.lang.Short.class) ||
clazz.equals(java.lang.Boolean.class)) {
return true;
}
// 判断是否是字符串类型。
if (clazz.equals(java.lang.String.class)) {
return true;
}
// 判断是否是数字类型这里的数字类型可能是指抽象的数字类型比如Number的子类等
if (clazz.equals(java.lang.Number.class)) {
return true;
}
return false;
}
}

@ -0,0 +1,255 @@
package com.yf.exam.aspect.mybatis;
// 导入MyBatis Plus的分页拦截器类用于实现分页功能
// 本类继承自该类以在拦截查询操作时能正确处理分页相关逻辑。
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
// 导入系统用户登录信息的数据传输对象DTO用于获取当前登录用户的相关信息
// 比如在处理查询拦截时可能需要根据登录用户的信息来过滤或修改查询语句。
import com.yf.exam.modules.sys.user.dto.response.SysUserLoginDTO;
// 导入Lombok的Log4j2注解用于简化日志记录的配置通过该注解可以方便地在类中使用Log4j2进行日志输出。
import lombok.extern.log4j.Log4j2;
// 导入JSqlParser库中的解析器管理器类用于解析SQL语句
// 在本类中用于解析查询语句以便进行后续的处理如替换用户ID等操作。
import net.sf.jsqlparser.parser.CCJSqlParserManager;
// 导入JSqlParser库中表示简单查询语句的类它是查询语句的一种具体表示形式
// 在解析查询语句后可以获取到该对象来进一步处理查询语句的内容。
import net.sf.jsqlparser.statement.select.PlainSelect;
// 导入JSqlParser库中表示查询语句的通用类用于接收解析后的查询语句对象
// 以便进行后续的类型转换和处理操作。
import net.sf.jsqlparser.statement.select.Select;
// 导入Apache Commons Lang3库中的StringUtils类用于处理字符串相关的操作
// 如判断字符串是否为空、非空等情况在本类中用于判断用户ID等字符串是否有效。
import org.apache.commons.lang3.StringUtils;
// 导入MyBatis中的语句处理器接口类它是MyBatis在执行SQL语句时涉及的一个重要组件
// 在本类中作为拦截的目标对象类型,以便在其执行查询准备阶段进行拦截操作。
import org.apache.ibatis.executor.statement.StatementHandler;
// 导入MyBatis中的映射语句类它包含了关于SQL语句的映射信息
// 如SQL语句的ID、参数映射、结果映射等在本类中用于获取SQL语句的相关属性如语句类型等。
import org.apache.ibatis.mapping.MappedStatement;
// 导入MyBatis中的SQL命令类型枚举类用于表示不同类型的SQL命令
// 如SELECT、INSERT、UPDATE、DELETE等在本类中用于判断当前拦截的SQL语句是否为查询语句。
import org.apache.ibatis.mapping.SqlCommandType;
// 导入MyBatis的拦截器接口类定义了拦截器的基本行为和方法
// 本类实现了该接口以作为一个MyBatis的拦截器来拦截查询语句的执行过程。
import org.apache.ibatis.plugin.Interceptor;
// 导入MyBatis的拦截器注解类用于标注一个类是MyBatis的拦截器并指定拦截的目标和方法
// 本类通过该注解指定了要拦截StatementHandler的prepare方法。
import org.apache.ibatis.plugin.Intercepts;
// 导入MyBatis的拦截器调用类用于在拦截器方法中传递被拦截方法的调用信息
// 包括被拦截的目标对象、方法参数等在本类的intercept方法中会接收到该对象来处理拦截逻辑。
import org.apache.ibatis.plugin.Invocation;
// 导入MyBatis的插件包装类用于将拦截器包装成MyBatis可识别的插件形式
// 在本类的plugin方法中会使用该类来包装目标对象以便实现拦截功能。
import org.apache.ibatis.plugin.Plugin;
// 导入MyBatis的拦截器签名类用于定义拦截器拦截的具体目标、方法和参数类型
// 在本类的@Intercepts注解中会使用该类来指定具体的拦截信息。
import org.apache.ibatis.plugin.Signature;
// 导入MyBatis的默认反射工厂类用于创建反射对象来访问和修改MyBatis相关对象的属性
// 在本类中用于创建MetaObject对象来操作StatementHandler等对象的属性。
import org.apache.ibatis.reflection.DefaultReflectorFactory;
// 导入MyBatis的元对象类它提供了一种通过反射来访问和操作MyBatis相关对象属性的机制
// 在本类中用于获取和设置StatementHandler等对象的内部属性如SQL语句等。
import org.apache.ibatis.reflection.MetaObject;
// 导入MyBatis的系统元对象类它是MetaObject的一种特殊实现提供了一些默认的对象工厂和包装器工厂
// 在本类中用于创建MetaObject对象来操作StatementHandler等对象的属性。
import org.apache.ibatis.reflection.SystemMetaObject;
// 导入Apache Shiro的安全工具类用于获取当前安全上下文的相关信息
// 在本类中用于获取当前登录用户的信息,以便根据用户信息来处理查询语句。
import org.apache.shiro.SecurityUtils;
// 导入Java标准库中的字符串读取器类用于将字符串转换为可读取的流形式
// 在本类中用于将SQL语句字符串提供给CCJSqlParserManager进行解析。
import java.io.StringReader;
// 导入Java标准库中的数据库连接接口类它是Java数据库操作中与数据库建立连接的关键接口
// 在本类中作为StatementHandler的prepare方法的参数类型之一出现虽然在本类代码中未直接对其进行复杂操作
// 但它是MyBatis执行SQL语句过程中涉及到的重要组件之一。
import java.sql.Connection;
// 导入Java标准库中的属性类用于存储和管理键值对形式的属性信息
// 在本类中作为Interceptor接口的setProperties方法的参数类型虽然在本类代码中该方法暂未实现具体功能
// 但它是符合Interceptor接口规范的一部分可用于接收外部配置的属性信息来动态调整拦截器的行为。
import java.util.Properties;
/**
* ID
* PaginationInterceptor
*
* @author bool
*/
@Log4j2
// 使用@Intercepts注解指定该类作为MyBatis的拦截器要拦截的目标和方法。
// 这里拦截的是StatementHandler类的prepare方法并且该方法的参数类型为Connection和Integer。
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
public class QueryInterceptor extends PaginationInterceptor implements Interceptor {
/**
* IDSQLID
*/
private static final String USER_FILTER = "{{userId}}";
/**
* StatementHandlerprepare
*
* @param invocation
* @return
* @throws Throwable
*/
@Override
public Object intercept(Invocation invocation) throws Throwable {
// 从invocation对象中获取被拦截的目标对象即StatementHandler对象。
StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
// 使用MetaObject.forObject方法创建一个元对象用于通过反射访问和修改StatementHandler对象的属性。
// 这里传入了默认的对象工厂、包装器工厂和反射工厂以便能够正确地操作StatementHandler对象的内部属性。
MetaObject metaObject = MetaObject.forObject(statementHandler, SystemMetaObject.DEFAULT_OBJECT_FACTORY, SystemMetaObject.DEFAULT_OBJECT_WRAPPER_FACTORY, new DefaultReflectorFactory());
// 从元对象中获取MappedStatement对象该对象包含了关于SQL语句的映射信息如SQL语句的ID、参数映射、结果映射等。
MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
// 获取当前SQL语句的类型通过MappedStatement对象的getSqlCommandType方法获取。
// 该类型是一个枚举值如SELECT、INSERT、UPDATE、DELETE等用于判断当前拦截的SQL语句是何种类型的操作。
SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
// 只对查询类型的SQL语句进行处理如果当前SQL语句类型是SELECT则进入下面的处理逻辑。
if (SqlCommandType.SELECT == sqlCommandType) {
// 获取原始的SQL语句通过StatementHandler的getBoundSql方法获取绑定的SQL语句对象再获取其SQL字符串。
String sql = statementHandler.getBoundSql().getSql();
// 如果原始SQL语句中不包含用户ID占位符USER_FILTER则直接调用父类PaginationInterceptor的intercept方法
// 即按照原有的分页逻辑进行处理不进行用户ID相关的替换等操作。
if (!sql.contains(USER_FILTER)) {
return super.intercept(invocation);
}
// 如果原始SQL语句中包含用户ID占位符则需要对SQL语句进行处理。
// 首先调用parseSql方法对SQL语句进行解析和处理包括替换用户ID等操作。
String outSql = this.parseSql(sql);
// 将处理后的SQL语句设置回StatementHandler对象的内部属性中通过元对象的setValue方法设置boundSql.sql属性的值。
metaObject.setValue("delegate.boundSql.sql", outSql);
// 再次调用父类PaginationInterceptor的intercept方法此时是在处理完用户ID等信息后
// 按照正确的分页逻辑进行处理,以确保分页功能在拦截数据并处理相关信息后正确执行。
return super.intercept(invocation);
}
// 如果当前SQL语句不是查询类型SELECT则直接执行被拦截方法的原有逻辑不进行额外的处理。
return invocation.proceed();
}
/**
* MyBatis
*
* @param target StatementHandler
* @return 便MyBatis
*/
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
/**
*
* Interceptor
*
* @param properties Properties
*/
@Override
public void setProperties(Properties properties) {
}
/**
* Apache ShiroSecurityUtils
* SysUserLoginDTOnull
*
* @return SysUserLoginDTOnull
*/
private SysUserLoginDTO getLoginUser() {
try {
return SecurityUtils.getSubject().getPrincipal()!= null? (SysUserLoginDTO) SecurityUtils.getSubject().getPrincipal() : null;
} catch (Exception e) {
return null;
}
}
/**
* IDIDSQLIDUSER_FILTERID
*
* @param sql SQL
* @return IDSQLIDnull
*/
private String processUserId(String sql) {
// 获取当前登录用户的信息通过调用getLoginUser方法获取。
SysUserLoginDTO user = this.getLoginUser();
String userId = user.getId();
// 如果获取到的用户ID不为空则将原始SQL语句中的用户ID占位符替换为实际的用户ID并返回替换后的SQL语句。
if (StringUtils.isNotBlank(userId)) {
return sql.replace(USER_FILTER, userId);
}
// 如果用户ID为空则返回null。
return null;
}
/**
* SQLID
*
* @param src SQL
* @return SQLSQL
*/
private String parseSql(String src) {
// 创建一个CCJSqlParserManager对象用于解析SQL语句。
CCJSqlParserManager parserManager = new CCJSqlParserManager();
try {
// 使用CCJSqlParserManager对象的parse方法解析原始SQL语句将其转换为Select类型的对象。
// 这里需要将原始SQL语句通过StringReader转换为可读取的流形式提供给parse方法进行解析。
Select select = (Select) parserManager.parse(new StringReader(src));
// 从Select对象中获取其查询主体部分即PlainSelect对象它包含了查询语句的具体内容如查询条件、字段等。
PlainSelect selectBody = (PlainSelect) select.getSelectBody();
// 将PlainSelect对象转换为字符串形式得到初步处理后的SQL语句。
// 这里主要是为了后续方便进行用户ID等信息的替换操作。
String sql = selectBody.toString();
// 调用processUserId方法对初步处理后的SQL语句进行用户ID的替换操作将用户ID占位符替换为实际的用户ID。
sql = this.processUserId(sql);
// 返回处理后的SQL语句。
return sql;
} catch (Exception e) {
e.printStackTrace();
}
// 如果在处理过程中出现异常则返回原始的SQL语句。
return src;
}
}

@ -0,0 +1,188 @@
// 定义包路径用于存放更新拦截器相关的类。这个包名表明该类属于特定的项目模块com.yf.exam下的aspect.mybatis部分
// 通常用于组织和管理与MyBatis相关的切面逻辑代码。
package com.yf.exam.aspect.mybatis;
// 导入MyBatis-Plus的抽象SQL解析处理器类它提供了一些基础的SQL解析处理功能
// 本类继承自该类以便在处理更新操作时利用其相关功能或遵循其处理规范。
import com.baomidou.mybatisplus.extension.handlers.AbstractSqlParserHandler;
// 导入Apache Commons Lang3库中的数组工具类用于对数组进行各种操作
// 如合并数组等,在本类中用于合并对象的字段数组(当存在父类字段时)。
import org.apache.commons.lang3.ArrayUtils;
// 导入MyBatis中的执行器接口类它是MyBatis执行SQL语句的核心组件负责实际执行数据库操作
// 在本类中作为拦截的目标对象类型通过拦截其update方法来实现自动设置创建时间和更新时间的功能。
import org.apache.ibatis.executor.Executor;
// 导入MyBatis中的映射语句类它包含了关于SQL语句的映射信息
// 如SQL语句的ID、参数映射、结果映射等在本类中用于获取SQL语句的相关属性如语句类型等
// 以便根据不同的操作类型(插入、更新等)来处理创建时间和更新时间的赋值。
import org.apache.ibatis.mapping.MappedStatement;
// 导入MyBatis中的SQL命令类型枚举类用于表示不同类型的SQL命令
// 如SELECT、INSERT、UPDATE、DELETE等在本类中用于判断当前拦截的SQL语句是何种类型的操作
// 从而确定是否需要对创建时间和更新时间进行赋值。
import org.apache.ibatis.mapping.SqlCommandType;
// 导入MyBatis的拦截器接口类定义了拦截器的基本行为和方法
// 本类实现了该接口以作为一个MyBatis的拦截器来拦截更新语句的执行过程实现自动设置时间的功能。
import org.apache.ibatis.plugin.Interceptor;
// 导入MyBatis的拦截器注解类用于标注一个类是MyBatis的拦截器并指定拦截的目标和方法
// 本类通过该注解指定了要拦截Executor类的update方法。
import org.apache.ibatis.plugin.Intercepts;
// 导入MyBatis的拦截器调用类用于在拦截器方法中传递被拦截方法的调用信息
// 包括被拦截的目标对象、方法参数等在本类的intercept方法中会接收到该对象来处理拦截逻辑。
import org.apache.ibatis.plugin.Invocation;
// 导入MyBatis的插件包装类用于将拦截器包装成MyBatis可识别的插件形式
// 在本类的plugin方法中会使用该类来包装目标对象以便实现拦截功能。
import org.apache.ibatis.plugin.Plugin;
// 导入MyBatis的拦截器签名类用于定义拦截器拦截的具体目标、方法和参数类型
// 在本类的@Intercepts注解中会使用该类来指定具体的拦截信息。
import org.apache.ibatis.plugin.Signature;
// 导入Java标准库中的反射字段类用于通过反射操作对象的私有字段
// 在本类中用于获取和设置对象的创建时间和更新时间字段的值。
import java.lang.reflect.Field;
// 导入Java标准库中的时间戳类用于表示某个特定时刻的时间点
// 在本类中用于设置创建时间和更新时间为当前的时间戳,以记录操作发生的准确时间。
import java.sql.Timestamp;
// 导入Java标准库中的对象工具类提供了一些用于比较和操作对象的方法
// 在本类中用于比较字段名与预定义的创建时间、更新时间字段名是否相等。
import java.util.Objects;
// 导入Java标准库中的属性类用于存储和管理键值对形式的属性信息
// 在本类中作为Interceptor接口的setProperties方法的参数类型虽然在本类代码中该方法暂未实现具体功能
// 但它是符合Interceptor接口规范的一部分可用于接收外部配置的属性信息来动态调整拦截器的行为。
import java.util.Properties;
/**
*
* MyBatisExecutorupdate
*
* @author bool
*/
@Intercepts(value = {@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
// 使用@Intercepts注解并通过@Signature指定该类作为MyBatis的拦截器要拦截的目标和方法。
// 这里拦截的是Executor类的update方法并且该方法的参数类型为MappedStatement和Object。
public class UpdateInterceptor extends AbstractSqlParserHandler implements Interceptor {
/**
* 便
*/
private static final String CREATE_TIME = "createTime";
/**
* 便
*/
private static final String UPDATE_TIME = "updateTime";
/**
* Executorupdate
*
* @param invocation
* @return
* @throws Throwable
*/
@Override
public Object intercept(Invocation invocation) throws Throwable {
// 从invocation对象的参数数组中获取第一个参数即MappedStatement对象
// 它包含了关于SQL语句的映射信息用于后续获取SQL命令类型等操作。
MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
// 获取当前SQL语句的类型通过MappedStatement对象的getSqlCommandType方法获取。
// 该类型是一个枚举值如SELECT、INSERT、UPDATE、DELETE等用于判断当前拦截的SQL语句是何种类型的操作。
SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
// 从invocation对象的参数数组中获取第二个参数即要进行新增或修改操作的对象参数
// 后续会通过反射操作该对象来设置创建时间和更新时间字段的值。
Object parameter = invocation.getArgs()[1];
// 获取对象中所有的私有成员变量对应表字段通过反射获取parameter对象的声明字段数组。
Field[] declaredFields = parameter.getClass().getDeclaredFields();
// 判断parameter对象的父类是否存在如果存在则获取父类的声明字段数组
// 并将其与之前获取的子类声明字段数组进行合并,以获取完整的包含父类和子类字段的数组。
if (parameter.getClass().getSuperclass()!= null) {
Field[] superField = parameter.getClass().getSuperclass().getDeclaredFields();
declaredFields = ArrayUtils.addAll(declaredFields, superField);
}
// 用于临时存储当前遍历到的字段名,以便后续与预定义的创建时间、更新时间字段名进行比较。
String fieldName = null;
// 遍历获取到的所有字段数组(包含父类和子类字段),对每个字段进行处理。
for (Field field : declaredFields) {
fieldName = field.getName();
// 如果当前遍历到的字段名与预定义的创建时间字段名相等,说明找到了创建时间字段。
if (Objects.equals(CREATE_TIME, fieldName)) {
// 如果当前SQL语句的操作类型是插入操作INSERT则需要为创建时间字段设置当前时间。
if (SqlCommandType.INSERT.equals(sqlCommandType)) {
// 通过反射设置该字段可访问,因为私有字段默认是不可直接访问的。
field.setAccessible(true);
// 使用反射设置该字段的值为当前的时间戳通过System.currentTimeMillis()获取当前时间的毫秒数,
// 再创建一个Timestamp对象来表示该时间点从而为创建时间字段赋值。
field.set(parameter, new Timestamp(System.currentTimeMillis()));
}
}
// 如果当前遍历到的字段名与预定义的更新时间字段名相等,说明找到了更新时间字段。
if (Objects.equals(UPDATE_TIME, fieldName)) {
// 如果当前SQL语句的操作类型是插入操作INSERT或者更新操作UPDATE
// 则需要为更新时间字段设置当前时间。
if (SqlCommandType.INSERT.equals(sqlCommandType) || SqlCommandType.UPDATE.equals(sqlCommandType)) {
// 通过反射设置该字段可访问,因为私有字段默认是不可直接访问的。
field.setAccessible(true);
// 使用反射设置该字段的值为当前的时间戳通过System.currentTimeMillis()获取当前时间的毫秒数,
// 再创建一个Timestamp对象来表示该时间点从而为更新时间字段赋值。
field.set(parameter, new Timestamp(System.currentTimeMillis()));
}
}
}
// 继续执行被拦截的Executor的update方法的原有逻辑经过上述处理后
// 已经为创建时间和更新时间字段设置了合适的值(如果符合条件的话),现在继续执行原始的更新操作。
return invocation.proceed();
}
/**
* MyBatis
*
* @param target Executor
* @return 便MyBatis
*/
@Override
public Object plugin(Object target) {
// 如果目标对象是Executor类型说明是我们要拦截的对象
// 则使用Plugin.wrap方法将拦截器this包装到目标对象上以便实现拦截功能。
if (target instanceof Executor) {
return Plugin.wrap(target, this);
}
// 如果目标对象不是Executor类型说明不是我们要拦截的对象直接返回该目标对象即可。
return target;
}
/**
*
* Interceptor
*
* @param properties Properties
*/
@Override
public void setProperties(Properties properties) {
// 这里暂时没有具体的设置属性操作,可根据后续需求添加相关逻辑来处理接收到的属性信息。
}
}

@ -0,0 +1,128 @@
// 定义包路径用于存放注入工具类相关的代码。这个包名表明该类属于特定的项目模块com.yf.exam下的aspect.utils部分
// 通常用于组织和管理与注入操作相关的工具类代码。
package com.yf.exam.aspect.utils;
// 导入FastJSON库它是一个用于将Java对象与JSON字符串进行相互转换的高性能库
// 在本类的restError方法中用于将API响应对象转换为JSON字符串以便写入HTTP响应中。
import com.alibaba.fastjson.JSON;
// 导入API错误类它可能定义了一系列表示不同类型API错误的常量或属性
// 在本类的restError方法中用于创建包含特定错误信息的API响应对象。
import com.yf.exam.core.api.ApiError;
// 导入API响应类它用于封装API调用的返回结果包括成功的结果以及可能出现的错误信息等
// 在本类的restError方法中用于创建要返回给客户端的错误响应对象。
import com.yf.exam.core.api.ApiRest;
// 导入Lombok的Log4j2注解用于简化日志记录的配置通过该注解可以方便地在类中使用Log4j2进行日志输出。
import lombok.extern.log4j.Log4j2;
// 导入Spring框架的组件注解用于标记该类是一个Spring组件这样Spring容器可以对其进行管理和实例化
// 使其能够在Spring应用程序中被其他组件所使用。
import org.springframework.stereotype.Component;
// 导入Java标准库中的HTTP响应类用于处理HTTP协议相关的响应操作
// 在本类的restError方法中用于设置响应的编码、内容类型以及写入响应内容等操作。
import javax.servlet.http.HttpServletResponse;
// 导入Java标准库中的IO异常类用于处理输入输出操作过程中可能出现的异常情况
// 在本类的restError方法以及其他可能涉及到IO操作的地方用于捕获和处理相关异常。
import java.io.IOException;
// 导入Java标准库中的反射字段类用于通过反射操作对象的私有字段
// 在本类的setValue和getFiled方法中用于获取和设置对象的指定字段的值。
import java.lang.reflect.Field;
/**
*
* @author bool
* @date 2019-07-17 09:32
*/
@Log4j2 // 使用Log4j2注解启用日志记录功能方便在类中记录相关操作的日志信息。
@Component // 将该类标记为Spring组件使其能够被Spring容器管理和使用。
public class InjectUtils {
/**
*
*
* @param object
* @param value
* @param fields
* @throws Exception
*/
public void setValue(Object object, Object value, String... fields) throws Exception {
// 遍历要赋值的字段名数组
for (String fieldName : fields) {
// 根据对象的类和字段名获取对应的字段对象
Field field = this.getFiled(object.getClass(), fieldName);
// 如果获取到的字段对象为空,说明未找到对应的字段,继续下一个字段的处理。
if (field == null) {
continue;
}
// 通过反射设置该字段可访问,因为私有字段默认是不可直接访问的。
field.setAccessible(true);
// 使用反射设置该字段的值为传入的值,即将指定的值赋给对象的指定字段。
field.set(object, value);
}
}
/**
*
*
* @param clazz
* @param fieldName
* @return null
*/
private Field getFiled(Class clazz, String fieldName) {
System.out.println("注入的类:" + clazz.toString()); // 打印当前正在查找字段的目标类的信息,方便调试查看。
// 尝试获取当前类中指定字段名的字段对象
try {
return clazz.getDeclaredField(fieldName);
} catch (Exception e) {
log.error(clazz.toString() + ": not exist field, try superclass " + fieldName); // 如果获取字段失败,记录错误日志,
// 提示在当前类中不存在指定字段,
// 并准备尝试在父类中查找。
// 如果当前类未找到指定字段且存在父类,则递归调用本方法在父类中继续查找指定字段。
if (clazz.getSuperclass()!= null) {
return this.getFiled(clazz.getSuperclass(), fieldName);
}
// 如果在当前类及其所有父类中都未找到指定字段则返回null。
return null;
}
}
/**
* HTTP
*
* @param response HTTP
* @throws IOException IO
*/
public static void restError(HttpServletResponse response) {
try {
// 创建一个包含特定API错误信息的API响应对象这里使用了ApiError.ERROR_10010002作为错误码
// 具体含义可能在ApiError类中定义通常表示某种常见的错误情况。
ApiRest apiRest = new ApiRest(ApiError.ERROR_10010002);
// 设置HTTP响应的字符编码为UTF-8确保能够正确处理和传输各种字符特别是中文等非ASCII字符。
response.setCharacterEncoding("UTF-8");
// 设置HTTP响应的内容类型为application/json表明返回给客户端的内容是JSON格式的数据。
response.setContentType("application/json");
// 将创建的API响应对象转换为JSON字符串并写入到HTTP响应的输出流中以便客户端能够接收到错误信息。
response.getWriter().write(JSON.toJSONString(apiRest));
// 关闭HTTP响应的写入流释放相关资源。
response.getWriter().close();
} catch (IOException e) {
// 如果在设置响应属性或写入响应内容过程中出现IO异常这里只是简单地捕获异常
// 可以根据实际需求进一步处理异常,比如记录更详细的日志信息等。
}
}
}

@ -0,0 +1,81 @@
package com.yf.exam.config;
// 导入Spring Boot中用于注册Servlet过滤器的类通过它可以将自定义的过滤器注册到Servlet容器中
// 并配置相关属性如过滤器的执行顺序等。在本类中用于注册跨域过滤器CorsFilter
import org.springframework.boot.web.servlet.FilterRegistrationBean;
// 导入Spring框架中用于标记一个类是配置类的注解被该注解标记的类可以在其中定义各种Bean配置方法
// 这些方法会被Spring容器在启动时自动识别并执行用于创建和配置应用程序所需的各种组件。
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
// 导入Spring框架中用于指定顺序的接口实现该接口可以定义对象的顺序
// 在本类中用于指定跨域过滤器CorsFilter在过滤器链中的执行顺序使其具有最高优先级。
import org.springframework.core.Ordered;
// 导入Spring框架中用于配置跨域资源共享Cors的类通过它可以设置允许的源、请求头、请求方法等跨域相关的配置项。
import org.springframework.web.cors.CorsConfiguration;
// 导入Spring框架中基于URL的跨域配置源类它允许根据不同的URL模式来配置不同的跨域设置
// 在本类中用于创建一个基于URL的跨域配置源并将统一的跨域配置应用到所有的URL路径"**")上。
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
// 导入Spring框架中实现跨域过滤功能的类它会根据配置的跨域规则对请求进行过滤和处理
// 以实现允许跨域访问的功能。在本类中创建该过滤器并将其注册到Servlet容器中。
import org.springframework.web.filter.CorsFilter;
/**
* 访
* CorsFilter
* 使访
*
* @author bool
* @date 2019-08-13 17:28
*/
@Configuration // 标记该类为Spring框架的配置类表明其中可以定义各种Bean的创建和配置方法。
public class CorsConfig {
/**
* BeanFilterRegistrationBeanCorsFilter
*
* @return FilterRegistrationBean
*/
@Bean
public FilterRegistrationBean corsFilter() {
// 创建一个基于URL的跨域配置源对象它将作为跨域配置的基础用于后续设置跨域规则并应用到特定的URL路径上。
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
// 创建一个CorsConfiguration对象用于设置具体的跨域配置项如允许的源、请求头、请求方法等。
CorsConfiguration config = new CorsConfiguration();
// 设置是否允许携带凭证如Cookie等进行跨域请求这里设置为true表示允许携带凭证。
config.setAllowCredentials(true);
// 添加允许的源这里使用CorsConfiguration.ALL表示允许所有的源进行跨域访问。
// 可以根据实际需求设置具体的源地址,如"http://example.com"等多个源地址可以多次调用addAllowedOrigin方法添加。
config.addAllowedOrigin(CorsConfiguration.ALL);
// 添加允许的请求头同样使用CorsConfiguration.ALL表示允许所有的请求头进行跨域请求。
// 如果需要限制特定的请求头,可以通过其他方式设置具体的请求头列表。
config.addAllowedHeader(CorsConfiguration.ALL);
// 添加允许的请求方法使用CorsConfiguration.ALL表示允许所有的请求方法进行跨域请求
// 包括常见的GET、POST、PUT、DELETE等方法。也可以根据实际需求设置具体的请求方法列表。
config.addAllowedMethod(CorsConfiguration.ALL);
// 将上述设置好的跨域配置应用到所有的URL路径上"**"表示匹配任意的URL路径。
// 这样,对于应用程序接收到的任何请求,都会根据这个统一的跨域配置进行处理。
source.registerCorsConfiguration("/**", config);
// 创建一个FilterRegistrationBean对象用于注册跨域过滤器CorsFilter
// 将创建好的基于上述跨域配置源的跨域过滤器new CorsFilter(source)作为参数传入FilterRegistrationBean的构造函数。
FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(source));
// 设置跨域过滤器在过滤器链中的执行顺序这里设置为Ordered.HIGHEST_PRECEDENCE表示具有最高优先级。
// 即该过滤器会在其他过滤器之前首先对请求进行处理,以确保跨域配置能够最先生效。
bean.setOrder(Ordered.HIGHEST_PRECEDENCE);
// 返回配置好的FilterRegistrationBean对象完成跨域过滤器的注册和相关设置。
return bean;
}
}

@ -0,0 +1,67 @@
// 定义包路径用于存放文件上传配置类相关的代码。这个包名表明该类属于特定的项目模块com.yf.exam下的config部分
// 通常用于组织和管理与文件上传配置相关的代码。
package com.yf.exam.config;
// 导入Spring Boot中用于创建和配置多部分Multipart上传相关设置的工厂类。
// 通过这个工厂类可以方便地设置如单个文件大小限制、总上传数据大小限制等参数,
// 在本类中用于创建和配置文件上传的相关限制。
import org.springframework.boot.web.servlet.MultipartConfigFactory;
// 导入Spring框架中用于标记一个方法返回值为Spring Bean的注解。
// 被该注解标记的方法其返回值会被Spring容器管理作为一个可被注入到其他组件中的Bean实例。
// 在本类中用于将multipartConfigElement方法返回的MultipartConfigElement对象注册为Spring Bean。
import org.springframework.context.annotation.Bean;
// 导入Spring框架中用于标记一个类是配置类的注解。
// 被该注解标记的类可以在其中定义各种Bean配置方法这些方法会被Spring容器在启动时自动识别并执行
// 用于创建和配置应用程序所需的各种组件。在本类中用于标记该类为Spring配置类以便进行文件上传相关的配置。
import org.springframework.context.annotation.Configuration;
// 导入Spring框架中用于处理数据大小单位转换和表示的工具类。
// 它可以方便地将不同单位的数据大小表示转换为统一的格式,
// 在本类中用于设置文件上传的单个文件大小和总上传数据大小的限制以兆字节MB为单位进行设置。
import org.springframework.util.unit.DataSize;
// 导入Java标准库中的用于表示多部分Multipart上传配置元素的接口。
// 这个接口定义了多部分上传相关的配置参数,如文件大小限制、请求大小限制等,
// 在本类中通过MultipartConfigFactory创建并返回实现了该接口的对象以完成文件上传的配置设置。
import javax.servlet.MultipartConfigElement;
/**
*
// 包括单个文件的最大允许大小以及整个上传请求的最大允许数据大小等。
*
* @author bool
* @date 2019-07-29 16:23
*/
@Configuration // 使用该注解标记此为Spring配置类表明这个类是用来进行Spring应用程序的配置工作的。
public class MultipartConfig {
/**
* 使@BeanSpring Bean
* MultipartConfigElement
*
* @return MultipartConfigElement
*/
@Bean
public MultipartConfigElement multipartConfigElement() {
MultipartConfigFactory factory = new MultipartConfigFactory(); // 创建一个MultipartConfigFactory对象
// 它是用于创建MultipartConfigElement对象的工厂类
// 通过它可以方便地设置各种文件上传的配置参数。
// 设置单个文件的最大允许大小。
// 这里使用DataSize.ofMegabytes(5000L)将大小设置为5000兆字节MB
// 即限制单个上传的文件大小不能超过5000MB。
factory.setMaxFileSize(DataSize.ofMegabytes(5000L));
// 设置整个上传请求的最大允许数据大小。
// 同样使用DataSize.ofMegabytes(5000L)将大小设置为5000兆字节MB
// 也就是说整个上传请求包括可能上传的多个文件以及其他相关数据的总数据量不能超过5000MB。
factory.setMaxRequestSize(DataSize.ofMegabytes(5000L));
// 通过MultipartConfigFactory对象的createMultipartConfig方法创建并返回一个MultipartConfigElement对象
// 这个对象包含了我们刚刚设置的单个文件大小和总上传数据大小等配置信息,
// 它会被Spring容器管理并应用到文件上传的相关处理中。
return factory.createMultipartConfig();
}
}

@ -0,0 +1,70 @@
// 定义包路径用于存放MyBatis配置类相关的代码。这个包名表明该类属于特定的项目模块com.yf.exam下的config部分
// 通常用于组织和管理与MyBatis配置相关的代码。
package com.yf.exam.config;
// 导入自定义的查询拦截器类,该拦截器用于在查询操作时进行一些额外的处理,
// 比如可能会根据特定条件对查询语句进行修改、添加过滤条件等操作。
import com.yf.exam.aspect.mybatis.QueryInterceptor;
// 导入自定义的更新拦截器类,该拦截器用于在插入或更新操作时进行相关处理,
// 例如自动设置创建时间、更新时间等字段的值。
import com.yf.exam.aspect.mybatis.UpdateInterceptor;
// 导入MyBatis与Spring集成时用于扫描MyBatis映射接口的注解。
// 通过该注解可以指定要扫描的包路径以便Spring能够自动发现并注册MyBatis的映射接口
// 使得这些接口可以被正确地用于数据库操作。
import org.mybatis.spring.annotation.MapperScan;
// 导入Spring框架中用于标记一个方法返回值为Spring Bean的注解。
// 被该注解标记的方法其返回值会被Spring容器管理作为一个可被注入到其他组件中的Bean实例。
// 在本类中用于将queryInterceptor和updateInterceptor方法返回的拦截器对象注册为Spring Bean。
import org.springframework.context.annotation.Bean;
// 导入Spring框架中用于标记一个类是配置类的注解。
// 被该注解标记的类可以在其中定义各种Bean配置方法这些方法会被Spring容器在启动时自动识别并执行
// 用于创建和配置应用程序所需的各种组件。在本类中用于标记该类为Spring配置类以便进行MyBatis相关的配置。
import org.springframework.context.annotation.Configuration;
/**
* MybatisMyBatis
* MyBatis
*
* @author bool
*/
@Configuration // 使用该注解标记此为Spring配置类表明这个类是用来进行Spring应用程序的配置工作的。
@MapperScan("com.yf.exam.modules.**.mapper") // 使用MapperScan注解指定要扫描的MyBatis映射接口所在的包路径
// "com.yf.exam.modules.**.mapper"表示会扫描com.yf.exam.modules包及其子包下的所有mapper接口。
public class MybatisConfig {
/**
* 使@BeanSpring Bean
* QueryInterceptor
*
* @return QueryInterceptor
*/
@Bean // 将该方法返回的查询拦截器对象声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
public QueryInterceptor queryInterceptor() {
QueryInterceptor query = new QueryInterceptor(); // 创建一个新的查询拦截器对象。
// 设置查询限制,这里将查询限制设置为 -1L具体含义可能根据QueryInterceptor类的内部逻辑而定
// 可能表示不限制查询结果的数量或者有其他特殊的处理方式与该值相关。
query.setLimit(-1L);
// 返回设置好的查询拦截器对象该对象将被Spring容器管理并在合适的查询操作场景中被调用执行拦截处理。
return query;
}
/**
* 使@BeanSpring Bean
* UpdateInterceptor
*
* @return UpdateInterceptor
*/
@Bean // 将该方法返回的更新拦截器对象声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
public UpdateInterceptor updateInterceptor() {
// 创建一个新的更新拦截器对象这里没有进行额外的设置操作可能在UpdateInterceptor类内部有默认的处理逻辑
// 直接返回该对象它将被Spring容器管理并在合适的插入或更新操作场景中被调用执行拦截处理。
return new UpdateInterceptor();
}
}

@ -0,0 +1,182 @@
// 定义包路径用于存放任务调度配置类相关的代码。这个包名表明该类属于特定的项目模块com.yf.exam下的config部分
// 通常用于组织和管理与任务调度配置相关的代码。
package com.yf.exam.config;
// 导入Lombok的Log4j2注解用于简化日志记录的配置通过该注解可以方便地在类中使用Log4j2进行日志输出。
import lombok.extern.log4j.Log4j2;
// 导入Spring框架中用于处理异步方法执行过程中未捕获异常的处理器接口。
// 当异步方法抛出异常且未在方法内部被捕获时,会由该处理器来处理异常情况,
// 在本类中实现该接口来定义异步未捕获异常的处理逻辑。
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
// 导入Spring框架中用于标记一个方法返回值为Spring Bean的注解。
// 被该注解标记的方法其返回值会被Spring容器管理作为一个可被注入到其他组件中的Bean实例。
// 在本类中用于将taskScheduler和asyncExecutor等方法返回的对象注册为Spring Bean。
import org.springframework.context.annotation.Bean;
// 导入Spring框架中用于标记一个类是配置类的注解。
// 被该注解标记的类可以在其中定义各种Bean配置方法这些方法会被Spring容器在启动时自动识别并执行
// 用于创建和配置应用程序所需的各种组件。在本类中用于标记该类为Spring配置类以便进行任务调度相关的配置。
import org.springframework.context.annotation.Configuration;
// 导入Spring框架中用于配置异步任务执行相关设置的接口。
// 实现该接口可以定义异步任务执行的线程池等配置信息,在本类中实现该接口来配置异步任务执行的相关参数。
import org.springframework.scheduling.annotation.AsyncConfigurer;
// 导入Spring框架中用于启用异步任务执行功能的注解。
// 当在类上添加该注解后Spring会自动识别并处理类中的异步方法使其能够在独立的线程中执行。
// 在本类上添加该注解以启用异步任务执行功能。
import org.springframework.scheduling.annotation.EnableAsync;
// 导入Spring框架中用于启用任务调度功能的注解。
// 当在类上添加该注解后Spring会自动识别并处理类中的定时任务等调度相关的设置使其能够按照预定的时间执行任务。
// 在本类上添加该注解以启用任务调度功能。
import org.springframework.scheduling.annotation.EnableScheduling;
// 导入Spring框架中用于配置任务调度相关设置的接口。
// 实现该接口可以定义任务调度的线程池、任务注册等配置信息,在本类中实现该接口来配置任务调度的相关参数。
import org.springframework.scheduling.annotation.SchedulingConfigurer;
// 导入Spring框架中用于执行线程池任务的执行器类。
// 它可以创建一个线程池并通过该线程池来执行任务在本类的asyncExecutor方法中用于创建异步任务执行的线程池。
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
// 导入Spring框架中用于调度线程池任务的调度器类。
// 它可以创建一个线程池并通过该线程池来调度任务的执行时间在本类的taskScheduler方法中用于创建定时任务执行的线程池。
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
// 导入Spring框架中用于注册调度任务的类。
// 通过它可以将需要调度执行的任务注册到相应的调度器中在本类的configureTasks方法中用于设置任务调度器。
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
// 导入Java标准库中的执行器接口它定义了执行任务的通用规范
// 在本类的getAsyncExecutor方法中用于返回异步任务执行的执行器对象。
import java.util.concurrent.Executor;
// 导入Java标准库中的线程池执行器类它是实现了线程池功能的具体类
// 在本类的asyncExecutor方法中用于设置异步任务执行线程池的拒绝策略。
import java.util.concurrent.ThreadPoolExecutor;
/**
*
* 线线线
*
* @author bool
*/
@Log4j2 // 使用Log4j2注解启用日志记录功能方便在类中记录相关操作的日志信息。
@Configuration // 使用该注解标记此为Spring配置类表明这个类是用来进行Spring应用程序的配置工作的。
@EnableScheduling // 使用该注解启用任务调度功能使得Spring能够识别并处理类中的定时任务等调度相关设置。
@EnableAsync // 使用该注解启用异步任务执行功能使得Spring能够识别并处理类中的异步方法使其能够在独立的线程中执行。
public class ScheduledConfig implements SchedulingConfigurer, AsyncConfigurer {
/**
* 使@BeanSpring Bean
* 线ThreadPoolTaskScheduler
*
* @return 线ThreadPoolTaskScheduler线
*/
@Bean(destroyMethod = "shutdown", name = "taskScheduler") // 将该方法返回的线程池任务调度器对象声明为Spring Bean
// 并指定销毁方法为"shutdown",以便在容器关闭时正确关闭线程池。
public ThreadPoolTaskScheduler taskScheduler() {
ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler(); // 创建一个新的线程池任务调度器对象。
// 设置线程池的大小即同时可执行的定时任务数量这里设置为10表示线程池最多可同时执行10个定时任务。
scheduler.setPoolSize(10);
// 设置线程的名称前缀,用于在日志等场景中方便识别线程所属的任务调度器,这里设置为"task-"
// 生成的线程名称可能类似"task-1"、"task-2"等。
scheduler.setThreadNamePrefix("task-");
// 设置线程池在关闭时等待任务完成的时间单位为秒这里设置为600秒10分钟
// 表示在容器关闭时线程池会等待正在执行的任务完成最长等待时间为10分钟。
scheduler.setAwaitTerminationSeconds(600);
// 设置在关闭时是否等待任务完成这里设置为true表示在容器关闭时线程池会等待所有任务完成后再关闭。
scheduler.setWaitForTasksToCompleteOnShutdown(true);
// 返回设置好的线程池任务调度器对象该对象将被Spring容器管理并在定时任务执行场景中被调用进行任务调度。
return scheduler;
}
/**
* 使@BeanSpring Bean
* 线ThreadPoolTaskExecutor
*
* @return 线ThreadPoolTaskExecutor线
*/
@Bean(name = "asyncExecutor") // 将该方法返回的线程池任务执行器对象声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
public ThreadPoolTaskExecutor asyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); // 创建一个新的线程池任务执行器对象。
// 设置线程池的核心线程数即线程池始终保持的活跃线程数量这里设置为10表示线程池至少会保持10个线程处于活跃状态。
executor.setCorePoolSize(10);
// 设置线程池的队列容量即用于存储等待执行任务的队列大小这里设置为1000表示队列最多可容纳1000个等待执行的任务。
executor.setQueueCapacity(1000);
// 设置线程池中非核心线程的保持活动时间单位为秒这里设置为600秒10分钟
// 表示当非核心线程空闲时间超过10分钟时可能会被回收。
executor.setKeepAliveSeconds(600);
// 设置线程池的最大线程数即线程池最多可同时拥有的线程数量这里设置为20表示线程池最多可扩展到20个线程同时执行任务。
executor.setMaxPoolSize(20);
// 设置线程的名称前缀,用于在日志等场景中方便识别线程所属的任务执行器,这里设置为"taskExecutor-"
// 生成的线程名称可能类似"taskExecutor-1"、"taskExecutor-2"等。
executor.setThreadNamePrefix("taskExecutor-");
// 设置线程池的拒绝策略这里采用ThreadPoolExecutor.CallerRunsPolicy()
// 表示当线程池和队列都已满,无法再接受新任务时,会由调用线程来执行该任务,而不是直接抛出异常。
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 初始化线程池,使其处于可使用状态,完成各项参数的设置和内部资源的初始化。
executor.initialize();
// 返回设置好的线程池任务执行器对象该对象将被Spring容器管理并在异步任务执行场景中被调用进行任务执行。
return executor;
}
/**
* SchedulingConfigurer
* 线
* 便使
*
* @param scheduledTaskRegistrar
*/
@Override
public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
ThreadPoolTaskScheduler taskScheduler = taskScheduler(); // 获取之前创建的线程池任务调度器对象。
// 将获取到的线程池任务调度器对象设置到调度任务注册类中,使得后续注册的定时任务能够使用该调度器进行任务调度。
scheduledTaskRegistrar.setTaskScheduler(taskScheduler);
}
/**
* AsyncConfigurer
* 线
*
* @return 线
*/
@Override
public Executor getAsyncExecutor() {
return asyncExecutor();
}
/**
* AsyncConfigurer
*
*
*
* @param throwable
* @param method
* @param objects
* @return AsyncUncaughtExceptionHandler
*/
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return (throwable, method, objects) -> {
log.error("异步任务执行出现异常, message {}, method {}, params {}", throwable, method, objects);
};
}
}

@ -0,0 +1,133 @@
// 定义包路径用于存放Shiro配置类
package com.yf.exam.config;
import com.yf.exam.ability.shiro.CNFilterFactoryBean; // 自定义过滤器工厂类
import com.yf.exam.ability.shiro.ShiroRealm; // 自定义Shiro领域类
import com.yf.exam.ability.shiro.aop.JwtFilter; // JWT认证过滤器
import lombok.extern.slf4j.Slf4j; // Lombok日志注解
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator; // Shiro默认会话存储评估器
import org.apache.shiro.mgt.DefaultSubjectDAO; // Shiro默认主体DAO
import org.apache.shiro.mgt.SecurityManager; // Shiro安全管理器
import org.apache.shiro.spring.LifecycleBeanPostProcessor; // Spring生命周期Bean后处理器
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor; // Shiro授权属性源顾问
import org.apache.shiro.spring.web.ShiroFilterFactoryBean; // Shiro过滤器工厂类
import org.apache.shiro.web.mgt.DefaultWebSecurityManager; // Shiro默认Web安全管理器
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator; // Spring默认顾问自动代理创建器
import org.springframework.context.annotation.Bean; // Spring Bean注解
import org.springframework.context.annotation.Configuration; // Spring配置注解
import org.springframework.context.annotation.DependsOn; // Spring依赖注解
import javax.servlet.Filter; // Servlet过滤器接口
import java.util.HashMap; // Java哈希映射类
import java.util.LinkedHashMap; // Java链接哈希映射类
import java.util.Map; // Java映射类
/**
* Shiro
* ShiroRealm
* @author bool
*/
@Slf4j // 使用Lombok注解启用Log4j2日志
@Configuration // 使用Spring注解标记为配置类
public class ShiroConfig {
/**
* Shiro
* ShiroURL
*
* @param securityManager Shiro
* @return ShiroFilterFactoryBean ShiroBean
*/
@Bean("shiroFilterFactoryBean") // 使用Spring注解声明为Bean并指定Bean名称
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
CNFilterFactoryBean shiroFilterFactoryBean = new CNFilterFactoryBean(); // 创建自定义过滤器工厂Bean
shiroFilterFactoryBean.setSecurityManager(securityManager); // 设置安全管理器
// 定义过滤器链
Map<String, String> map = new LinkedHashMap<>(); // 创建拦截器映射
// 配置不需要认证的路径
map.put("/exam/api/sys/user/login", "anon"); // 登录接口不需要认证
map.put("/exam/api/sys/user/reg", "anon"); // 注册接口不需要认证
map.put("/exam/api/sys/user/quick-reg", "anon"); // 快速注册接口不需要认证
// 配置其他不需要认证的静态资源路径
map.put("/upload/file/**", "anon"); // 文件上传路径不需要认证
map.put("/", "anon"); // 根路径不需要认证
map.put("/v2/**", "anon"); // Swagger路径不需要认证
map.put("/doc.html", "anon"); // Swagger文档不需要认证
// ... 省略其他静态资源配置
// 添加自定义JWT过滤器
Map<String, Filter> filterMap = new HashMap<>(); // 创建过滤器映射
filterMap.put("jwt", new JwtFilter()); // 添加JWT过滤器
shiroFilterFactoryBean.setFilters(filterMap); // 设置过滤器
// 设置过滤器链定义
map.put("/**", "jwt"); // 所有请求都需要通过JWT过滤器
shiroFilterFactoryBean.setFilterChainDefinitionMap(map); // 设置过滤器链定义
return shiroFilterFactoryBean; // 返回Shiro过滤器工厂Bean
}
/**
* Shiro
* ShiroRealmShiro
*
* @param myRealm Shiro
* @return DefaultWebSecurityManager Shiro
*/
@Bean("securityManager") // 使用Spring注解声明为Bean并指定Bean名称
public DefaultWebSecurityManager securityManager(ShiroRealm myRealm) {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(); // 创建默认Web安全管理器
securityManager.setRealm(myRealm); // 设置自定义Realm
// 禁用Shiro的会话存储
DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO(); // 创建默认主体DAO
DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator(); // 创建默认会话存储评估器
defaultSessionStorageEvaluator.setSessionStorageEnabled(false); // 禁用会话存储
subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator); // 设置会话存储评估器
securityManager.setSubjectDAO(subjectDAO); // 设置主体DAO
return securityManager; // 返回安全管理器
}
/**
*
* 使Shiro
*
* @return DefaultAdvisorAutoProxyCreator
*/
@Bean // 使用Spring注解声明为Bean
@DependsOn("lifecycleBeanPostProcessor") // 依赖于生命周期Bean后处理器
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator(); // 创建顾问自动代理创建器
defaultAdvisorAutoProxyCreator.setProxyTargetClass(true); // 设置代理目标类
return defaultAdvisorAutoProxyCreator; // 返回顾问自动代理创建器
}
/**
* Bean
* ShiroBeanShiro
*
* @return LifecycleBeanPostProcessor Bean
*/
@Bean // 使用Spring注解声明为Bean
public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
return new LifecycleBeanPostProcessor(); // 返回生命周期Bean后处理器
}
/**
*
* ShiroShiro
*
* @param securityManager Shiro
* @return AuthorizationAttributeSourceAdvisor
*/
@Bean // 使用Spring注解声明为Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor(); // 创建授权属性源顾问
advisor.setSecurityManager(securityManager); // 设置安全管理器
return advisor; // 返回授权属性源顾问
}
}

@ -0,0 +1,164 @@
// 定义包路径用于存放Swagger配置类相关的代码。这个包名表明该类属于特定的项目模块com.yf.exam下的config部分
// 通常用于组织和管理与Swagger配置相关的代码。
package com.yf.exam.config;
// 导入用于启用Swagger Bootstrap UI的注解Swagger Bootstrap UI是对Swagger UI的一种增强
// 提供了更友好的界面展示和交互功能,通过该注解可以在项目中启用这一特性。
import com.github.xiaoymin.swaggerbootstrapui.annotations.EnableSwaggerBootstrapUI;
// 导入Swagger用于标注API操作的注解通过在方法上添加该注解可以为该方法在Swagger文档中生成详细的操作描述信息
// 包括方法的功能、参数、返回值等内容方便开发者和使用者了解API的具体使用方式。
import io.swagger.annotations.ApiOperation;
// 导入Spring框架中用于将类的属性与配置文件中的属性进行绑定的注解。
// 通过指定prefix属性可以将配置文件中以该前缀开头的属性值绑定到类的对应属性上
// 在本类中用于绑定以"swagger"为前缀的配置属性。
import org.springframework.boot.context.properties.ConfigurationProperties;
// 导入Spring框架中用于标记一个方法返回值为Spring Bean的注解。
// 被该注解标记的方法其返回值会被Spring容器管理作为一个可被注入到其他组件中的Bean实例。
// 在本类中用于将examApi、securityScheme等方法返回的对象注册为Spring Bean。
import org.springframework.context.annotation.Bean;
// 导入Spring框架中用于标记一个类是配置类的注解。
// 被该注解标记的类可以在其中定义各种Bean配置方法这些方法会被Spring容器在启动时自动识别并执行
// 用于创建和配置应用程序所需的各种组件。在本类中用于标记该类为Spring配置类以便进行Swagger相关的配置。
import org.springframework.context.annotation.Configuration;
// 导入Swagger用于构建API信息的构建器类通过该构建器可以方便地设置API的标题、描述、联系人、版本等信息
// 在本类的apiInfo方法中用于创建并返回包含详细API信息的ApiInfo对象。
import springfox.documentation.builders.ApiInfoBuilder;
// 导入Swagger用于选择路径的选择器类通过该选择器可以指定哪些路径下的API需要被Swagger生成文档并展示
// 在本类的examApi方法中用于选择符合特定路径模式的API。
import springfox.documentation.builders.PathSelectors;
// 导入Swagger用于选择请求处理器即包含API方法的类或接口的选择器类
// 通过该选择器可以指定哪些请求处理器中的方法需要被Swagger生成文档并展示
// 在本类的examApi方法中用于选择带有ApiOperation注解的方法所在的请求处理器。
import springfox.documentation.builders.RequestHandlerSelectors;
// 导入Swagger用于表示API信息的类该类包含了API的标题、描述、联系人、版本等详细信息
// 在本类的examApi方法中通过调用apiInfo方法获取该对象并设置到Docket中以便在Swagger文档中展示这些信息。
import springfox.documentation.service.ApiInfo;
// 导入Swagger用于表示API密钥的类用于设置API的授权相关信息如授权的键名、值的位置如在请求头中
// 在本类的securityScheme方法中用于创建并返回一个ApiKey对象用于设置API的授权方案。
import springfox.documentation.service.ApiKey;
// 导入Swagger用于表示联系人信息的类通过该类可以设置API的联系人姓名、联系方式、网址等信息
// 在本类的apiInfo方法中用于创建并返回一个包含联系人信息的Contact对象并设置到ApiInfo中。
import springfox.documentation.service.Contact;
// 导入Swagger用于表示安全方案的类它是一个通用的接口用于定义不同类型的安全方案
// 在本类的examApi方法中通过调用securityScheme方法获取具体的安全方案实现如ApiKey并设置到Docket中。
import springfox.documentation.service.SecurityScheme;
// 导入Swagger用于表示文档类型的枚举类目前主要有SWAGGER_2等类型
// 在本类的examApi方法中用于指定创建Docket对象时所采用的文档类型为SWAGagger_2。
import springfox.documentation.spi.DocumentationType;
// 导入Swagger用于生成Swagger文档的核心类通过该类可以配置各种Swagger相关的设置如API信息、路径选择、
// 授权方案等在本类的examApi方法中用于创建并配置Docket对象以生成符合项目需求的Swagger文档。
import springfox.documentation.spring.web.plugins.Docket;
// 导入用于启用Swagger 2的注解通过在类上添加该注解可以在项目中启用Swagger 2的功能
// 使得Swagger能够为项目中的API生成详细的文档并提供交互界面方便开发者和使用者查看和测试API。
import springfox.documentation.swagger2.annotations.EnableSwagger2;
// 导入Java标准库中的集合类用于处理集合相关的操作在本类的examApi方法中用于创建一个包含单个安全方案的列表
// 以便将安全方案设置到Docket对象中。
import java.util.Collections;
/**
* SwaggerSwagger
* Swagger 2Swagger Bootstrap UI"swagger"
* DocketAPIAPI
* API便API使
* @author bool
* @date 2020/8/19 20:53
*/
@Configuration // 使用该注解标记此为Spring配置类表明这个类是用来进行Spring应用程序的配置工作的。
@EnableSwagger2 // 使用该注解启用Swagger 2功能使得Swagger能够为项目中的API生成详细的文档并提供交互界面。
@EnableSwaggerBootstrapUI // 使用该注解启用Swagger Bootstrap UI功能提供更友好的界面展示和交互功能。
@ConfigurationProperties(prefix = "swagger") // 使用该注解将类的属性与以"swagger"为前缀的配置文件中的属性进行绑定,
// 以便在类中可以方便地使用这些配置属性来定制Swagger的设置。
public class SwaggerConfig {
/**
* 使@BeanSpring Bean
* DocketSwagger
* API
*
* @return DocketAPIAPI
*/
@Bean // 将该方法返回的Docket对象声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
public Docket examApi() {
return new Docket(DocumentationType.SWAGGER_2) // 创建一个新的Docket对象并指定文档类型为SWAGGER_2
// 这是目前较为常用的Swagger文档类型用于生成详细的API文档。
.apiInfo(apiInfo()) // 调用apiInfo方法获取包含详细API信息的ApiInfo对象并设置到Docket对象中
// 以便在生成的Swagger文档中展示API的标题、描述、联系人、版本等信息。
.groupName("考试模块接口") // 设置Docket对象的分组名称为"考试模块接口"
// 这样可以将项目中的API按照不同的模块或功能进行分组展示方便查看和管理。
.select() // 开始选择需要生成文档的API通过一系列选择器来指定具体的选择条件。
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class)) // 使用RequestHandlerSelectors的withMethodAnnotation方法选择带有ApiOperation注解的方法
// 即只选择那些在方法上标注了ApiOperation注解的API方法进行文档生成
// 这样可以确保只生成我们希望展示的重要API的文档。
.paths(PathSelectors.ant("/exam/api/**")) // 使用PathSelectors的ant方法选择符合特定路径模式的API
// 这里选择的路径模式是"/exam/api/**",表示只选择以"/exam/api/"开头的任意路径下的API进行文档生成
// 进一步限定了生成文档的API范围使其更加聚焦于项目中的特定部分如考试模块相关的API
.build() // 完成上述选择条件的设置后调用build方法构建Docket对象使其生效并包含我们所设置的所有选择条件和信息。
.securitySchemes(Collections.singletonList(securityScheme())) // 创建一个包含单个安全方案的列表,
// 通过调用securityScheme方法获取具体的安全方案对象如ApiKey
// 并将其添加到列表中然后设置到Docket对象中
// 以便在Swagger文档中展示API的授权相关信息如需要在请求头中传递的授权密钥等。
;
}
/**
* APIApiInfo
* ApiInfoBuilder便API
*
* @return ApiInfoAPI
* Docket便Swagger
*/
private ApiInfo apiInfo() {
return new ApiInfoBuilder().title("考试系统接口") // 使用ApiInfoBuilder的title方法设置API的标题为"考试系统接口"
// 这将在Swagger文档的顶部显著位置展示让使用者快速了解该API所属的系统。
.description("考试系统接口") // 使用ApiInfoBuilder的description方法设置API的描述为"考试系统接口"
// 可以在这里详细描述API的功能、用途、特点等信息方便使用者进一步了解API的具体情况。
.contact(new Contact("Van", "https://exam.yfhl.net", "18365918@qq.com")) // 使用ApiInfoBuilder的contact方法创建一个包含联系人信息的Contact对象
// 并设置联系人姓名为"Van",网址为"https://exam.yfhl.net",邮箱为"18365918@qq.com"
// 这些信息将在Swagger文档中展示方便使用者在有问题时能够联系到相关人员。
.version("1.0.0") // 使用ApiInfoBuilder的version方法设置API的版本号为"1.0.0"
// 让使用者了解该API的版本情况以便在不同版本之间进行对比和选择。
.build(); // 完成上述各项信息的设置后调用build方法构建ApiInfo对象使其生效并包含我们所设置的所有信息。
}
/**
* APIApiKeyAPI
*
* @return ApiKeyAPI
* Docket便SwaggerAPI
*/
@Bean // 将该方法返回的SecurityScheme对象实际为ApiKey类型声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
SecurityScheme securityScheme() {
return new ApiKey("token", "token", "header"); // 创建一个新的ApiKey对象
// 第一个参数"token"表示授权的键名,即客户端在请求时需要在指定位置(这里是请求头)传递的键名;
// 第二个参数"token"表示授权的值,这里简单设置为与键名相同,实际应用中可能是根据用户登录等情况生成的授权令牌;
// 第三个参数"header"表示授权的值应该放置的位置,这里指定为在请求头中传递。
}
}

@ -0,0 +1,21 @@
package com.yf.exam.core.annon;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
*
* @author bool
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Dict {
String dicCode();
String dicText() default "";
String dictTable() default "";
}

@ -0,0 +1,67 @@
package com.yf.exam.core.api;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
*
* 使
* @author bool
* @date 2019-06-14 21:15
*/
@NoArgsConstructor
@AllArgsConstructor
public enum ApiError implements Serializable {
/**
*
*/
ERROR_10010001("参数不全或类型错误!"),
ERROR_10010002("您还未登录,请先登录!"),
ERROR_10010003("数据不存在!"),
ERROR_10010012("图形验证码错误!"),
ERROR_10010013("短信验证码错误!"),
ERROR_10010014("不允许重复评论!"),
/**
*
*/
ERROR_20010001("试题被删除,无法继续考试!"),
ERROR_20010002("您有正在进行的考试!"),
ERROR_90010001("账号不存在,请确认!"),
ERROR_90010002("账号或密码错误!"),
ERROR_90010003("至少要包含一个角色!"),
ERROR_90010004("管理员账号无法修改!"),
ERROR_90010005("账号被禁用,请联系管理员!"),
ERROR_90010006("活动用户不足,无法开启竞拍!"),
ERROR_90010007("旧密码不正确,请确认!"),
ERROR_60000001("数据不存在!");
public String msg;
/**
* Markdown
* @param args
*/
public static void main(String[] args) {
for (ApiError e : ApiError.values()) {
System.out.println("'"+e.name().replace("ERROR_", "")+"':'"+e.msg+"',");
}
}
/**
*
* @return
*/
public Integer getCode(){
return Integer.parseInt(this.name().replace("ERROR_", ""));
}
}

@ -0,0 +1,64 @@
package com.yf.exam.core.api;
import com.yf.exam.core.api.ApiError;
import com.yf.exam.core.exception.ServiceException;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
*
* @author bool
* @date 2018/11/20 09:48
*/
@Data
@NoArgsConstructor
@ApiModel(value="接口响应", description="接口响应")
public class ApiRest<T>{
/**
*
*/
@ApiModelProperty(value = "响应消息")
private String msg;
/**
*
*/
@ApiModelProperty(value = "响应代码,0为成功,1为失败", required = true)
private Integer code;
/**
* body
*/
@ApiModelProperty(value = "响应内容")
protected T data;
/**
*
* @return
*/
public boolean isSuccess(){
return code.equals(0);
}
/**
*
* @param error
*/
public ApiRest(ServiceException error){
this.code = error.getCode();
this.msg = error.getMsg();
}
/**
*
* @param error
*/
public ApiRest(ApiError error){
this.code = error.getCode();
this.msg = error.msg;
}
}

@ -0,0 +1,154 @@
package com.yf.exam.core.api.controller;
import com.yf.exam.core.api.ApiError;
import com.yf.exam.core.api.ApiRest;
import com.yf.exam.core.exception.ServiceException;
/**
*
* @author Dav
*/
public class BaseController {
/**
*
*/
private static final Integer CODE_SUCCESS = 0;
private static final String MSG_SUCCESS = "操作成功!";
/**
*
*/
private static final Integer CODE_FAILURE = 1;
private static final String MSG_FAILURE = "请求失败!";
/**
*
* @param code
* @param message
* @param data
* @param <T>
* @return
*/
protected <T> ApiRest<T> message(Integer code, String message, T data){
ApiRest<T> response = new ApiRest<>();
response.setCode(code);
response.setMsg(message);
if(data!=null) {
response.setData(data);
}
return response;
}
/**
*
* @param <T>
* @return
*/
protected <T> ApiRest<T> success(){
return message(0, "请求成功!", null);
}
/**
*
* @param message
* @param data
* @param <T>
* @return
*/
protected <T> ApiRest<T> success(String message, T data){
return message(CODE_SUCCESS, message, data);
}
/**
*
* @param data
* @param <T>
* @return
*/
protected <T> ApiRest<T> success(T data){
return message(CODE_SUCCESS, MSG_SUCCESS, data);
}
/**
*
* @param code
* @param message
* @param data
* @param <T>
* @return
*/
protected <T> ApiRest<T> failure(Integer code, String message, T data){
return message(code, message, data);
}
/**
*
* @param message
* @param data
* @param <T>
* @return
*/
protected <T> ApiRest<T> failure(String message, T data){
return message(CODE_FAILURE, message, data);
}
/**
*
* @param message
* @return
*/
protected <T> ApiRest<T> failure(String message){
return message(CODE_FAILURE, message, null);
}
/**
*
* @param data
* @param <T>
* @return
*/
protected <T> ApiRest<T> failure(T data){
return message(CODE_FAILURE, MSG_FAILURE, data);
}
/**
*
* @param <T>
* @return
*/
protected <T> ApiRest<T> failure(){
return message(CODE_FAILURE, MSG_FAILURE, null);
}
/**
*
* @param <T>
* @return
*/
protected <T> ApiRest<T> failure(ApiError error, T data){
return message(error.getCode(), error.msg, data);
}
/**
*
* @param ex
* @param <T>
* @return
*/
protected <T> ApiRest<T> failure(ServiceException ex){
ApiRest<T> apiRest = message(ex.getCode(), ex.getMsg(), null);
return apiRest;
}
}

@ -0,0 +1,15 @@
package com.yf.exam.core.api.dto;
import lombok.Data;
import java.io.Serializable;
/**
*
* @author dav
* @date 2019/3/16 15:56
*/
@Data
public class BaseDTO implements Serializable {
}

@ -0,0 +1,28 @@
package com.yf.exam.core.api.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* <p>
* ID
* </p>
*
* @author
* @since 2019-04-20 12:15
*/
@Data
@ApiModel(value="主键通用请求类", description="主键通用请求类")
public class BaseIdReqDTO extends BaseDTO {
@ApiModelProperty(value = "主键ID", required=true)
private String id;
@JsonIgnore
private String userId;
}

@ -0,0 +1,26 @@
package com.yf.exam.core.api.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* <p>
*
* </p>
*
* @author
* @since 2019-04-20 12:15
*/
@Data
@ApiModel(value="主键通用响应类", description="主键通用响应类")
@AllArgsConstructor
@NoArgsConstructor
public class BaseIdRespDTO extends BaseDTO {
@ApiModelProperty(value = "主键ID", required=true)
private String id;
}

@ -0,0 +1,26 @@
package com.yf.exam.core.api.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* ID
* @author bool
* @date 2019-08-01 19:07
*/
@Data
@ApiModel(value="删除参数", description="删除参数")
public class BaseIdsReqDTO extends BaseDTO {
@JsonIgnore
private String userId;
@ApiModelProperty(value = "要删除的ID列表", required = true)
private List<String> ids;
}

@ -0,0 +1,32 @@
package com.yf.exam.core.api.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* <p>
*
* </p>
*
* @author
* @since 2019-04-20 12:15
*/
@Data
@ApiModel(value="通用状态请求类", description="通用状态请求类")
@AllArgsConstructor
@NoArgsConstructor
public class BaseStateReqDTO extends BaseDTO {
@ApiModelProperty(value = "要修改对象的ID列表", required=true)
private List<String> ids;
@ApiModelProperty(value = "通用状态0为正常1为禁用", required=true)
private Integer state;
}

@ -0,0 +1,47 @@
package com.yf.exam.core.api.dto;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
*
* @param <T>
* @author bool
*/
@ApiModel(value="分页参数", description="分页参数")
@Data
public class PagingReqDTO<T> {
@ApiModelProperty(value = "当前页码", required = true, example = "1")
private Integer current;
@ApiModelProperty(value = "每页数量", required = true, example = "10")
private Integer size;
@ApiModelProperty(value = "查询参数")
private T params;
@ApiModelProperty(value = "排序字符")
private String orderBy;
@JsonIgnore
@ApiModelProperty(value = "当前用户的ID")
private String userId;
/**
* MyBatis
* @return
*/
public Page toPage(){
Page page = new Page();
page.setCurrent(this.current);
page.setSize(this.size);
return page;
}
}

@ -0,0 +1,30 @@
package com.yf.exam.core.api.dto;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
*
* @author bool
* @date 2019-07-20 15:17
* @param <T>
*/
public class PagingRespDTO<T> extends Page<T> {
/**
*
* @return
*/
@Override
public long getPages() {
if (this.getSize() == 0L) {
return 0L;
} else {
long pages = this.getTotal() / this.getSize();
if (this.getTotal() % this.getSize() != 0L) {
++pages;
}
return pages;
}
}
}

@ -0,0 +1,48 @@
package com.yf.exam.core.api.utils;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
/**
* JSON
* @author dav
* @date 2018/9/11 19:30
*/
public class JsonConverter {
/**
* FastJson
*
* @return
*/
public static HttpMessageConverter fastConverter() {
// 定义一个convert转换消息的对象
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
// 添加FastJson的配置信息
FastJsonConfig fastJsonConfig = new FastJsonConfig();
// 默认转换器
fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat,
SerializerFeature.WriteNullNumberAsZero,
SerializerFeature.MapSortField,
SerializerFeature.WriteNullStringAsEmpty,
SerializerFeature.DisableCircularReferenceDetect,
SerializerFeature.WriteDateUseDateFormat,
SerializerFeature.WriteNullListAsEmpty);
fastJsonConfig.setCharset(Charset.forName("UTF-8"));
// 处理中文乱码问题
List<MediaType> fastMediaTypes = new ArrayList<>();
fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
fastConverter.setSupportedMediaTypes(fastMediaTypes);
// 在convert中添加配置信息
fastConverter.setFastJsonConfig(fastJsonConfig);
return fastConverter;
}
}

@ -0,0 +1,19 @@
package com.yf.exam.core.enums;
/**
*
*
* @author bool
* @date 2019-09-17 17:57
*/
public interface CommonState {
/**
*
*/
Integer NORMAL = 0;
/**
*
*/
Integer ABNORMAL = 1;
}

@ -0,0 +1,18 @@
package com.yf.exam.core.enums;
/**
*
* @author bool
*/
public interface OpenType {
/**
*
*/
Integer OPEN = 1;
/**
*
*/
Integer DEPT_OPEN = 2;
}

@ -0,0 +1,51 @@
package com.yf.exam.core.exception;
import com.yf.exam.core.api.ApiError;
import com.yf.exam.core.api.ApiRest;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ServiceException extends RuntimeException{
/**
*
*/
private Integer code;
/**
*
*/
private String msg;
/**
*
* @param apiRest
*/
public ServiceException(ApiRest apiRest){
this.code = apiRest.getCode();
this.msg = apiRest.getMsg();
}
/**
*
* @param apiError
*/
public ServiceException(ApiError apiError){
this.code = apiError.getCode();
this.msg = apiError.msg;
}
/**
*
* @param msg
*/
public ServiceException(String msg){
this.code = 1;
this.msg = msg;
}
}

@ -0,0 +1,46 @@
package com.yf.exam.core.exception;
import com.yf.exam.core.api.ApiRest;
import org.springframework.http.HttpStatus;
import org.springframework.ui.Model;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;
/**
*
* @author bool
* @date 2019-06-21 19:27
*/
@RestControllerAdvice
public class ServiceExceptionHandler {
/**
* @RequestMapping
* @param binder
*/
@InitBinder
public void initWebBinder(WebDataBinder binder){
}
/**
* Model使@RequestMapping
* @param model
*/
@ModelAttribute
public void addAttribute(Model model) {
}
/**
* ServiceException
* @param e
* @return
*/
@ExceptionHandler({com.yf.exam.core.exception.ServiceException.class})
@ResponseStatus(HttpStatus.OK)
public ApiRest serviceExceptionHandler(ServiceException e) {
return new ApiRest(e);
}
}

@ -0,0 +1,59 @@
package com.yf.exam.core.utils;
import org.dozer.DozerBeanMapper;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* Dozer, Bean<->BeanMapper.:
*
* 1. Mapper.
* 2. .
* 3. Collection.
* 4. BAB.
*
*/
public class BeanMapper {
/**
* Dozer, DozerMapper.
*/
private static DozerBeanMapper dozerBeanMapper = new DozerBeanMapper();
/**
* Dozer.
*/
public static <T> T map(Object source, Class<T> destinationClass) {
return dozerBeanMapper.map(source, destinationClass);
}
/**
* DozerCollection.
*/
public static <T> List<T> mapList(Iterable<?> sourceList, Class<T> destinationClass) {
List<T> destinationList = new ArrayList();
for (Object sourceObject : sourceList) {
T destinationObject = dozerBeanMapper.map(sourceObject, destinationClass);
destinationList.add(destinationObject);
}
return destinationList;
}
/**
* DozerAB.
*/
public static void copy(Object source, Object destinationObject) {
if(source!=null) {
dozerBeanMapper.map(source, destinationObject);
}
}
public static <T, S> List<T> mapList(Collection<S> source, Function<? super S, ? extends T> mapper) {
return source.stream().map(mapper).collect(Collectors.toList());
}
}

@ -0,0 +1,31 @@
package com.yf.exam.core.utils;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* quartz
* @author bool
* @date 2020/11/29 3:00
*/
public class CronUtils {
/**
*
*/
private static final String DATE_FORMAT = "ss mm HH dd MM ? yyyy";
/**
*
* @param date
* @return
*/
public static String dateToCron(final Date date){
SimpleDateFormat fmt = new SimpleDateFormat(DATE_FORMAT);
String formatTimeStr = "";
if (date != null) {
formatTimeStr = fmt.format(date);
}
return formatTimeStr;
}
}

@ -0,0 +1,103 @@
package com.yf.exam.core.utils;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
/**
*
* ClassName: DateUtils <br/>
* date: 20181213 6:34:02 <br/>
*
* @author Bool
* @version
*/
public class DateUtils {
/**
*
* calcExpDays: <br/>
* @author Bool
* @param userCreateTime
* @return
* @since JDK 1.6
*/
public static int calcExpDays(Date userCreateTime){
Calendar start = Calendar.getInstance();
start.setTime(userCreateTime);
Calendar now = Calendar.getInstance();
now.setTime(new Date());
long l = now.getTimeInMillis() - start.getTimeInMillis();
int days = new Long(l / (1000 * 60 * 60 * 24)).intValue();
return days;
}
/**
*
* dateNow:. <br/>
* @author Bool
* @param format
* @return
*/
public static String dateNow(String format) {
SimpleDateFormat fmt = new SimpleDateFormat(format);
Calendar c = new GregorianCalendar();
return fmt.format(c.getTime());
}
/**
* formatDate: <br/>
* @author Bool
* @param time
* @param format
* @return
*/
public static String formatDate(Date time, String format) {
SimpleDateFormat fmt = new SimpleDateFormat(format);
return fmt.format(time.getTime());
}
/**
* parseDate:使yyyy-MM-dd HH:mm:ss
* @author Bool
* @param date
* @return
*/
public static Date parseDate(String date) {
return parseDate(date, "yyyy-MM-dd HH:mm:ss");
}
/**
*
* parseDate:使
* @author Bool
* @param date
* @param pattern
* @return
*/
public static Date parseDate(String date, String pattern) {
if (pattern==null) {
pattern = "yyyy-MM-dd HH:mm:ss";
}
SimpleDateFormat fmt = new SimpleDateFormat(pattern);
try {
return fmt.parse(date);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
}

@ -0,0 +1,65 @@
package com.yf.exam.core.utils;
import javax.servlet.http.HttpServletRequest;
/**
* IPIP
* ClassName: IpUtils <br/>
* date: 2018213 7:27:52 <br/>
*
* @author Bool
* @version
*/
public class IpUtils {
/**
*
* getClientIp:IP
* @author Bool
* @param request
* @return
*/
public static String extractClientIp(HttpServletRequest request) {
String ip = null;
//X-Forwarded-ForSquid 服务代理
String ipAddresses = request.getHeader("X-Forwarded-For");
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
//Proxy-Client-IPapache 服务代理
ipAddresses = request.getHeader("Proxy-Client-IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
//WL-Proxy-Client-IPweblogic 服务代理
ipAddresses = request.getHeader("WL-Proxy-Client-IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
//HTTP_CLIENT_IP有些代理服务器
ipAddresses = request.getHeader("HTTP_CLIENT_IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
//X-Real-IPnginx服务代理
ipAddresses = request.getHeader("X-Real-IP");
}
//有些网络通过多层代理那么获取到的ip就会有多个一般都是通过逗号,分割开来并且第一个ip为客户端的真实IP
if (ipAddresses != null && ipAddresses.length() != 0) {
ip = ipAddresses.split(",")[0];
}
//还是不能获取到最后再通过request.getRemoteAddr();获取
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ip = request.getRemoteAddr();
}
return ip;
}
}

@ -0,0 +1,324 @@
/**
* Copyright (c) 2005-2012 springside.org.cn
*/
package com.yf.exam.core.utils;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.springframework.util.Assert;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* .
* getter/setter, 访, , Class, AOP.
* @author calvin
* @version 2016-01-15
*/
@Log4j2
public class Reflections {
private static final String SETTER_PREFIX = "set";
private static final String GETTER_PREFIX = "get";
private static final String CGLIB_CLASS_SEPARATOR = "$$";
/**
*
*
* @param object
* @return
*/
public static Field[] getAllFields(Object object) {
Class<?> clazz = object.getClass();
List<Field> fieldList = new ArrayList<>();
while (clazz != null) {
fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
clazz = clazz.getSuperclass();
}
Field[] fields = new Field[fieldList.size()];
fieldList.toArray(fields);
return fields;
}
/**
* Getter.
* ..
*/
public static Object invokeGetter(Object obj, String propertyName) {
Object object = obj;
for (String name : StringUtils.split(propertyName, ".")){
String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name);
object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
}
return object;
}
/**
* Setter,
* ..
*/
public static void invokeSetter(Object obj, String propertyName, Object value) {
Object object = obj;
String[] names = StringUtils.split(propertyName, ".");
for (int i=0; i<names.length; i++){
if(i<names.length-1){
String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(names[i]);
object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
}else{
String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(names[i]);
invokeMethodByName(object, setterMethodName, new Object[] { value });
}
}
}
/**
* , private/protected, getter.
*/
public static Object getFieldValue(final Object obj, final String fieldName) {
Field field = getAccessibleField(obj, fieldName);
if (field == null) {
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
}
Object result = null;
try {
result = field.get(obj);
} catch (IllegalAccessException e) {
log.error("不可能抛出的异常{}", e.getMessage());
}
return result;
}
/**
* , private/protected, setter.
*/
public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
Field field = getAccessibleField(obj, fieldName);
if (field == null) {
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
}
try {
field.set(obj, value);
} catch (IllegalAccessException e) {
log.error("不可能抛出的异常:{}", e.getMessage());
}
}
/**
* , private/protected.
* 使getAccessibleMethod()Method.
* +
*/
public static Object invokeMethod(final Object obj, final String methodName, final Class<?>[] parameterTypes,
final Object[] args) {
Method method = getAccessibleMethod(obj, methodName, parameterTypes);
if (method == null) {
throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
}
try {
return method.invoke(obj, args);
} catch (Exception e) {
throw convertReflectionExceptionToUnchecked(e);
}
}
/**
* , private/protected
* 使getAccessibleMethodByName()Method.
*
*/
public static Object invokeMethodByName(final Object obj, final String methodName, final Object[] args) {
Method method = getAccessibleMethodByName(obj, methodName);
if (method == null) {
throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
}
try {
return method.invoke(obj, args);
} catch (Exception e) {
throw convertReflectionExceptionToUnchecked(e);
}
}
/**
* , DeclaredField, 访.
*
* Object, null.
*/
public static Field getAccessibleField(final Object obj, final String fieldName) {
Validate.notNull(obj, "object can't be null");
Validate.notBlank(fieldName, "fieldName can't be blank");
for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()) {
try {
Field field = superClass.getDeclaredField(fieldName);
makeAccessible(field);
return field;
} catch (NoSuchFieldException e) {//NOSONAR
// Field不在当前类定义,继续向上转型
continue;// new add
}
}
return null;
}
/**
* , DeclaredMethod,访.
* Object, null.
* +
*
* . 使Method,Method.invoke(Object obj, Object... args)
*/
public static Method getAccessibleMethod(final Object obj, final String methodName,
final Class<?>... parameterTypes) {
Validate.notNull(obj, "object can't be null");
Validate.notBlank(methodName, "methodName can't be blank");
for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
try {
Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
makeAccessible(method);
return method;
} catch (NoSuchMethodException e) {
// Method不在当前类定义,继续向上转型
continue;// new add
}
}
return null;
}
/**
* , DeclaredMethod,访.
* Object, null.
*
*
* . 使Method,Method.invoke(Object obj, Object... args)
*/
public static Method getAccessibleMethodByName(final Object obj, final String methodName) {
Validate.notNull(obj, "object can't be null");
Validate.notBlank(methodName, "methodName can't be blank");
for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
Method[] methods = searchType.getDeclaredMethods();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
makeAccessible(method);
return method;
}
}
}
return null;
}
/**
* private/protectedpublicJDKSecurityManager
*/
public static void makeAccessible(Method method) {
if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
&& !method.isAccessible()) {
method.setAccessible(true);
}
}
/**
* private/protectedpublicJDKSecurityManager
*/
public static void makeAccessible(Field field) {
if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers()) || Modifier
.isFinal(field.getModifiers())) && !field.isAccessible()) {
field.setAccessible(true);
}
}
/**
* , Class,
* , Object.class.
* eg.
* public UserDao extends HibernateDao<User>
*
* @param clazz The class to introspect
* @return the first generic declaration, or Object.class if cannot be determined
*/
@SuppressWarnings("unchecked")
public static <T> Class<T> getClassGenricType(final Class clazz) {
return getClassGenricType(clazz, 0);
}
/**
* , Class.
* , Object.class.
*
* public UserDao extends HibernateDao<User,Long>
*
* @param clazz clazz The class to introspect
* @param index the Index of the generic ddeclaration,start from 0.
* @return the index generic declaration, or Object.class if cannot be determined
*/
public static Class getClassGenricType(final Class clazz, final int index) {
Type genType = clazz.getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
log.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
return Object.class;
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index >= params.length || index < 0) {
log.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
+ params.length);
return Object.class;
}
if (!(params[index] instanceof Class)) {
log.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
return Object.class;
}
return (Class) params[index];
}
public static Class<?> getUserClass(Object instance) {
Assert.notNull(instance, "Instance must not be null");
Class clazz = instance.getClass();
if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
Class<?> superClass = clazz.getSuperclass();
if (superClass != null && !Object.class.equals(superClass)) {
return superClass;
}
}
return clazz;
}
/**
* checked exceptionunchecked exception.
*/
public static RuntimeException convertReflectionExceptionToUnchecked(Exception e) {
if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException
|| e instanceof NoSuchMethodException) {
return new IllegalArgumentException(e);
} else if (e instanceof InvocationTargetException) {
return new RuntimeException(((InvocationTargetException) e).getTargetException());
} else if (e instanceof RuntimeException) {
return (RuntimeException) e;
}
return new RuntimeException("Unexpected Checked Exception.", e);
}
}

@ -0,0 +1,32 @@
package com.yf.exam.core.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* Spring
*
* @author bool
* @date 2019-12-09 15:55
*/
@Component
public class SpringUtils implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
applicationContext = context;
}
public static <T> T getBean(Class<T> tClass) {
return applicationContext.getBean(tClass);
}
public static <T> T getBean(String name, Class<T> type) {
return applicationContext.getBean(name, type);
}
}

@ -0,0 +1,39 @@
package com.yf.exam.core.utils;
import java.util.Map;
/**
*
* @author bool
* @date 2019-05-15 11:40
*/
public class StringUtils {
/**
*
* @param str
* @return
*/
public static boolean isBlank(String str){
return str==null || "".equals(str);
}
/**
* MAPxml<xml><key>value</key>...</xml>
* @param params
* @return
*/
public static String mapToXml(Map<String, String> params){
StringBuffer sb = new StringBuffer("<xml>");
for(String key:params.keySet()){
sb.append("<")
.append(key).append(">")
.append(params.get(key))
.append("</").append(key).append(">");
}
sb.append("</xml>");
return sb.toString();
}
}

@ -0,0 +1,402 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel;
import com.google.common.collect.Lists;
import com.yf.exam.core.utils.Reflections;
import com.yf.exam.core.utils.excel.annotation.ExcelField;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.DataFormat;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URLEncoder;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* ExcelXLSX @see org.apache.poi.ss.SpreadsheetVersion
* @author jeeplus
* @version 2016-04-21
*/
public class ExportExcel {
private static Logger log = LoggerFactory.getLogger(ExportExcel.class);
/**
*
*/
private SXSSFWorkbook wb;
/**
*
*/
private Sheet sheet;
/**
*
*/
private Map<String, CellStyle> styles;
/**
*
*/
private int rownum;
/**
* Object[]{ ExcelField, Field/Method }
*/
List<Object[]> annotationList = Lists.newArrayList();
/**
*
* @param title
* @param cls annotation.ExportField
*/
public ExportExcel(String title, Class<?> cls){
this(title, cls, 1);
}
/**
*
* @param title
* @param cls annotation.ExportField
* @param type 1:2
* @param groups
*/
public ExportExcel(String title, Class<?> cls, int type, int... groups){
// Get annotation field
Field[] fs = cls.getDeclaredFields();
for (Field f : fs){
ExcelField ef = f.getAnnotation(ExcelField.class);
if (ef != null && (ef.type()==0 || ef.type()==type)){
if (groups!=null && groups.length>0){
boolean inGroup = false;
for (int g : groups){
if (inGroup){
break;
}
for (int efg : ef.groups()){
if (g == efg){
inGroup = true;
annotationList.add(new Object[]{ef, f});
break;
}
}
}
}else{
annotationList.add(new Object[]{ef, f});
}
}
}
// Get annotation method
Method[] ms = cls.getDeclaredMethods();
for (Method m : ms){
ExcelField ef = m.getAnnotation(ExcelField.class);
if (ef != null && (ef.type()==0 || ef.type()==type)){
if (groups!=null && groups.length>0){
boolean inGroup = false;
for (int g : groups){
if (inGroup){
break;
}
for (int efg : ef.groups()){
if (g == efg){
inGroup = true;
annotationList.add(new Object[]{ef, m});
break;
}
}
}
}else{
annotationList.add(new Object[]{ef, m});
}
}
}
// Field sorting
Collections.sort(annotationList, new Comparator<Object[]>() {
@Override
public int compare(Object[] o1, Object[] o2) {
return new Integer(((ExcelField)o1[0]).sort()).compareTo(
new Integer(((ExcelField)o2[0]).sort()));
}
});
// Initialize
List<String> headerList = Lists.newArrayList();
for (Object[] os : annotationList){
String t = ((ExcelField)os[0]).title();
// 如果是导出,则去掉注释
if (type==1){
String[] ss = StringUtils.split(t, "**", 2);
if (ss.length==2){
t = ss[0];
}
}
headerList.add(t);
}
initialize(title, headerList);
}
/**
*
* @param title
* @param headerList
*/
private void initialize(String title, List<String> headerList) {
this.wb = new SXSSFWorkbook(500);
this.sheet = wb.createSheet("Export");
this.styles = createStyles(wb);
// Create title
if (StringUtils.isNotBlank(title)){
Row titleRow = sheet.createRow(rownum++);
titleRow.setHeightInPoints(30);
Cell titleCell = titleRow.createCell(0);
titleCell.setCellStyle(styles.get("title"));
titleCell.setCellValue(title);
sheet.addMergedRegion(new CellRangeAddress(titleRow.getRowNum(),
titleRow.getRowNum(), titleRow.getRowNum(), headerList.size()-1));
}
// Create header
if (headerList == null){
throw new RuntimeException("headerList not null!");
}
Row headerRow = sheet.createRow(rownum++);
headerRow.setHeightInPoints(16);
for (int i = 0; i < headerList.size(); i++) {
Cell cell = headerRow.createCell(i);
cell.setCellStyle(styles.get("header"));
String[] ss = StringUtils.split(headerList.get(i), "**", 2);
if (ss.length==2){
cell.setCellValue(ss[0]);
Comment comment = this.sheet.createDrawingPatriarch().createCellComment(
new XSSFClientAnchor(0, 0, 0, 0, (short) 3, 3, (short) 5, 6));
comment.setString(new XSSFRichTextString(ss[1]));
cell.setCellComment(comment);
}else{
cell.setCellValue(headerList.get(i));
}
sheet.autoSizeColumn(i);
}
for (int i = 0; i < headerList.size(); i++) {
int colWidth = sheet.getColumnWidth(i)*2;
sheet.setColumnWidth(i, colWidth < 3000 ? 3000 : colWidth);
}
log.debug("Initialize success.");
}
/**
*
* @param wb
* @return
*/
private Map<String, CellStyle> createStyles(Workbook wb) {
Map<String, CellStyle> styles = new HashMap<>(16);
CellStyle style = wb.createCellStyle();
style.setAlignment(CellStyle.ALIGN_CENTER);
style.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
Font titleFont = wb.createFont();
titleFont.setFontName("Arial");
titleFont.setFontHeightInPoints((short) 16);
titleFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
style.setFont(titleFont);
styles.put("title", style);
style = wb.createCellStyle();
style.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
style.setBorderRight(CellStyle.BORDER_THIN);
style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
style.setBorderLeft(CellStyle.BORDER_THIN);
style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
style.setBorderTop(CellStyle.BORDER_THIN);
style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
style.setBorderBottom(CellStyle.BORDER_THIN);
style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
Font dataFont = wb.createFont();
dataFont.setFontName("Arial");
dataFont.setFontHeightInPoints((short) 10);
style.setFont(dataFont);
styles.put("data", style);
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(CellStyle.ALIGN_LEFT);
styles.put("data1", style);
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(CellStyle.ALIGN_CENTER);
styles.put("data2", style);
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(CellStyle.ALIGN_RIGHT);
styles.put("data3", style);
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
// style.setWrapText(true);
style.setAlignment(CellStyle.ALIGN_CENTER);
style.setFillForegroundColor(IndexedColors.GREY_50_PERCENT.getIndex());
style.setFillPattern(CellStyle.SOLID_FOREGROUND);
Font headerFont = wb.createFont();
headerFont.setFontName("Arial");
headerFont.setFontHeightInPoints((short) 10);
headerFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
headerFont.setColor(IndexedColors.WHITE.getIndex());
style.setFont(headerFont);
styles.put("header", style);
return styles;
}
/**
*
* @return
*/
public Row addRow(){
return sheet.createRow(rownum++);
}
/**
*
* @param row
* @param column
* @param val
* @return
*/
public Cell addCell(Row row, int column, Object val){
return this.addCell(row, column, val, 0, Class.class);
}
/**
*
* @param row
* @param column
* @param val
* @param align 123
* @return
*/
public Cell addCell(Row row, int column, Object val, int align, Class<?> fieldType){
Cell cell = row.createCell(column);
CellStyle style = styles.get("data"+(align>=1&&align<=3?align:""));
try {
if (val == null){
cell.setCellValue("");
} else if (val instanceof String) {
cell.setCellValue((String) val);
} else if (val instanceof Integer) {
cell.setCellValue((Integer) val);
} else if (val instanceof Long) {
cell.setCellValue((Long) val);
} else if (val instanceof Double) {
cell.setCellValue((Double) val);
} else if (val instanceof Float) {
cell.setCellValue((Float) val);
} else if (val instanceof Date) {
DataFormat format = wb.createDataFormat();
style.setDataFormat(format.getFormat("yyyy-MM-dd"));
cell.setCellValue((Date) val);
} else {
if (fieldType != Class.class){
cell.setCellValue((String)fieldType.getMethod("setValue", Object.class).invoke(null, val));
}else{
cell.setCellValue((String)Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(),
"fieldtype."+val.getClass().getSimpleName()+"Type")).getMethod("setValue", Object.class).invoke(null, val));
}
}
} catch (Exception ex) {
log.info("Set cell value ["+row.getRowNum()+","+column+"] error: " + ex.toString());
cell.setCellValue(val.toString());
}
cell.setCellStyle(style);
return cell;
}
/**
* annotation.ExportField
* @return list
*/
public <E> ExportExcel setDataList(List<E> list){
for (E e : list){
int colunm = 0;
Row row = this.addRow();
StringBuilder sb = new StringBuilder();
for (Object[] os : annotationList){
ExcelField ef = (ExcelField)os[0];
Object val = null;
try{
if (StringUtils.isNotBlank(ef.value())){
val = Reflections.invokeGetter(e, ef.value());
}else{
if (os[1] instanceof Field){
val = Reflections.invokeGetter(e, ((Field)os[1]).getName());
}else if (os[1] instanceof Method){
val = Reflections.invokeMethod(e, ((Method)os[1]).getName(), new Class[] {}, new Object[] {});
}
}
}catch(Exception ex) {
log.info(ex.toString());
val = "";
}
this.addCell(row, colunm++, val, ef.align(), ef.fieldType());
sb.append(val + ", ");
}
log.debug("Write success: ["+row.getRowNum()+"] "+sb.toString());
}
return this;
}
/**
*
* @param os
*/
public ExportExcel write(OutputStream os) throws IOException{
wb.write(os);
return this;
}
/**
*
* @param fileName
*/
public ExportExcel write(HttpServletResponse response, String fileName) throws IOException{
response.reset();
response.setHeader("Access-Control-Allow-Origin", "*");
response.setContentType("application/octet-stream; charset=utf-8");
response.addHeader("Content-Disposition", "attachment; filename="+ URLEncoder.encode(fileName, "utf-8"));
write(response.getOutputStream());
return this;
}
/**
*
*/
public ExportExcel dispose(){
wb.dispose();
return this;
}
}

@ -0,0 +1,303 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel;
import com.google.common.collect.Lists;
import com.yf.exam.core.utils.Reflections;
import com.yf.exam.core.utils.excel.annotation.ExcelField;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
/**
* ExcelXLSXLSX
* @author jeeplus
* @version 2016-03-10
*/
public class ImportExcel {
private static Logger log = LoggerFactory.getLogger(ImportExcel.class);
/**
*
*/
private Workbook wb;
/**
*
*/
private Sheet sheet;
/**
*
*/
private int headerNum;
/**
*
* @param multipartFile
* @param headerNum =+1
* @param sheetIndex
* @throws InvalidFormatException
* @throws IOException
*/
public ImportExcel(MultipartFile multipartFile, int headerNum, int sheetIndex)
throws InvalidFormatException, IOException {
this(multipartFile.getOriginalFilename(), multipartFile.getInputStream(), headerNum, sheetIndex);
}
/**
*
* @param is
* @param headerNum =+1
* @param sheetIndex
* @throws InvalidFormatException
* @throws IOException
*/
public ImportExcel(String fileName, InputStream is, int headerNum, int sheetIndex)
throws IOException {
if (StringUtils.isBlank(fileName)){
throw new RuntimeException("导入文档为空!");
}else if(fileName.toLowerCase().endsWith("xls")){
this.wb = new HSSFWorkbook(is);
}else if(fileName.toLowerCase().endsWith("xlsx")){
this.wb = new XSSFWorkbook(is);
}else{
throw new RuntimeException("文档格式不正确!");
}
if (this.wb.getNumberOfSheets()<sheetIndex){
throw new RuntimeException("文档中没有工作表!");
}
this.sheet = this.wb.getSheetAt(sheetIndex);
this.headerNum = headerNum;
log.debug("Initialize success.");
}
/**
*
* @param rownum
* @return
*/
public Row getRow(int rownum){
return this.sheet.getRow(rownum);
}
/**
*
* @return
*/
public int getDataRowNum(){
return headerNum+1;
}
/**
*
* @return
*/
public int getLastDataRowNum(){
return this.sheet.getLastRowNum()+headerNum;
}
/**
*
* @param row
* @param column
* @return
*/
public Object getCellValue(Row row, int column) {
Object val = "";
try {
Cell cell = row.getCell(column);
if (cell != null) {
if (cell.getCellType() == Cell.CELL_TYPE_NUMERIC) {
// 当excel 中的数据为数值或日期是需要特殊处理
if (HSSFDateUtil.isCellDateFormatted(cell)) {
double d = cell.getNumericCellValue();
Date date = HSSFDateUtil.getJavaDate(d);
SimpleDateFormat dformat = new SimpleDateFormat(
"yyyy-MM-dd");
val = dformat.format(date);
} else {
NumberFormat nf = NumberFormat.getInstance();
nf.setGroupingUsed(false);// true时的格式1,234,567,890
val = nf.format(cell.getNumericCellValue());// 数值类型的数据为double所以需要转换一下
}
} else if (cell.getCellType() == Cell.CELL_TYPE_STRING) {
val = cell.getStringCellValue();
} else if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) {
val = cell.getCellFormula();
} else if (cell.getCellType() == Cell.CELL_TYPE_BOOLEAN) {
val = cell.getBooleanCellValue();
} else if (cell.getCellType() == Cell.CELL_TYPE_ERROR) {
val = cell.getErrorCellValue();
}
}
} catch (Exception e) {
return val;
}
return val;
}
/**
*
* @param cls
* @param groups
*/
public <E> List<E> getDataList(Class<E> cls, int... groups) throws InstantiationException, IllegalAccessException{
List<Object[]> annotationList = Lists.newArrayList();
// Get annotation field
Field[] fs = cls.getDeclaredFields();
for (Field f : fs){
ExcelField ef = f.getAnnotation(ExcelField.class);
if (ef != null && (ef.type()==0 || ef.type()==2)){
if (groups!=null && groups.length>0){
boolean inGroup = false;
for (int g : groups){
if (inGroup){
break;
}
for (int efg : ef.groups()){
if (g == efg){
inGroup = true;
annotationList.add(new Object[]{ef, f});
break;
}
}
}
}else{
annotationList.add(new Object[]{ef, f});
}
}
}
// Get annotation method
Method[] ms = cls.getDeclaredMethods();
for (Method m : ms){
ExcelField ef = m.getAnnotation(ExcelField.class);
if (ef != null && (ef.type()==0 || ef.type()==2)){
if (groups!=null && groups.length>0){
boolean inGroup = false;
for (int g : groups){
if (inGroup){
break;
}
for (int efg : ef.groups()){
if (g == efg){
inGroup = true;
annotationList.add(new Object[]{ef, m});
break;
}
}
}
}else{
annotationList.add(new Object[]{ef, m});
}
}
}
// Field sorting
Collections.sort(annotationList, new Comparator<Object[]>() {
@Override
public int compare(Object[] o1, Object[] o2) {
return new Integer(((ExcelField)o1[0]).sort()).compareTo(
new Integer(((ExcelField)o2[0]).sort()));
}
});
// Get excel data
List<E> dataList = Lists.newArrayList();
for (int i = this.getDataRowNum(); i < this.getLastDataRowNum(); i++) {
E e = (E)cls.newInstance();
int column = 0;
Row row = this.getRow(i);
StringBuilder sb = new StringBuilder();
for (Object[] os : annotationList){
Object val = this.getCellValue(row, column++);
if (val != null){
ExcelField ef = (ExcelField)os[0];
// Get param type and type cast
Class<?> valType = Class.class;
if (os[1] instanceof Field){
valType = ((Field)os[1]).getType();
}else if (os[1] instanceof Method){
Method method = ((Method)os[1]);
if ("get".equals(method.getName().substring(0, 3))){
valType = method.getReturnType();
}else if("set".equals(method.getName().substring(0, 3))){
valType = ((Method)os[1]).getParameterTypes()[0];
}
}
//log.debug("Import value type: ["+i+","+column+"] " + valType);
try {
//如果导入的java对象需要在这里自己进行变换。
if (valType == String.class){
String s = String.valueOf(val.toString());
if(StringUtils.endsWith(s, ".0")){
val = StringUtils.substringBefore(s, ".0");
}else{
val = String.valueOf(val.toString());
}
}else if (valType == Integer.class){
val = Double.valueOf(val.toString()).intValue();
}else if (valType == Long.class){
val = Double.valueOf(val.toString()).longValue();
}else if (valType == Double.class){
val = Double.valueOf(val.toString());
}else if (valType == Float.class){
val = Float.valueOf(val.toString());
}else if (valType == Date.class){
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
val=sdf.parse(val.toString());
}else{
if (ef.fieldType() != Class.class){
val = ef.fieldType().getMethod("getValue", String.class).invoke(null, val.toString());
}else{
val = Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(),
"fieldtype."+valType.getSimpleName()+"Type")).getMethod("getValue", String.class).invoke(null, val.toString());
}
}
} catch (Exception ex) {
log.info("Get cell value ["+i+","+column+"] error: " + ex.toString());
val = null;
}
// set entity value
if (os[1] instanceof Field){
Reflections.invokeSetter(e, ((Field)os[1]).getName(), val);
}else if (os[1] instanceof Method){
String mthodName = ((Method)os[1]).getName();
if ("get".equals(mthodName.substring(0, 3))){
mthodName = "set"+StringUtils.substringAfter(mthodName, "get");
}
Reflections.invokeMethod(e, mthodName, new Class[] {valType}, new Object[] {val});
}
}
sb.append(val+", ");
}
dataList.add(e);
log.debug("Read success: ["+i+"] "+sb.toString());
}
return dataList;
}
}

@ -0,0 +1,59 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Excel
* @author jeeplus
* @version 2016-03-10
*/
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcelField {
/**
* get.area.nameoffice.name
*/
String value() default "";
/**
* ****
*/
String title();
/**
* 012
*/
int type() default 0;
/**
* 0123
*/
int align() default 0;
/**
*
*/
int sort() default 0;
/**
* type
*/
String dictType() default "";
/**
*
*/
Class<?> fieldType() default Class.class;
/**
*
*/
int[] groups() default {};
}

@ -0,0 +1,56 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel.fieldtype;
import com.google.common.collect.Lists;
import com.yf.exam.core.utils.StringUtils;
import java.util.List;
/**
*
* @author jeeplus
* @version 2016-5-29
*/
public class ListType {
/**
*
*/
public static Object getValue(String val) {
List<String> list = Lists.newArrayList();
if(!StringUtils.isBlank(val)) {
for (String s : val.split(",")) {
list.add(s);
}
}
return list;
}
/**
*
*/
public static String setValue(Object val) {
if (val != null){
List<String> list = (List<String>)val;
StringBuffer sb = null;
for (String item: list){
if(StringUtils.isBlank(item)){
continue;
}
if(sb == null){
sb = new StringBuffer(item);
}else{
sb.append(",").append(item);
}
}
if(sb!=null) {
return sb.toString().replace("[]", "");
}
}
return "";
}
}

@ -0,0 +1,37 @@
package com.yf.exam.core.utils.file;
import java.security.MessageDigest;
/**
* MD5
* ClassName: MD5Util <br/>
* date: 2018113 6:54:53 <br/>
*
* @author Bool
* @version
*/
public class Md5Util {
/**
* MD5
* @param str
* @return
*/
public static String md5(String str) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] array = md.digest(str.getBytes("UTF-8"));
StringBuilder sb = new StringBuilder();
for (byte item : array) {
sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
}
return sb.toString();
}catch(Exception e) {
return null;
}
}
}

@ -0,0 +1,57 @@
package com.yf.exam.core.utils.passwd;
import com.yf.exam.core.utils.file.Md5Util;
import org.apache.commons.lang3.RandomStringUtils;
/**
*
* ClassName: PassGenerator <br/>
* date: 20171213 7:13:03 <br/>
*
* @author Bool
* @version
*/
public class PassHandler {
/**
* checkPass:
* @author Bool
* @param inputPass
* @param salt
* @param pass MD5
* @return
*/
public static boolean checkPass(String inputPass , String salt , String pass){
String pwdMd5 = Md5Util.md5(inputPass);
return Md5Util.md5(pwdMd5 + salt).equals(pass);
}
/**
*
* buildPassword:
* @author Bool
* @param inputPass
* @return PassInfo
*/
public static PassInfo buildPassword(String inputPass) {
//产生一个6位数的随机码
String salt = RandomStringUtils.randomAlphabetic(6);
//加密后的密码
String encryptPassword = Md5Util.md5(Md5Util.md5(inputPass)+salt);
//返回对象
return new PassInfo(salt,encryptPassword);
}
public static void main(String[] args) {
PassInfo info = buildPassword("190601");
System.out.println(info.getPassword());
System.out.println(info.getSalt());
}
}

@ -0,0 +1,38 @@
package com.yf.exam.core.utils.passwd;
/**
*
* ClassName: PassInfo <br/>
* date: 2018213 7:13:50 <br/>
*
* @author Bool
* @version
*/
public class PassInfo {
//密码随机串码
private String salt;
//MD5后的密码
private String password;
public PassInfo(String salt, String password) {
super();
this.salt = salt;
this.password = password;
}
public String getSalt() {
return salt;
}
public void setSalt(String salt) {
this.salt = salt;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}

@ -0,0 +1,14 @@
package com.yf.exam.modules;
/**
*
* @author bool
*/
public class Constant {
/**
*
*/
public static final String TOKEN = "token";
}

@ -0,0 +1,144 @@
package com.yf.exam.modules.exam.controller; // 定义包名,控制器所在的包路径
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入MyBatis Plus的查询包装类
import com.baomidou.mybatisplus.core.metadata.IPage; // 导入MyBatis Plus的分页接口
import com.yf.exam.core.api.ApiRest; // 导入自定义的API响应类
import com.yf.exam.core.api.controller.BaseController; // 导入基控制器类
import com.yf.exam.core.api.dto.BaseIdReqDTO; // 导入基础ID请求数据传输对象
import com.yf.exam.core.api.dto.BaseIdsReqDTO; // 导入基础IDs请求数据传输对象
import com.yf.exam.core.api.dto.BaseStateReqDTO; // 导入基础状态请求数据传输对象
import com.yf.exam.core.api.dto.PagingReqDTO; // 导入分页请求数据传输对象
import com.yf.exam.modules.exam.dto.ExamDTO; // 导入考试DTO
import com.yf.exam.modules.exam.dto.request.ExamSaveReqDTO; // 导入考试保存请求DTO
import com.yf.exam.modules.exam.dto.response.ExamOnlineRespDTO; // 导入在线考试响应DTO
import com.yf.exam.modules.exam.dto.response.ExamReviewRespDTO; // 导入考试审核响应DTO
import com.yf.exam.modules.exam.entity.Exam; // 导入考试实体类
import com.yf.exam.modules.exam.service.ExamService; // 导入考试服务接口
import io.swagger.annotations.Api; // 导入Swagger注解
import io.swagger.annotations.ApiOperation; // 导入Swagger操作注解
import org.apache.shiro.authz.annotation.RequiresRoles; // 导入Shiro权限注解
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动注入注解
import org.springframework.web.bind.annotation.RequestBody; // 导入Spring MVC的请求体注解
import org.springframework.web.bind.annotation.RequestMapping; // 导入Spring MVC的请求映射注解
import org.springframework.web.bind.annotation.RequestMethod; // 导入Spring MVC的请求方法注解
import org.springframework.web.bind.annotation.RestController; // 导入Spring MVC的控制器注解
import java.util.Date; // 导入Java的日期类
/**
* <p>
*
* </p>
*
* @author
* @since 2020-07-25 16:18
*/
@Api(tags={"考试"}) // Swagger注解定义API的标签
@RestController // Spring MVC注解声明这是一个REST控制器
@RequestMapping("/exam/api/exam/exam") // Spring MVC注解定义请求的基础路径
public class ExamController extends BaseController { // 声明控制器类,继承自基控制器
@Autowired
private ExamService baseService; // 自动注入考试服务
/**
*
* @param reqDTO
* @return ApiRest
*/
@RequiresRoles("sa") // Shiro权限注解要求角色为"sa"(超级管理员)
@ApiOperation(value = "添加或修改") // Swagger注解定义操作的描述
@RequestMapping(value = "/save", method = { RequestMethod.POST}) // Spring MVC注解定义请求的映射和方法
public ApiRest save(@RequestBody ExamSaveReqDTO reqDTO) { // 定义添加或修改考试的方法
// 复制参数并保存
baseService.save(reqDTO); // 调用服务层保存考试信息
return super.success(); // 返回成功响应
}
/**
*
* @param reqDTO ID
* @return ApiRest
*/
@RequiresRoles("sa") // Shiro权限注解要求角色为"sa"(超级管理员)
@ApiOperation(value = "批量删除") // Swagger注解定义操作的描述
@RequestMapping(value = "/delete", method = { RequestMethod.POST}) // Spring MVC注解定义请求的映射和方法
public ApiRest edit(@RequestBody BaseIdsReqDTO reqDTO) { // 定义批量删除考试的方法
// 根据ID删除考试
baseService.removeByIds(reqDTO.getIds()); // 调用服务层根据ID列表删除考试
return super.success(); // 返回成功响应
}
/**
*
* @param reqDTO ID
* @return ApiRest<ExamSaveReqDTO>
*/
@ApiOperation(value = "查找详情") // Swagger注解定义操作的描述
@RequestMapping(value = "/detail", method = { RequestMethod.POST}) // Spring MVC注解定义请求的映射和方法
public ApiRest<ExamSaveReqDTO> find(@RequestBody BaseIdReqDTO reqDTO) { // 定义查找考试详情的方法
ExamSaveReqDTO dto = baseService.findDetail(reqDTO.getId()); // 调用服务层查找考试详情
return super.success(dto); // 返回成功响应和考试详情
}
/**
*
* @param reqDTO ID
* @return ApiRest
*/
@RequiresRoles("sa") // Shiro权限注解要求角色为"sa"(超级管理员)
@ApiOperation(value = "更新考试状态") // Swagger注解定义操作的描述
@RequestMapping(value = "/state", method = { RequestMethod.POST}) // Spring MVC注解定义请求的映射和方法
public ApiRest state(@RequestBody BaseStateReqDTO reqDTO) { // 定义更新考试状态的方法
// 创建查询条件
QueryWrapper<Exam> wrapper = new QueryWrapper<>();
wrapper.lambda().in(Exam::getId, reqDTO.getIds()); // 构造查询条件查询指定ID的考试
Exam exam = new Exam(); // 创建考试实体
exam.setState(reqDTO.getState()); // 设置新状态
exam.setUpdateTime(new Date()); // 设置更新时间为当前时间
baseService.update(exam, wrapper); // 调用服务层更新考试状态
return super.success(); // 返回成功响应
}
/**
*
* @param reqDTO
* @return ApiRest<IPage<ExamOnlineRespDTO>>
*/
@ApiOperation(value = "考试视角") // Swagger注解定义操作的描述
@RequestMapping(value = "/online-paging", method = { RequestMethod.POST}) // Spring MVC注解定义请求的映射和方法
public ApiRest<IPage<ExamOnlineRespDTO>> myPaging(@RequestBody PagingReqDTO<ExamDTO> reqDTO) { // 定义分页查找考试的方法
// 分页查询并转换
IPage<ExamOnlineRespDTO> page = baseService.onlinePaging(reqDTO); // 调用服务层进行分页查询
return super.success(page); // 返回成功响应和分页结果
}
/**
*
* @param reqDTO
* @return ApiRest<IPage<ExamDTO>>
*/
@RequiresRoles("sa") // Shiro权限注解要求角色为"sa"(超级管理员)
@ApiOperation(value = "分页查找") // Swagger注解定义操作的描述
@RequestMapping(value = "/paging", method = { RequestMethod.POST}) // Spring MVC注解定义请求的映射和方法
public ApiRest<IPage<ExamDTO>> paging(@RequestBody PagingReqDTO<ExamDTO> reqDTO) { // 定义分页查找考试的方法
// 分页查询并转换
IPage<ExamDTO> page = baseService.paging(reqDTO); // 调用服务层进行分页查询
return super.success(page); // 返回成功响应和分页结果
}
/**
*
* @param reqDTO
* @return ApiRest<IPage<ExamReviewRespDTO>>
*/
@RequiresRoles("sa") // Shiro权限注解要求角色为"sa"(超级管理员)
@ApiOperation(value = "待阅试卷") // Swagger注解定义操作的描述
@RequestMapping(value = "/review-paging", method = { RequestMethod.POST}) // Spring MVC注解定义请求的映射和方法
public ApiRest<IPage<ExamReviewRespDTO>> reviewPaging(@RequestBody PagingReqDTO<ExamDTO> reqDTO) { // 定义分页查找待阅试卷的方法
// 分页查询并转换
IPage<ExamReviewRespDTO> page = baseService.reviewPaging(reqDTO); // 调用服务层进行分页查询
return super.success(page); // 返回成功响应和分页结果
}
}

@ -0,0 +1,93 @@
package com.yf.exam.modules.exam.dto; // 定义包名DTO类所在的包路径
import com.fasterxml.jackson.annotation.JsonFormat; // 导入Jackson库的注解用于格式化日期
import com.yf.exam.modules.paper.enums.ExamState; // 导入考试状态枚举
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于描述模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于描述模型属性
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
import org.springframework.format.annotation.DateTimeFormat; // 导入Spring的日期格式化注解
import java.io.Serializable; // 导入Java的序列化接口用于确保对象可以被序列化
import java.util.Date; // 导入Java的日期类
/**
* <p>
*
* </p>
* 便
*
* @author
* @since 2020-07-25 16:18
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@ApiModel(value="考试", description="考试") // Swagger注解描述这个类的用途
public class ExamDTO implements Serializable { // 声明类实现Serializable接口以确保可以序列化
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的版本唯一性
@ApiModelProperty(value = "ID", required=true) // Swagger注解描述字段的用途和是否必填
private String id; // 考试ID
@ApiModelProperty(value = "考试名称", required=true) // Swagger注解描述字段的用途和是否必填
private String title; // 考试名称
@ApiModelProperty(value = "考试描述", required=true) // Swagger注解描述字段的用途和是否必填
private String content; // 考试描述
@ApiModelProperty(value = "1公开2部门3定员", required=true) // Swagger注解描述字段的用途和是否必填
private Integer openType; // 开放类型1表示公开2表示部门3表示定员
@ApiModelProperty(value = "考试状态", required=true) // Swagger注解描述字段的用途和是否必填
private Integer state; // 考试状态
@ApiModelProperty(value = "是否限时", required=true) // Swagger注解描述字段的用途和是否必填
private Boolean timeLimit; // 是否限时
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd") // Jackson注解格式化日期
@DateTimeFormat(pattern = "yyyy-MM-dd") // Spring注解格式化日期
@ApiModelProperty(value = "开始时间", required=true) // Swagger注解描述字段的用途和是否必填
private Date startTime; // 考试开始时间
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd") // Jackson注解格式化日期
@DateTimeFormat(pattern = "yyyy-MM-dd") // Spring注解格式化日期
@ApiModelProperty(value = "结束时间", required=true) // Swagger注解描述字段的用途和是否必填
private Date endTime; // 考试结束时间
@ApiModelProperty(value = "创建时间", required=true) // Swagger注解描述字段的用途和是否必填
private Date createTime; // 创建时间
@ApiModelProperty(value = "更新时间", required=true) // Swagger注解描述字段的用途和是否必填
private Date updateTime; // 更新时间
@ApiModelProperty(value = "总分数", required=true) // Swagger注解描述字段的用途和是否必填
private Integer totalScore; // 总分数
@ApiModelProperty(value = "总时长(分钟)", required=true) // Swagger注解描述字段的用途和是否必填
private Integer totalTime; // 总时长(分钟)
@ApiModelProperty(value = "及格分数", required=true) // Swagger注解描述字段的用途和是否必填
private Integer qualifyScore; // 及格分数
/**
*
*
*
* @return
*/
public Integer getState() {
if (this.timeLimit != null && this.timeLimit) {
if (System.currentTimeMillis() < startTime.getTime()) {
return ExamState.READY_START; // 如果当前时间小于开始时间,状态为准备开始
}
if (System.currentTimeMillis() > endTime.getTime()) {
return ExamState.OVERDUE; // 如果当前时间大于结束时间,状态为已过期
}
if (System.currentTimeMillis() > startTime.getTime()
&& System.currentTimeMillis() < endTime.getTime()
&& !ExamState.DISABLED.equals(this.state)) {
return ExamState.ENABLE; // 如果当前时间在开始时间和结束时间之间,并且状态不是禁用,状态为正在进行
}
}
return this.state; // 如果不满足上述条件,返回当前状态
}
}

@ -0,0 +1,32 @@
package com.yf.exam.modules.exam.dto; // 定义包名DTO类所在的包路径
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于描述模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于描述模型属性
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
import java.io.Serializable; // 导入Java的序列化接口用于确保对象可以被序列化
/**
* <p>
*
* </p>
* 便
*
* @author
* @since 2020-09-03 17:24
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@ApiModel(value="考试部门", description="考试部门") // Swagger注解描述这个类的用途
public class ExamDepartDTO implements Serializable { // 声明类实现Serializable接口以确保可以序列化
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的版本唯一性
@ApiModelProperty(value = "ID", required=true) // Swagger注解描述字段的用途和是否必填
private String id; // 唯一标识符标识考试部门记录的ID
@ApiModelProperty(value = "考试ID", required=true) // Swagger注解描述字段的用途和是否必填
private String examId; // 考试的唯一标识符,关联到具体的考试
@ApiModelProperty(value = "部门ID", required=true) // Swagger注解描述字段的用途和是否必填
private String departId; // 部门的唯一标识符,关联到具体的部门
}

@ -0,0 +1,50 @@
package com.yf.exam.modules.exam.dto; // 定义包名DTO类所在的包路径
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于描述模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于描述模型属性
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
import java.io.Serializable; // 导入Java的序列化接口用于确保对象可以被序列化
/**
* <p>
*
* </p>
* 便
*
* @author
* @since 2020-09-05 11:14
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@ApiModel(value="考试题库", description="考试题库") // Swagger注解描述这个类的用途
public class ExamRepoDTO implements Serializable { // 声明类实现Serializable接口以确保可以序列化
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的版本唯一性
@ApiModelProperty(value = "ID", required=true) // Swagger注解描述字段的用途和是否必填
private String id; // 题库ID唯一标识符
@ApiModelProperty(value = "考试ID", required=true) // Swagger注解描述字段的用途和是否必填
private String examId; // 关联的考试ID标识与哪个考试相关联
@ApiModelProperty(value = "题库ID", required=true) // Swagger注解描述字段的用途和是否必填
private String repoId; // 题库ID标识具体的题库
@ApiModelProperty(value = "单选题数量", required=true) // Swagger注解描述字段的用途和是否必填
private Integer radioCount; // 单选题数量,表示题库中单选题的总数
@ApiModelProperty(value = "单选题分数", required=true) // Swagger注解描述字段的用途和是否必填
private Integer radioScore; // 单选题分数,表示单选题的总分
@ApiModelProperty(value = "多选题数量", required=true) // Swagger注解描述字段的用途和是否必填
private Integer multiCount; // 多选题数量,表示题库中多选题的总数
@ApiModelProperty(value = "多选题分数", required=true) // Swagger注解描述字段的用途和是否必填
private Integer multiScore; // 多选题分数,表示多选题的总分
@ApiModelProperty(value = "判断题数量", required=true) // Swagger注解描述字段的用途和是否必填
private Integer judgeCount; // 判断题数量,表示题库中判断题的总数
@ApiModelProperty(value = "判断题分数", required=true) // Swagger注解描述字段的用途和是否必填
private Integer judgeScore; // 判断题分数,表示判断题的总分
}

@ -0,0 +1,30 @@
package com.yf.exam.modules.exam.dto.ext; // 定义包名DTO扩展类所在的包路径
import com.yf.exam.modules.exam.dto.ExamRepoDTO; // 导入考试题库数据传输类
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于描述模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于描述模型属性
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
/**
* <p>
*
* </p>
*
* @author
* @since 2020-09-05 11:14
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@ApiModel(value="考试题库扩展响应类", description="考试题库扩展响应类") // Swagger注解描述这个类的用途
public class ExamRepoExtDTO extends ExamRepoDTO { // 声明类继承自ExamRepoDTO
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制
@ApiModelProperty(value = "单选题总量", required=true) // Swagger注解描述字段的用途和是否必填
private Integer totalRadio; // 单选题总量
@ApiModelProperty(value = "多选题总量", required=true) // Swagger注解描述字段的用途和是否必填
private Integer totalMulti; // 多选题总量
@ApiModelProperty(value = "判断题总量", required=true) // Swagger注解描述字段的用途和是否必填
private Integer totalJudge; // 判断题总量
}

@ -0,0 +1,30 @@
package com.yf.exam.modules.exam.dto.request; // 定义包名请求DTO类所在的包路径
import com.yf.exam.modules.exam.dto.ExamDTO; // 导入基础考试DTO类
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO; // 导入考试题库扩展DTO类
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于描述模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于描述模型属性
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
import java.util.List; // 导入Java的List接口用于定义列表类型的属性
/**
* <p>
*
* </p>
*
* @author
* @since 2020-07-25 16:18
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@ApiModel(value="考试保存请求类", description="考试保存请求类") // Swagger注解描述这个类的用途
public class ExamSaveReqDTO extends ExamDTO { // 声明类继承自ExamDTO
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制
@ApiModelProperty(value = "题库列表", required=true) // Swagger注解描述字段的用途和是否必填
private List<ExamRepoExtDTO> repoList; // 题库列表,存储与考试相关的题库信息
@ApiModelProperty(value = "考试部门列表", required=true) // Swagger注解描述字段的用途和是否必填
private List<String> departIds; // 考试部门ID列表存储与考试相关的部门ID
}

@ -0,0 +1,21 @@
package com.yf.exam.modules.exam.dto.response; // 定义包名响应DTO类所在的包路径
import com.yf.exam.modules.exam.dto.ExamDTO; // 导入基础考试DTO类
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于描述模型
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
/**
* <p>
* 线线
* </p>
* 线
*
* @author
* @since 2020-07-25 16:18
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@ApiModel(value="在线考试分页响应类", description="在线考试分页响应类") // Swagger注解描述这个类的用途
public class ExamOnlineRespDTO extends ExamDTO { // 声明类继承自ExamDTO
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的版本唯一性
}

@ -0,0 +1,28 @@
package com.yf.exam.modules.exam.dto.response; // 定义包名响应DTO类所在的包路径
import com.yf.exam.modules.exam.dto.ExamDTO; // 导入基础考试DTO类
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于描述模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于描述模型属性
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
/**
* <p>
*
* </p>
*
*
* @author
* @since 2020-07-25 16:18
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@ApiModel(value="阅卷分页响应类", description="阅卷分页响应类") // Swagger注解描述这个类的用途
public class ExamReviewRespDTO extends ExamDTO { // 声明类继承自ExamDTO
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的版本唯一性
@ApiModelProperty(value = "考试人数", required=true) // Swagger注解描述字段的用途和是否必填
private Integer examUser; // 考试人数,表示参与考试的用户总数
@ApiModelProperty(value = "待阅试卷", required=true) // Swagger注解描述字段的用途和是否必填
private Integer unreadPaper; // 待阅试卷数量,表示尚未被阅卷的试卷数量
}

@ -0,0 +1,61 @@
package com.yf.exam.modules.exam.entity; // 定义包名,实体类所在的包路径
import com.baomidou.mybatisplus.annotation.IdType; // 导入MyBatis Plus的ID类型注解
import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的表字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的表ID注解
import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.extension.activerecord.Model; // 导入MyBatis Plus的模型类
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
import java.util.Date; // 导入Java的日期类
/**
* <p>
*
* </p>
*
*
* @author
* @since 2020-07-25 16:18
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@TableName("el_exam") // MyBatis Plus注解指定这个实体类对应的数据库表名
public class Exam extends Model<Exam> { // 声明类继承自MyBatis Plus的Model类用于数据库操作
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的唯一性
@TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解指定这个字段为表的主键类型为自增ID
private String id; // 考试ID唯一标识符
private String title; // 考试名称,描述考试的标题
private String content; // 考试描述,详细描述考试的内容
@TableField("open_type") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer openType; // 开放类型表示考试的开放范围1公开2部门3定员
private Integer state; // 考试状态,表示考试的当前状态(如:未开始、进行中、已结束)
@TableField("time_limit") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Boolean timeLimit; // 是否限时,表示考试是否有时间限制
@TableField("start_time") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Date startTime; // 开始时间,表示考试的开始时间
@TableField("end_time") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Date endTime; // 结束时间,表示考试的结束时间
@TableField("create_time") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Date createTime; // 创建时间,表示记录的创建时间
@TableField("update_time") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Date updateTime; // 更新时间,表示记录的最后更新时间
@TableField("total_score") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer totalScore; // 总分数,表示考试的总分
@TableField("total_time") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer totalTime; // 总时长(分钟),表示考试的总时长
@TableField("qualify_score") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer qualifyScore; // 及格分数,表示考试的及格分数线
}

@ -0,0 +1,47 @@
package com.yf.exam.modules.exam.entity; // 定义包名,实体类所在的包路径
import com.baomidou.mybatisplus.annotation.IdType; // 导入MyBatis Plus的ID类型注解
import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的表字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的表ID注解
import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.extension.activerecord.Model; // 导入MyBatis Plus的模型类
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
import java.io.Serializable; // 导入Java的序列化接口用于确保对象可以被序列化
/**
* <p>
*
* </p>
*
*
* @author
* @since 2020-09-03 17:24
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@TableName("el_exam_depart") // MyBatis Plus注解指定这个实体类对应的数据库表名
public class ExamDepart extends Model<ExamDepart> { // 声明类继承自MyBatis Plus的Model类用于数据库操作
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的唯一性
/**
* ID
*
*/
@TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解指定这个字段为表的主键类型为自增ID
private String id;
/**
* ID
* ID
*/
@TableField("exam_id") // MyBatis Plus注解指定这个字段在数据库表中的列名
private String examId;
/**
* ID
* ID
*/
@TableField("depart_id") // MyBatis Plus注解指定这个字段在数据库表中的列名
private String departId;
}

@ -0,0 +1,87 @@
package com.yf.exam.modules.exam.entity; // 定义包名,实体类所在的包路径
import com.baomidou.mybatisplus.annotation.IdType; // 导入MyBatis Plus的ID类型注解
import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的表字段注解
import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的表ID注解
import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.extension.activerecord.Model; // 导入MyBatis Plus的模型类
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
/**
* <p>
*
* </p>
*
*
* @author
* @since 2020-09-05 11:14
*/
@Data // Lombok注解标记这个类为数据类自动生成getter和setter方法
@TableName("el_exam_repo") // MyBatis Plus注解指定这个实体类对应的数据库表名
public class ExamRepo extends Model<ExamRepo> { // 声明类继承自MyBatis Plus的Model类用于数据库操作
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的唯一性
/**
* ID
*
*/
@TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解指定这个字段为表的主键类型为自增ID
private String id;
/**
* ID
* ID
*/
@TableField("exam_id") // MyBatis Plus注解指定这个字段在数据库表中的列名
private String examId;
/**
* ID
* ID
*/
@TableField("repo_id") // MyBatis Plus注解指定这个字段在数据库表中的列名
private String repoId;
/**
*
*
*/
@TableField("radio_count") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer radioCount;
/**
*
*
*/
@TableField("radio_score") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer radioScore;
/**
*
*
*/
@TableField("multi_count") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer multiCount;
/**
*
*
*/
@TableField("multi_score") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer multiScore;
/**
*
*
*/
@TableField("judge_count") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer judgeCount;
/**
*
*
*/
@TableField("judge_score") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer judgeScore;
}

@ -0,0 +1,17 @@
package com.yf.exam.modules.exam.mapper; // 定义包名Mapper接口所在的包路径
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus的基础Mapper接口
import com.yf.exam.modules.exam.entity.ExamDepart; // 导入考试部门实体类
/**
* <p>
* Mapper
* </p>
* MapperMyBatis PlusBaseMapper
*
* @author
* @since 2020-09-03 17:24
*/
public interface ExamDepartMapper extends BaseMapper<ExamDepart> { // 声明接口继承自BaseMapper并指定操作的实体类为ExamDepart
// 继承BaseMapper提供基本的CRUD操作创建、读取、更新、删除
}

@ -0,0 +1,52 @@
package com.yf.exam.modules.exam.mapper; // 定义包名Mapper接口所在的包路径
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus的基础Mapper接口
import com.baomidou.mybatisplus.core.metadata.IPage; // 导入MyBatis Plus的分页结果接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入MyBatis Plus的分页对象
import com.yf.exam.modules.exam.dto.ExamDTO; // 导入考试DTO
import com.yf.exam.modules.exam.dto.response.ExamReviewRespDTO; // 导入阅卷分页响应DTO
import com.yf.exam.modules.exam.dto.response.ExamOnlineRespDTO; // 导入在线考试分页响应DTO
import com.yf.exam.modules.exam.entity.Exam; // 导入考试实体类
import org.apache.ibatis.annotations.Param; // 导入MyBatis的参数注解
/**
* <p>
* Mapper
* </p>
* MapperMyBatis PlusBaseMapper
*
* @author
* @since 2020-07-25 16:18
*/
public interface ExamMapper extends BaseMapper<Exam> { // 声明接口继承自BaseMapper并指定操作的实体类为Exam
/**
*
*
*
* @param page
* @param query
* @return IPage<ExamDTO> DTO
*/
IPage<ExamDTO> paging(Page page, @Param("query") ExamDTO query);
/**
*
*
*
* @param page
* @param query
* @return IPage<ExamReviewRespDTO> DTO
*/
IPage<ExamReviewRespDTO> reviewPaging(Page page, @Param("query") ExamDTO query);
/**
* 线-
* 线
*
* @param page
* @param query
* @return IPage<ExamOnlineRespDTO> 线DTO
*/
IPage<ExamOnlineRespDTO> online(Page page, @Param("query") ExamDTO query);
}

@ -0,0 +1,29 @@
package com.yf.exam.modules.exam.mapper; // 定义包名Mapper接口所在的包路径
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus的基础Mapper接口
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO; // 导入考试题库扩展DTO
import com.yf.exam.modules.exam.entity.ExamRepo; // 导入考试题库实体类
import org.apache.ibatis.annotations.Param; // 导入MyBatis的参数注解
import java.util.List; // 导入Java的List接口
/**
* <p>
* Mapper
* </p>
* MapperMyBatis PlusBaseMapper
*
* @author
* @since 2020-09-05 11:14
*/
public interface ExamRepoMapper extends BaseMapper<ExamRepo> { // 声明接口继承自BaseMapper并指定操作的实体类为ExamRepo
/**
*
* IDDTO
*
* @param examId ID
* @return List<ExamRepoExtDTO>
*/
List<ExamRepoExtDTO> listByExam(@Param("examId") String examId); // 使用MyBatis的@Param注解来指定方法参数的名称
}

@ -0,0 +1,36 @@
package com.yf.exam.modules.exam.service; // 定义包名,服务接口所在的包路径
import com.baomidou.mybatisplus.extension.service.IService; // 导入MyBatis Plus的服务接口
import com.yf.exam.modules.exam.entity.ExamDepart; // 导入考试部门实体类
import java.util.List; // 导入Java的List接口
/**
* <p>
*
* </p>
* MyBatis PlusIService
*
* @author
* @since 2020-09-03 17:24
*/
public interface ExamDepartService extends IService<ExamDepart> { // 声明接口继承自IService并指定操作的实体类为ExamDepart
/**
*
* IDID
*
* @param examId ID
* @param departs IDID
*/
void saveAll(String examId, List<String> departs);
/**
*
* IDID
*
* @param examId ID
* @return List<String> IDID
*/
List<String> listByExam(String examId);
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save