develop四人注释完到master里 #13

Merged
pzk6utiap merged 16 commits from develop into master 9 months ago

@ -1,15 +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/";
}

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

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

@ -1,53 +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";
String TASK_DATA = "taskData"; // 用于存储任务相关数据的键名
/**
*
* @param jobClass
* @param jobName
* @param cron
* @param data
* 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
*
*
* @param jobClass
* @param jobName
* @param data
*/
void addCronJob(Class jobClass, String jobName, String data);
/**
*
* @param jobName
* @param jobGroup
*
*
* @param jobName
* @param jobGroup
*/
void pauseJob(String jobName, String jobGroup);
/**
*
* @param triggerName
* @param triggerGroup
*
*
* @param triggerName
* @param triggerGroup
*/
void resumeJob(String triggerName, String triggerGroup);
/**
* job
* @param jobName
* @param jobGroup
*
*
*
* @param jobName
* @param jobGroup
*/
void deleteJob(String jobName, String jobGroup);
}

@ -1,122 +1,185 @@
// 定义包路径,用于存放任务服务实现类
package com.yf.exam.ability.job.service.impl;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.yf.exam.ability.job.enums.JobGroup;
import com.yf.exam.ability.job.service.JobService;
import lombok.extern.log4j.Log4j2;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
// 导入所需的外部依赖包
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
@Service
@Log4j2 // 启用Log4j2日志
@Service // 标记为Spring服务组件
public class JobServiceImpl implements JobService {
/**
* Quartz
* Quartz
*
*/
private Scheduler scheduler;
private Scheduler scheduler; // 定时任务调度器实例
/**
*
* @param schedulerFactoryBean
* 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)){
jobName = jobClass.getSimpleName().toUpperCase() + "_"+IdWorker.getIdStr();
// 使用类名大写+下划线+唯一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);
//构建job信息
// 构建新的任务详情
jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).build();
//用JopDataMap来传递数据
// 设置任务数据
jobDetail.getJobDataMap().put(TASK_DATA, data);
//按新的cronExpression表达式构建一个新的trigger
// 声明触发器
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();
// 构建触发器
trigger = TriggerBuilder.newTrigger()
.withIdentity(jobName, jobGroup)
.withSchedule(scheduleBuilder)
.build();
}else{
// 无表达式则立即执行
// 无cron表达式则立即执行一次
log.info("+++++立即执行:"+ JSON.toJSONString(jobDetail));
trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup).startNow().build();
// 构建立即执行的触发器
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();
}
}

@ -1,29 +1,39 @@
// 定义包路径,用于存放自定义过滤器相关的类
package com.yf.exam.ability.shiro;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.filter.InvalidRequestFilter;
import org.apache.shiro.web.filter.mgt.DefaultFilter;
import org.apache.shiro.web.filter.mgt.FilterChainManager;
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;
import java.util.Map;
import javax.servlet.Filter; // Servlet过滤器接口定义了过滤器的基本操作
import java.util.Map; // Map集合类用于存储键值对
/**
* URL
* 400https://youdomain.com/upload/file/云帆考试系统用户手册.pdf
* 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();
// URL携带中文400servletPath中文校验bug
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;
return manager; // 返回配置好的过滤器链管理器
}
}

@ -1,131 +1,135 @@
// 定义包路径用于存放Shiro领域相关的类
package com.yf.exam.ability.shiro;
import com.yf.exam.ability.shiro.jwt.JwtToken;
import com.yf.exam.ability.shiro.jwt.JwtUtils;
import com.yf.exam.modules.sys.user.dto.response.SysUserLoginDTO;
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;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import java.util.HashSet;
import java.util.List;
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
@Slf4j
@Component // 标记为Spring组件
@Slf4j // 启用Slf4j日志
public class ShiroRealm extends AuthorizingRealm {
@Autowired
@Lazy
private SysUserService sysUserService;
@Autowired
@Lazy
private SysUserRoleService sysUserRoleService;
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof JwtToken;
}
/**
*
* @param principals
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String userId = null;
if (principals != null) {
SysUserLoginDTO user = (SysUserLoginDTO) principals.getPrimaryPrincipal();
userId = user.getId();
}
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();
if (token == null) {
throw new AuthenticationException("token为空!");
}
// 校验token有效性
SysUserLoginDTO user = this.checkToken(token);
return new SimpleAuthenticationInfo(user, token, getName());
}
/**
* Token
* @param token
* @return
* @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);
@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); // 清除缓存
}
}

@ -1,53 +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 com.yf.exam.ability.shiro.jwt.JwtToken;
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;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
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 // 启用Slf4j日志
public class JwtFilter extends BasicHttpAuthenticationFilter {
/**
*
* @param request
* @param response
* @param mappedValue
* @return
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
try {
executeLogin(request, response);
return true;
} catch (Exception e) {
// 写出统一错误信息
InjectUtils.restError((HttpServletResponse) response);
return false;
}
}
/**
* 访
*
* 访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);
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String token = httpServletRequest.getHeader(Constant.TOKEN);
// 如果token为空则抛出异常
if (token == null || "".equals(token)) {
throw new Exception("token不能为空");
}
JwtToken jwtToken = new JwtToken(token);
// 提交给realm进行登入如果错误他会抛出异常并被捕获
getSubject(request, response).login(jwtToken);
// 如果没有抛出异常则代表登入成功返回true
return true;
}
// 创建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;
}
}
}

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

@ -1,14 +1,15 @@
// 定义包路径用于存放JWT工具类
package com.yf.exam.ability.shiro.jwt;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.yf.exam.core.utils.file.Md5Util;
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;
import java.util.Calendar; // 日历类
import java.util.Date; // 日期类
/**
* JWT
@ -19,81 +20,74 @@ public class JwtUtils {
/**
* 24
*/
private static final long EXPIRE_TIME = 24 * 60 * 60 * 1000;
private static final long EXPIRE_TIME = 24 * 60 * 60 * 1000; // JWT有效期
/**
*
* @param token
* @param username
* @return
* @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();
Algorithm algorithm = Algorithm.HMAC256(encryptSecret(username)); // 创建算法
JWTVerifier verifier = JWT.require(algorithm) // 创建验证器
.withClaim("username", username) // 添加用户名声明
.build(); // 构建验证器
// 效验TOKEN
verifier.verify(token);
return true;
verifier.verify(token); // 验证token
return true; // 返回验证成功
} catch (Exception exception) {
return false;
return false; // 返回验证失败
}
}
/**
* Token
* @param token
* @return
* @param token JWT
* @return
*/
public static String getUsername(String token) {
try {
DecodedJWT jwt = JWT.decode(token);
return jwt.getClaim("username").asString();
DecodedJWT jwt = JWT.decode(token); // 解码JWT
return jwt.getClaim("username").asString(); // 获取用户名
} catch (JWTDecodeException e) {
return null;
return null; // 返回null表示解码失败
}
}
/**
* JWT Token
* @param username
* @return
* @param username
* @return JWT
*/
public static String sign(String username) {
Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
Algorithm algorithm = Algorithm.HMAC256(encryptSecret(username));
Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME); // 设置过期时间
Algorithm algorithm = Algorithm.HMAC256(encryptSecret(username)); // 创建算法
// 附带username信息
return JWT.create()
.withClaim("username", username)
.withExpiresAt(date).sign(algorithm);
return JWT.create() // 创建JWT
.withClaim("username", username) // 添加用户名声明
.withExpiresAt(date).sign(algorithm); // 设置过期时间并签名
}
/**
* JWT
* @param userName
* @return
* @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));
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());
String secret = Md5Util.md5(sb.toString()); // 生成MD5秘钥
return Md5Util.md5(userName + "&" + secret);
return Md5Util.md5(userName + "&" + secret); // 返回加密后的秘钥
}
}

@ -1,32 +1,36 @@
// 定义包路径,用于存放文件上传配置相关的类
package com.yf.exam.ability.upload.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
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
@Configuration
@ConfigurationProperties(prefix = "conf.upload")
@Data // 使用Lombok注解自动生成getter和setter方法
@Configuration // 标记为Spring配置类表示这是一个配置类
@ConfigurationProperties(prefix = "conf.upload") // 指定配置文件中属性的前缀,这里是"conf.upload"
public class UploadConfig {
/**
* 访
* 访
* 访URL
*/
private String url;
private String url; // 文件访问的URL
/**
*
*
*
*/
private String dir;
private String dir; // 文件存储的物理目录
/**
*
*
*
*/
private String [] allowExtensions;
private String[] allowExtensions; // 允许上传的文件后缀
}

@ -1,57 +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 com.yf.exam.ability.Constant;
import com.yf.exam.ability.upload.dto.UploadReqDTO;
import com.yf.exam.ability.upload.dto.UploadRespDTO;
import com.yf.exam.ability.upload.service.UploadService;
import com.yf.exam.core.api.ApiRest;
import com.yf.exam.core.api.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletRequest; // HTTP请求类表示HTTP请求
import javax.servlet.http.HttpServletResponse; // HTTP响应类表示HTTP响应
/**
*
* RESTful API
* @author bool
*/
@Log4j2
@Api(tags = {"文件上传"})
@RestController
@Log4j2 // 启用Log4j2日志
@Api(tags = {"文件上传"}) // Swagger API标签用于分类API
@RestController // 标记为REST控制器表示该类是一个REST风格的控制器
public class UploadController extends BaseController {
@Autowired
private UploadService uploadService;
private UploadService uploadService; // 文件上传服务,自动注入
/**
*
* @param reqDTO
* @return
*
*
* @param reqDTO DTO
* @return
*/
@PostMapping("/common/api/file/upload")
@ApiOperation(value = "文件上传", notes = "此接口较为特殊参数都通过表单方式提交而非JSON")
@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);
UploadRespDTO respDTO = uploadService.upload(reqDTO); // 调用上传服务
return super.success(respDTO); // 返回成功响应
}
/**
*
* @param request
* @param response
*
*
* @param request HTTP
* @param response HTTP
*/
@GetMapping(Constant.FILE_PREFIX+"**")
@ApiOperation(value = "文件下载", notes = "文件下载")
@GetMapping(Constant.FILE_PREFIX+"**") // GET请求映射指定请求路径前缀
@ApiOperation(value = "文件下载", notes = "文件下载") // Swagger API操作描述
public void download(HttpServletRequest request, HttpServletResponse response) {
uploadService.download(request, response);
uploadService.download(request, response); // 调用下载服务
}
}

@ -1,22 +1,26 @@
// 定义包路径用于存放文件上传请求DTO
package com.yf.exam.ability.upload.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.web.multipart.MultipartFile;
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
*
* @author van
* @date 2019-12-26 17:54
*/
@Data
@ApiModel(value="文件上传参数", description="文件上传参数")
@Data // 使用Lombok注解自动生成getter和setter方法
@ApiModel(value="文件上传参数", description="文件上传参数") // 使用Swagger注解描述API模型
public class UploadReqDTO extends BaseDTO {
@ApiModelProperty(value = "上传文件内容", required=true)
private MultipartFile file;
/**
*
*
*/
@ApiModelProperty(value = "上传文件内容", required=true) // 使用Swagger注解描述API模型属性
private MultipartFile file; // 上传的文件内容
}

@ -1,23 +1,28 @@
// 定义包路径用于存放文件上传响应DTO
package com.yf.exam.ability.upload.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 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
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value="文件上传响应", description="文件上传响应")
@Data // 使用Lombok注解自动生成getter和setter方法
@AllArgsConstructor // 使用Lombok注解生成全参构造函数
@NoArgsConstructor // 使用Lombok注解生成无参构造函数
@ApiModel(value="文件上传响应", description="文件上传响应") // 使用Swagger注解描述API模型
public class UploadRespDTO extends BaseDTO {
@ApiModelProperty(value = "上传后的完整的URL地址", required=true)
private String url;
/**
* URL
* 访URL
*/
@ApiModelProperty(value = "上传后的完整的URL地址", required=true) // 使用Swagger注解描述API模型属性
private String url; // 上传后的完整URL地址
}

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

@ -1,135 +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;
import com.yf.exam.ability.upload.dto.UploadRespDTO;
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;
import org.springframework.stereotype.Service;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
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
@Service
@Log4j2 // 使用Log4j2日志注解启用日志功能
@Service // 使用Spring服务注解标记为服务组件
public class UploadServiceImpl implements UploadService {
@Autowired
private UploadConfig conf;
private UploadConfig conf; // 自动注入文件上传配置
/**
*
*
*
* @param reqDTO DTO
* @return DTO
*/
@Override
public UploadRespDTO upload(UploadReqDTO reqDTO) {
// 文件内容
MultipartFile file = reqDTO.getFile();
MultipartFile file = reqDTO.getFile(); // 获取上传的文件
// 验证文件后缀
boolean allow = FilenameUtils.isExtension(file.getOriginalFilename(), conf.getAllowExtensions());
boolean allow = FilenameUtils.isExtension(file.getOriginalFilename(), conf.getAllowExtensions()); // 验证文件后缀
if(!allow){
throw new ServiceException("文件类型不允许上传!");
throw new ServiceException("文件类型不允许上传!"); // 抛出异常
}
// 上传文件夹
String fileDir = conf.getDir();
String fileDir = conf.getDir(); // 获取文件存储目录
// 真实物理地址
String fullPath;
try {
// 新文件
String filePath = FileUtils.processPath(file);
String filePath = FileUtils.processPath(file); // 处理文件路径
// 文件保存地址
fullPath = fileDir + filePath;
fullPath = fileDir + filePath; // 拼接完整路径
// 创建文件夹
FileUtils.checkDir(fullPath);
FileUtils.checkDir(fullPath); // 检查并创建文件夹
// 上传文件
FileCopyUtils.copy(file.getInputStream(), new FileOutputStream(fullPath));
FileCopyUtils.copy(file.getInputStream(), new FileOutputStream(fullPath)); // 复制文件内容到指定路径
return this.generateResult(filePath);
return this.generateResult(filePath); // 返回上传结果
} catch (IOException e) {
e.printStackTrace();
throw new ServiceException("文件上传失败:"+e.getMessage());
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());
String filePath = this.getRealPath(request.getRequestURI()); // 获取文件的真实路径
// 处理中文问题
try {
filePath = URLDecoder.decode(filePath, "utf-8");
filePath = URLDecoder.decode(filePath, "utf-8"); // 解码文件路径
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
throw new RuntimeException(e); // 抛出运行时异常
}
System.out.println("++++完整路径为:"+filePath);
System.out.println("++++完整路径为:"+filePath); // 打印完整路径
try {
FileUtils.writeRange(request, response, filePath);
FileUtils.writeRange(request, response, filePath); // 调用文件工具类进行文件写入
} catch (IOException e) {
response.setStatus(404);
log.error("预览文件失败" + e.getMessage());
response.setStatus(404); // 设置响应状态为404
log.error("预览文件失败" + e.getMessage()); // 打印错误日志
}
}
/**
*
* @param fileName
* @return
* DTOURL
*
* @param fileName
* @return DTO
*/
private UploadRespDTO generateResult(String fileName) {
//获取加速域名
String domain = conf.getUrl();
String domain = conf.getUrl(); // 获取文件访问的URL
// 返回结果
return new UploadRespDTO(domain + fileName);
return new UploadRespDTO(domain + fileName); // 返回上传响应DTO
}
/**
*
* @param uri
* @return
* URI
*
* @param uri URI
* @return
*/
public String getRealPath(String uri){
String regx = Constant.FILE_PREFIX+"(.*)";
String regx = Constant.FILE_PREFIX+"(.*)"; // 正则表达式匹配文件路径
// 查找全部变量
Pattern pattern = Pattern.compile(regx);
Matcher m = pattern.matcher(uri);
Pattern pattern = Pattern.compile(regx); // 编译正则表达式
Matcher m = pattern.matcher(uri); // 创建匹配器
if (m.find()) {
String str = m.group(1);
return conf.getDir() + str;
String str = m.group(1); // 获取匹配的文件路径
return conf.getDir() + str; // 返回真实文件路径
}
return null;
return null; // 返回null表示未找到
}
}

@ -1,172 +1,169 @@
// 定义包路径,用于存放文件工具类
package com.yf.exam.ability.upload.utils;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.yf.exam.core.utils.DateUtils;
import org.apache.commons.io.FilenameUtils;
import org.springframework.web.multipart.MultipartFile;
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;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Date;
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 = ".";
/**
* 线线
* @param request
* @param response
* @param filePath
* @throws IOException
*/
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");
int start = 0, end = 0;
if (range != null && range.startsWith("bytes=")) {
String[] values = range.split("=")[1].split("-");
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("=");
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
* @return
*/
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();
}
}
/**
*
*
*/
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(); // 如果文件夹不存在,创建文件夹
}
}
}

@ -1,47 +1,75 @@
package com.yf.exam.ability.upload.utils;
// 这一行声明了该Java类所属的包名为com.yf.exam.ability.upload.utils。
// 包用于对相关的Java类进行组织和管理方便代码的分类、复用以及避免类名冲突。
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的字符串工具类用于字符串操作
// 引入了Apache Commons Lang库中的StringUtils类。
// 这个类提供了许多方便的字符串操作方法,比如判断字符串是否为空、是否空白(包含空格等空白字符)、字符串的拼接、截取等操作,在这里主要用于对文件路径字符串进行相关判断。
import java.util.HashMap;
import java.util.Map;
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
*/
public class MediaUtils {
// 这是一个Java类的文档注释用于描述该类的整体功能和用途。
// 说明这个类主要是作为媒体工具类其核心功能是判断和获取媒体文件的MIME类型。
// 通过维护一个静态的映射关系文件后缀名到MIME类型的映射在文件上传和下载的业务场景中能够依据文件的后缀名准确地确定其对应的MIME类型从而正确处理文件的传输和展示等操作。
// 同时标注了类的作者是bool创建日期是2019年11月14日16:21。
public static final Map<String, String> MEDIA_MAP = new HashMap(){
{
//本来是pdf的
put(".pdf", "application/pdf");
public class MediaUtils {
//视频
put(".mp4", "video,video/mp4");
/**
*
* 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类型。
/**
*
* @param filePath
* @return
* MIME
* MEDIA_MAPMIME
*
* @param filePath
* @return MIME
*/
public static String getContentType(String filePath){
if(!StringUtils.isBlank(filePath)
&& filePath.indexOf(".")!=-1) {
// 这是对下面定义的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",这个默认值通常用于表示未知类型的二进制数据文件。
}

@ -1,156 +1,189 @@
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;
import lombok.extern.slf4j.Slf4j;
// 导入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
* AOP
*
*
* @author bool
*/
@Aspect
@Component
@Slf4j
@Aspect // 标记该类为一个AspectJ切面类用于定义切面相关的逻辑。
@Component // 标记该类为Spring组件使其能够被Spring容器管理和实例化以便在应用中使用。
@Log4j2 // 使用Log4j2注解启用日志记录功能方便在类中记录相关操作的日志信息。
public class DictAspect {
@Autowired
private SysDictService sysDictService;
private SysDictService sysDictService; // 通过自动注入获取系统数据字典服务对象,用于查询数据字典值。
/**
* Controller
* @param pjp
* @return
* @throws Throwable
* 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);
return this.translate(pjp); // 调用translate方法对被拦截方法的执行结果进行处理主要是处理数据字典值。
}
/**
* BaseDictService
*
* BaseDictService
*
* @param pjp
* @return
* @throws Throwable
* @param pjp
* @return
* @throws Throwable
*/
public Object translate(ProceedingJoinPoint pjp) throws Throwable {
// 处理字典
// 调用被拦截方法获取原始结果然后调用parseAllDictText方法对结果进行数据字典值的处理。
return this.parseAllDictText(pjp.proceed());
}
/**
*
*
* ApiRestparseFullDictText
*
* @param result
* @param result
*/
private Object parseAllDictText(Object result) {
// 非ApiRest类型不处理
// 判断结果对象是否是ApiRest类型如果是则进行数据字典值的处理。
if (result instanceof ApiRest) {
parseFullDictText(result);
}
return result;
}
/**
*
* ApiRest
*
* @param result
* @param result ApiRest
*/
private void parseFullDictText(Object result) {
try {
Object rest = ((ApiRest) result).getData(); // 获取ApiRest对象中的数据部分这部分数据可能包含数据字典相关字段。
Object rest = ((ApiRest) result).getData();
// 不处理普通数据类型
// 如果数据部分为空或者是基本数据类型,则不需要进行数据字典值的处理,直接返回。
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);
Object item = this.parseObject(record); // 调用parseObject方法对每条记录进行数据字典值处理。
items.add(item);
}
((IPage) rest).setRecords(items);
((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);
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();
e.printStackTrace(); // 如果在处理过程中出现异常,则打印异常堆栈信息。
}
}
/**
*
*
*
* @param record
* @return
* @param record
* @return
*/
public Object parseObject(Object record) {
if (record == null) {
return null;
}
// 不处理普通数据类型
// 如果记录对象是基本数据类型,则不需要进行数据字典值处理,直接返回原对象。
if (this.isBaseType(record.getClass())) {
return record;
}
// 转换JSON字符
// 将记录对象转换JSON字符再解析为JSONObject对象以便于通过字段名获取和设置值。
String json = JSON.toJSONString(record);
JSONObject item = JSONObject.parseObject(json);
for (Field field : Reflections.getAllFields(record)) {
for (Field field : Reflections.getAllFields(record)) { // 遍历记录对象的所有字段。
// 如果是List类型
// 如果字段类型是List类型,则对列表字段进行特殊处理。
if (List.class.isAssignableFrom(field.getType())) {
try {
List list = this.processList(field, item.getObject(field.getName(), List.class));
List list = this.processList(field, item.getObject(field.getName(), List.class)); // 调用processList方法处理列表字段。
item.put(field.getName(), list);
continue;
} catch (Exception e) {
@ -159,14 +192,14 @@ public class DictAspect {
continue;
}
// 处理普通字段
if (field.getAnnotation(Dict.class) != null) {
// 如果字段带有数据字典注解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()));
//翻译字典值对应的txt
// 调用translateDictValue方法翻译字典值对应的文本根据字典代码、文本、表名和键值查询对应的字典文本。
String textValue = this.translateDictValue(code, text, table, key);
if (StringUtils.isEmpty(textValue)) {
textValue = "";
@ -175,24 +208,22 @@ public class DictAspect {
continue;
}
//日期格式转换
if ("java.util.Date".equals(field.getType().getName()) && item.get(field.getName()) != null) {
// 获取注解
// 如果字段类型是日期类型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())) {
// 如果注解不为空且指定了日期格式模式,则使用注解指定的格式创建日期格式化对象。
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;
}
}
@ -200,49 +231,53 @@ public class DictAspect {
}
/**
* List
* List
*
* @param field
* @return
* @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属性的真实类
// 获取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){
} 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){
// 转换出错不处理
} catch (Exception e) {
// 如果转换过程中出现错误,则不进行处理,直接使用原元素。
// 这里可以根据实际需求进一步处理错误情况,比如记录日志等。
// 目前只是简单地忽略错误,继续处理下一个元素。
;
}
// 处理后的数据
// 处理后的元素进行数据字典值处理调用parseObject方法。
Object pds = this.parseObject(data);
result.add(pds);
}
@ -251,23 +286,25 @@ public class DictAspect {
}
/**
*
*
*
* @param code
* @param text
* @param table
* @param key
* @return
* @param code
* @param text
* @param table
* @param key
* @return
*/
private String translateDictValue(String code, String text, String table, String key) {
private String translateDictValue(String code, String text, String table, String) {
if (StringUtils.isEmpty(key)) {
return null;
}
try {
// 翻译值
// 定义变量用于存储翻译后的字典文本
String dictText = null;
if (!StringUtils.isEmpty(table)) {
dictText = sysDictService.findDict(table, text, code, key.trim());
// 如果字典表名不为空则调用sysDictService的findDict方法查询数据字典表获取对应的字典文本值。
dictText = sysDictService.findDict(table, text, code, key.trim());
}
if (!StringUtils.isEmpty(dictText)) {
@ -280,15 +317,13 @@ public class DictAspect {
}
/**
*
*
*
* @param clazz
* @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) ||
@ -300,18 +335,16 @@ public class DictAspect {
return true;
}
// String类型
// 判断是否是字符串类型。
if (clazz.equals(java.lang.String.class)) {
return true;
}
// 数字
// 判断是否是数字类型这里的数字类型可能是指抽象的数字类型比如Number的子类等
if (clazz.equals(java.lang.Number.class)) {
return true;
}
return false;
}
}

@ -1,144 +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
* ID
* PaginationInterceptor
*
* @author bool
*/
@Log4j2
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class}),})
// 使用@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 {
/**
* ID
* 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语句类型
// 获取当前SQL语句的类型通过MappedStatement对象的getSqlCommandType方法获取。
// 该类型是一个枚举值如SELECT、INSERT、UPDATE、DELETE等用于判断当前拦截的SQL语句是何种类型的操作。
SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
// 只过滤查询的
// 只对查询类型的SQL语句进行处理如果当前SQL语句类型是SELECT则进入下面的处理逻辑。
if (SqlCommandType.SELECT == sqlCommandType) {
// 获得原始SQL
// 获取原始的SQL语句通过StatementHandler的getBoundSql方法获取绑定的SQL语句对象再获取其SQL字符串。
String sql = statementHandler.getBoundSql().getSql();
// 不处理
if(!sql.contains(USER_FILTER)){
// 如果原始SQL语句中不包含用户ID占位符USER_FILTER则直接调用父类PaginationInterceptor的intercept方法
// 即按照原有的分页逻辑进行处理不进行用户ID相关的替换等操作。
if (!sql.contains(USER_FILTER)) {
return super.intercept(invocation);
}
// 处理SQL语句
// 如果原始SQL语句中包含用户ID占位符则需要对SQL语句进行处理。
// 首先调用parseSql方法对SQL语句进行解析和处理包括替换用户ID等操作。
String outSql = this.parseSql(sql);
// 设置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) {
}
/**
*
* @return
* Apache ShiroSecurityUtils
* SysUserLoginDTOnull
*
* @return SysUserLoginDTOnull
*/
private SysUserLoginDTO getLoginUser() {
try {
return SecurityUtils.getSubject().getPrincipal() != null ? (SysUserLoginDTO) SecurityUtils.getSubject().getPrincipal() : null;
return SecurityUtils.getSubject().getPrincipal()!= null? (SysUserLoginDTO) SecurityUtils.getSubject().getPrincipal() : null;
} catch (Exception e) {
return null;
}
}
/**
* ID
* @param sql
* @return
* IDIDSQLIDUSER_FILTERID
*
* @param sql SQL
* @return IDSQLIDnull
*/
private String processUserId(String sql) {
// 当前用户
// 获取当前登录用户的信息通过调用getLoginUser方法获取。
SysUserLoginDTO user = this.getLoginUser();
String userId = user.getId();
if(StringUtils.isNotBlank(userId)){
// 如果获取到的用户ID不为空则将原始SQL语句中的用户ID占位符替换为实际的用户ID并返回替换后的SQL语句。
if (StringUtils.isNotBlank(userId)) {
return sql.replace(USER_FILTER, userId);
}
// 如果用户ID为空则返回null。
return null;
}
/**
*
* @param src
* @return
* 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();
// 过滤用户ID
// 调用processUserId方法对初步处理后的SQL语句进行用户ID的替换操作将用户ID占位符替换为实际的用户ID。
sql = this.processUserId(sql);
// 获得SQL
// 返回处理后的SQL语句。
return sql;
} catch (Exception e) {
e.printStackTrace();
}
// 如果在处理过程中出现异常则返回原始的SQL语句。
return src;
}
}

@ -1,80 +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操作命令
// 获取当前SQL语句的类型通过MappedStatement对象的getSqlCommandType方法获取。
// 该类型是一个枚举值如SELECT、INSERT、UPDATE、DELETE等用于判断当前拦截的SQL语句是何种类型的操作。
SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
// 获取新增或修改的对象参数
// 从invocation对象的参数数组中获取第二个参数即要进行新增或修改操作的对象参数
// 后续会通过反射操作该对象来设置创建时间和更新时间字段的值。
Object parameter = invocation.getArgs()[1];
// 获取对象中所有的私有成员变量(对应表字段)
// 获取对象中所有的私有成员变量对应表字段通过反射获取parameter对象的声明字段数组。
Field[] declaredFields = parameter.getClass().getDeclaredFields();
if (parameter.getClass().getSuperclass() != null) {
// 判断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);
field.set(parameter, new Timestamp(System.currentTimeMillis()));
// 使用反射设置该字段的值为当前的时间戳通过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) {
// 这里暂时没有具体的设置属性操作,可根据后续需求添加相关逻辑来处理接收到的属性信息。
}
}

@ -1,99 +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
@Component
@Log4j2 // 使用Log4j2注解启用日志记录功能方便在类中记录相关操作的日志信息。
@Component // 将该类标记为Spring组件使其能够被Spring容器管理和使用。
public class InjectUtils {
/**
*
*
*
* @param object
* @param value
* @param fields
* @throws Exception
* @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){
// 如果获取到的字段对象为空,说明未找到对应的字段,继续下一个字段的处理。
if (field == null) {
continue;
}
// 通过反射设置该字段可访问,因为私有字段默认是不可直接访问的。
field.setAccessible(true);
// 使用反射设置该字段的值为传入的值,即将指定的值赋给对象的指定字段。
field.set(object, value);
}
}
/**
*
*
*
* @param clazz
* @param fieldName
* @param clazz
* @param fieldName
* @return null
*/
private Field getFiled(Class clazz, String fieldName) {
System.out.println("注入的类:" + clazz.toString()); // 打印当前正在查找字段的目标类的信息,方便调试查看。
System.out.println("注入的类:"+clazz.toString());
//是否具有包含关系
// 尝试获取当前类中指定字段名的字段对象
try {
//获取当前类的属性
return clazz.getDeclaredField(fieldName);
}catch (Exception e){
} catch (Exception e) {
log.error(clazz.toString() + ": not exist field, try superclass " + fieldName); // 如果获取字段失败,记录错误日志,
// 提示在当前类中不存在指定字段,
// 并准备尝试在父类中查找。
log.error(clazz.toString() + ": not exist field, try superclass " + fieldName);
//如果为空且存在父类,则往上找
if(clazz.getSuperclass()!=null){
// 如果当前类未找到指定字段且存在父类,则递归调用本方法在父类中继续查找指定字段。
if (clazz.getSuperclass()!= null) {
return this.getFiled(clazz.getSuperclass(), fieldName);
}
// 如果在当前类及其所有父类中都未找到指定字段则返回null。
return null;
}
}
/**
*
* @param response
* @throws IOException
* 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");
response.getWriter().write(JSON.toJSONString(apiRest));
response.getWriter().close();
}catch (IOException e){
// 将创建的API响应对象转换为JSON字符串并写入到HTTP响应的输出流中以便客户端能够接收到错误信息。
response.getWriter().write(JSON.toJSONString(apiRest));
// 关闭HTTP响应的写入流释放相关资源。
response.getWriter().close();
} catch (IOException e) {
// 如果在设置响应属性或写入响应内容过程中出现IO异常这里只是简单地捕获异常
// 可以根据实际需求进一步处理异常,比如记录更详细的日志信息等。
}
}
}

@ -1,35 +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;
import org.springframework.web.filter.CorsFilter;
// 导入Spring框架中实现跨域过滤功能的类它会根据配置的跨域规则对请求进行过滤和处理
// 以实现允许跨域访问的功能。在本类中创建该过滤器并将其注册到Servlet容器中。
import org.springframework.web.filter.CorsFilter;
/**
*
* 访
* CorsFilter
* 使访
*
* @author bool
* @date 2019-08-13 17:28
*/
@Configuration
@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;
}
}

@ -1,28 +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
@Configuration // 使用该注解标记此为Spring配置类表明这个类是用来进行Spring应用程序的配置工作的。
public class MultipartConfig {
/**
* 使@BeanSpring Bean
* MultipartConfigElement
*
* @return MultipartConfigElement
*/
@Bean
public MultipartConfigElement multipartConfigElement() {
MultipartConfigFactory factory = new MultipartConfigFactory();
// 单个数据大小
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();
}
}

@ -1,37 +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;
/**
* Mybatis
*
* MybatisMyBatis
* MyBatis
*
* @author bool
*/
@Configuration
@MapperScan("com.yf.exam.modules.**.mapper")
@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
@Bean // 将该方法返回的查询拦截器对象声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
public QueryInterceptor queryInterceptor() {
QueryInterceptor query = new QueryInterceptor();
QueryInterceptor query = new QueryInterceptor(); // 创建一个新的查询拦截器对象。
// 设置查询限制,这里将查询限制设置为 -1L具体含义可能根据QueryInterceptor类的内部逻辑而定
// 可能表示不限制查询结果的数量或者有其他特殊的处理方式与该值相关。
query.setLimit(-1L);
// 返回设置好的查询拦截器对象该对象将被Spring容器管理并在合适的查询操作场景中被调用执行拦截处理。
return query;
}
/**
*
* 使@BeanSpring Bean
* UpdateInterceptor
*
* @return UpdateInterceptor
*/
@Bean
@Bean // 将该方法返回的更新拦截器对象声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
public UpdateInterceptor updateInterceptor() {
// 创建一个新的更新拦截器对象这里没有进行额外的设置操作可能在UpdateInterceptor类内部有默认的处理逻辑
// 直接返回该对象它将被Spring容器管理并在合适的插入或更新操作场景中被调用执行拦截处理。
return new UpdateInterceptor();
}
}

@ -1,77 +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
@Configuration
@EnableScheduling
@EnableAsync
@Log4j2 // 使用Log4j2注解启用日志记录功能方便在类中记录相关操作的日志信息。
@Configuration // 使用该注解标记此为Spring配置类表明这个类是用来进行Spring应用程序的配置工作的。
@EnableScheduling // 使用该注解启用任务调度功能使得Spring能够识别并处理类中的定时任务等调度相关设置。
@EnableAsync // 使用该注解启用异步任务执行功能使得Spring能够识别并处理类中的异步方法使其能够在独立的线程中执行。
public class ScheduledConfig implements SchedulingConfigurer, AsyncConfigurer {
/**
* 使线
* @return
* 使@BeanSpring Bean
* 线ThreadPoolTaskScheduler
*
* @return 线ThreadPoolTaskScheduler线
*/
@Bean(destroyMethod = "shutdown", name = "taskScheduler")
public ThreadPoolTaskScheduler taskScheduler(){
ThreadPoolTaskScheduler scheduler = new 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;
}
/**
* 线
* @return
* 使@BeanSpring Bean
* 线ThreadPoolTaskExecutor
*
* @return 线ThreadPoolTaskExecutor线
*/
@Bean(name = "asyncExecutor")
@Bean(name = "asyncExecutor") // 将该方法返回的线程池任务执行器对象声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
public ThreadPoolTaskExecutor asyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
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();
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 {}, emthod {}, params {}", throwable, method, objects);
log.error("异步任务执行出现异常, message {}, method {}, params {}", throwable, method, objects);
};
}
}

@ -1,127 +1,133 @@
// 定义包路径用于存放Shiro配置类
package com.yf.exam.config;
import com.yf.exam.ability.shiro.CNFilterFactoryBean;
import com.yf.exam.ability.shiro.ShiroRealm;
import com.yf.exam.ability.shiro.aop.JwtFilter;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
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
@Configuration
@Slf4j // 使用Lombok注解启用Log4j2日志
@Configuration // 使用Spring注解标记为配置类
public class ShiroConfig {
/**
* Filter Chain
*
* 1URLFilter使
* 2
* 3permsroles
*/
@Bean("shiroFilterFactoryBean")
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new CNFilterFactoryBean();
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("/exam/api/sys/config/detail", "anon");
// 文件读取
map.put("/upload/file/**", "anon");
map.put("/", "anon");
map.put("/v2/**", "anon");
map.put("/doc.html", "anon");
map.put("/**/*.js", "anon");
map.put("/**/*.css", "anon");
map.put("/**/*.html", "anon");
map.put("/**/*.svg", "anon");
map.put("/**/*.pdf", "anon");
map.put("/**/*.jpg", "anon");
map.put("/**/*.png", "anon");
map.put("/**/*.ico", "anon");
// 字体
map.put("/**/*.ttf", "anon");
map.put("/**/*.woff", "anon");
map.put("/**/*.woff2", "anon");
map.put("/druid/**", "anon");
map.put("/swagger-ui.html", "anon");
map.put("/swagger**/**", "anon");
map.put("/webjars/**", "anon");
// 添加自己的过滤器并且取名为jwt
Map<String, Filter> filterMap = new HashMap<String, Filter>(1);
filterMap.put("jwt", new JwtFilter());
shiroFilterFactoryBean.setFilters(filterMap);
map.put("/**", "jwt");
shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
return shiroFilterFactoryBean;
}
@Bean("securityManager")
public DefaultWebSecurityManager securityManager(ShiroRealm myRealm) {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(myRealm);
DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
securityManager.setSubjectDAO(subjectDAO);
return securityManager;
}
/**
*
* @return
*/
@Bean
@DependsOn("lifecycleBeanPostProcessor")
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
defaultAdvisorAutoProxyCreator.setUsePrefix(true);
defaultAdvisorAutoProxyCreator.setAdvisorBeanNamePrefix("_no_advisor");
return defaultAdvisorAutoProxyCreator;
}
@Bean
public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
return new LifecycleBeanPostProcessor();
}
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
return advisor;
}
/**
* 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; // 返回授权属性源顾问
}
}

@ -1,65 +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;
/**
* Swagger
* SwaggerSwagger
* Swagger 2Swagger Bootstrap UI"swagger"
* DocketAPIAPI
* API便API使
* @author bool
* @date 2020/8/19 20:53
*/
@Configuration
@EnableSwagger2
@EnableSwaggerBootstrapUI
@ConfigurationProperties(prefix = "swagger")
public class SwaggerConfig {
@Configuration // 使用该注解标记此为Spring配置类表明这个类是用来进行Spring应用程序的配置工作的。
@EnableSwagger2 // 使用该注解启用Swagger 2功能使得Swagger能够为项目中的API生成详细的文档并提供交互界面。
@EnableSwaggerBootstrapUI // 使用该注解启用Swagger Bootstrap UI功能提供更友好的界面展示和交互功能。
@ConfigurationProperties(prefix = "swagger") // 使用该注解将类的属性与以"swagger"为前缀的配置文件中的属性进行绑定,
// 以便在类中可以方便地使用这些配置属性来定制Swagger的设置。
public class SwaggerConfig {
@Bean
/**
* 使@BeanSpring Bean
* DocketSwagger
* API
*
* @return DocketAPIAPI
*/
@Bean // 将该方法返回的Docket对象声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
public Docket examApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.groupName("考试模块接口")
.select()
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
.paths(PathSelectors.ant("/exam/api/**"))
.build()
.securitySchemes(Collections.singletonList(securityScheme()));
}
return new Docket(DocumentationType.SWAGGER_2) // 创建一个新的Docket对象并指定文档类型为SWAGGER_2
// 这是目前较为常用的Swagger文档类型用于生成详细的API文档。
.apiInfo(apiInfo()) // 调用apiInfo方法获取包含详细API信息的ApiInfo对象并设置到Docket对象中
// 以便在生成的Swagger文档中展示API的标题、描述、联系人、版本等信息。
.groupName("考试模块接口") // 设置Docket对象的分组名称为"考试模块接口"
// 这样可以将项目中的API按照不同的模块或功能进行分组展示方便查看和管理。
private ApiInfo apiInfo() {
return new ApiInfoBuilder().title("考试系统接口")
.description("考试系统接口")
.contact(new Contact("Van", "https://exam.yfhl.net", "18365918@qq.com"))
.version("1.0.0")
.build();
.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对象使其生效并包含我们所设置的所有信息。
}
/**
*
* @return
* APIApiKeyAPI
*
* @return ApiKeyAPI
* Docket便SwaggerAPI
*/
@Bean
@Bean // 将该方法返回的SecurityScheme对象实际为ApiKey类型声明为Spring Bean以便Spring容器能够管理和注入到其他需要使用的地方。
SecurityScheme securityScheme() {
return new ApiKey("token", "token", "header");
return new ApiKey("token", "token", "header"); // 创建一个新的ApiKey对象
// 第一个参数"token"表示授权的键名,即客户端在请求时需要在指定位置(这里是请求头)传递的键名;
// 第二个参数"token"表示授权的值,这里简单设置为与键名相同,实际应用中可能是根据用户登录等情况生成的授权令牌;
// 第三个参数"header"表示授权的值应该放置的位置,这里指定为在请求头中传递。
}
}

@ -1,21 +1,22 @@
package com.yf.exam.core.annon;
// 文件路径: yfexam-exam-main/yfexam-exam-main/exam-api/src/main/java/com/yf/exam/core/annon/Dict.java
package com.yf.exam.core.annon; // 定义包名,表示该类属于 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;
import java.lang.annotation.ElementType; // 导入 ElementType 类,用于指定注解可以应用于的元素类型
import java.lang.annotation.Retention; // 导入 Retention 类,用于指定注解的保留策略
import java.lang.annotation.RetentionPolicy; // 导入 RetentionPolicy 类,定义注解的保留策略
import java.lang.annotation.Target; // 导入 Target 类,用于指定注解的适用范围
/**
*
* @author bool
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Dict {
@Target(ElementType.FIELD) // 指定该注解可以应用于字段(类的属性)
@Retention(RetentionPolicy.RUNTIME) // 指定该注解在运行时仍然可用
public @interface Dict { // 定义一个名为 Dict 的注解
String dicCode();
String dicCode(); // 定义一个抽象方法 dicCode返回数据字典的代码
String dicText() default "";
String dicText() default ""; // 定义一个抽象方法 dicText返回数据字典的文本默认为空字符串
String dictTable() default "";
String dictTable() default ""; // 定义一个抽象方法 dictTable返回数据字典的表名默认为空字符串
}

@ -1,67 +1,63 @@
package com.yf.exam.core.api;
package com.yf.exam.core.api; // 定义包名
import lombok.AllArgsConstructor; // 导入Lombok的全参构造器注解
import lombok.NoArgsConstructor; // 导入Lombok的无参构造器注解
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.io.Serializable; // 导入Serializable接口
/**
*
* 使
* @author bool
* @date 2019-06-14 21:15
* // 类注释,说明该类的用途
* 使 // 说明枚举命名规则
* @author bool // 作者信息
* @date 2019-06-14 21:15 // 日期信息
*/
@NoArgsConstructor
@AllArgsConstructor
public enum ApiError implements Serializable {
@NoArgsConstructor // 生成无参构造器
@AllArgsConstructor // 生成全参构造器
public enum ApiError implements Serializable { // 定义ApiError枚举实现Serializable接口
/**
*
*/
ERROR_10010001("参数不全或类型错误!"),
ERROR_10010002("您还未登录,请先登录!"),
ERROR_10010003("数据不存在!"),
ERROR_10010012("图形验证码错误!"),
ERROR_10010013("短信验证码错误!"),
ERROR_10010014("不允许重复评论!"),
ERROR_10010001("参数不全或类型错误!"), // 错误码10010001及其对应的消息
ERROR_10010002("您还未登录,请先登录!"), // 错误码10010002及其对应的消息
ERROR_10010003("数据不存在!"), // 错误码10010003及其对应的消息
ERROR_10010012("图形验证码错误!"), // 错误码10010012及其对应的消息
ERROR_10010013("短信验证码错误!"), // 错误码10010013及其对应的消息
ERROR_10010014("不允许重复评论!"), // 错误码10010014及其对应的消息
/**
*
*/
ERROR_20010001("试题被删除,无法继续考试!"),
ERROR_20010002("您有正在进行的考试!"),
ERROR_90010001("账号不存在,请确认!"),
ERROR_90010002("账号或密码错误!"),
ERROR_90010003("至少要包含一个角色!"),
ERROR_90010004("管理员账号无法修改!"),
ERROR_90010005("账号被禁用,请联系管理员!"),
ERROR_90010006("活动用户不足,无法开启竞拍!"),
ERROR_90010007("旧密码不正确,请确认!"),
ERROR_20010001("试题被删除,无法继续考试!"), // 错误码20010001及其对应的消息
ERROR_20010002("您有正在进行的考试!"), // 错误码20010002及其对应的消息
ERROR_90010001("账号不存在,请确认!"), // 错误码90010001及其对应的消息
ERROR_90010002("账号或密码错误!"), // 错误码90010002及其对应的消息
ERROR_90010003("至少要包含一个角色!"), // 错误码90010003及其对应的消息
ERROR_90010004("管理员账号无法修改!"), // 错误码90010004及其对应的消息
ERROR_90010005("账号被禁用,请联系管理员!"), // 错误码90010005及其对应的消息
ERROR_90010006("活动用户不足,无法开启竞拍!"), // 错误码90010006及其对应的消息
ERROR_90010007("旧密码不正确,请确认!"), // 错误码90010007及其对应的消息
ERROR_60000001("数据不存在!");
ERROR_60000001("数据不存在!"); // 错误码60000001及其对应的消息
public String msg;
public String msg; // 定义错误消息字段
/**
* Markdown
* @param args
* Markdown // 方法注释,说明该方法的用途
* @param args // 参数说明
*/
public static void main(String[] args) {
for (ApiError e : ApiError.values()) {
System.out.println("'"+e.name().replace("ERROR_", "")+"':'"+e.msg+"',");
public static void main(String[] args) { // 主方法
for (ApiError e : ApiError.values()) { // 遍历所有ApiError枚举值
System.out.println("'"+e.name().replace("ERROR_", "")+"':'"+e.msg+"',"); // 输出错误码和消息
}
}
/**
*
* @return
* // 方法注释,说明该方法的用途
* @return // 返回值说明
*/
public Integer getCode(){
return Integer.parseInt(this.name().replace("ERROR_", ""));
public Integer getCode(){ // 获取错误码的方法
return Integer.parseInt(this.name().replace("ERROR_", "")); // 返回去掉"ERROR_"前缀的整数值
}
}

@ -1,64 +1,64 @@
package com.yf.exam.core.api;
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;
import com.yf.exam.core.api.ApiError; // 导入ApiError类
import com.yf.exam.core.exception.ServiceException; // 导入ServiceException类
import io.swagger.annotations.ApiModel; // 导入ApiModel注解
import io.swagger.annotations.ApiModelProperty; // 导入ApiModelProperty注解
import lombok.Data; // 导入Data注解
import lombok.NoArgsConstructor; // 导入NoArgsConstructor注解
/**
*
* @author bool
* @date 2018/11/20 09:48
*/
@Data
@NoArgsConstructor
@ApiModel(value="接口响应", description="接口响应")
public class ApiRest<T>{
@Data // 自动生成getter、setter、toString等方法
@NoArgsConstructor // 自动生成无参构造函数
@ApiModel(value="接口响应", description="接口响应") // Swagger注解描述API模型
public class ApiRest<T>{ // 定义泛型类ApiRest
/**
*
*/
@ApiModelProperty(value = "响应消息")
private String msg;
@ApiModelProperty(value = "响应消息") // Swagger注解描述响应消息属性
private String msg; // 响应消息
/**
*
*/
@ApiModelProperty(value = "响应代码,0为成功,1为失败", required = true)
private Integer code;
@ApiModelProperty(value = "响应代码,0为成功,1为失败", required = true) // Swagger注解描述响应代码属性
private Integer code; // 响应代码
/**
* body
*/
@ApiModelProperty(value = "响应内容")
protected T data;
@ApiModelProperty(value = "响应内容") // Swagger注解描述响应内容属性
protected T data; // 响应内容
/**
*
* @return
*/
public boolean isSuccess(){
return code.equals(0);
public boolean isSuccess(){ // 判断请求是否成功
return code.equals(0); // 如果响应代码为0返回true
}
/**
*
* @param error
*/
public ApiRest(ServiceException error){
this.code = error.getCode();
this.msg = error.getMsg();
public ApiRest(ServiceException error){ // 构造函数接收ServiceException对象
this.code = error.getCode(); // 设置响应代码
this.msg = error.getMsg(); // 设置响应消息
}
/**
*
* @param error
*/
public ApiRest(ApiError error){
this.code = error.getCode();
this.msg = error.msg;
public ApiRest(ApiError error){ // 构造函数接收ApiError对象
this.code = error.getCode(); // 设置响应代码
this.msg = error.msg; // 设置响应消息
}
}

@ -1,154 +1,150 @@
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;
// 导入所需的类
import com.yf.exam.core.api.ApiError; // 导入ApiError类用于处理API错误
import com.yf.exam.core.api.ApiRest; // 导入ApiRest类用于构建API响应
import com.yf.exam.core.exception.ServiceException; // 导入ServiceException类用于处理服务异常
/**
*
* API
* @author Dav
*/
public class BaseController {
/**
*
* CODE_SUCCESS
*/
private static final Integer CODE_SUCCESS = 0;
private static final String MSG_SUCCESS = "操作成功!";
private static final Integer CODE_SUCCESS = 0; // 定义成功状态码
private static final String MSG_SUCCESS = "操作成功!"; // 定义成功消息
/**
*
* CODE_FAILURE
*/
private static final Integer CODE_FAILURE = 1;
private static final String MSG_FAILURE = "请求失败!";
private static final Integer CODE_FAILURE = 1; // 定义失败状态码
private static final String MSG_FAILURE = "请求失败!"; // 定义失败消息
/**
*
* @param code
* @param message
* @param data
* @param <T>
* @return
* @param code
* @param message
* @param data
* @param <T>
* @return ApiRest<T> API
*/
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);
ApiRest<T> response = new ApiRest<>(); // 创建ApiRest对象
response.setCode(code); // 设置状态码
response.setMsg(message); // 设置消息内容
if(data!=null) { // 如果数据不为空
response.setData(data); // 设置响应数据
}
return response;
return response; // 返回构造好的响应
}
/**
*
* @param <T>
* @return
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> success(){
return message(0, "请求成功!", null);
return message(0, "请求成功!", null); // 调用message方法构造成功响应
}
/**
*
* @param message
* @param data
* @param <T>
* @return
* @param message
* @param data
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> success(String message, T data){
return message(CODE_SUCCESS, message, data);
return message(CODE_SUCCESS, message, data); // 调用message方法构造成功响应
}
/**
*
* @param data
* @param <T>
* @return
* @param data
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> success(T data){
return message(CODE_SUCCESS, MSG_SUCCESS, data);
return message(CODE_SUCCESS, MSG_SUCCESS, data); // 调用message方法构造成功响应
}
/**
*
* @param code
* @param message
* @param data
* @param <T>
* @return
* @param code
* @param message
* @param data
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> failure(Integer code, String message, T data){
return message(code, message, data);
return message(code, message, data); // 调用message方法构造失败响应
}
/**
*
* @param message
* @param data
* @param <T>
* @return
* @param message
* @param data
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> failure(String message, T data){
return message(CODE_FAILURE, message, data);
return message(CODE_FAILURE, message, data); // 调用message方法构造失败响应
}
/**
*
* @param message
* @return
* @param message
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> failure(String message){
return message(CODE_FAILURE, message, null);
return message(CODE_FAILURE, message, null); // 调用message方法构造失败响应
}
/**
*
* @param data
* @param <T>
* @return
* @param data
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> failure(T data){
return message(CODE_FAILURE, MSG_FAILURE, data);
return message(CODE_FAILURE, MSG_FAILURE, data); // 调用message方法构造失败响应
}
/**
*
* @param <T>
* @return
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> failure(){
return message(CODE_FAILURE, MSG_FAILURE, null);
return message(CODE_FAILURE, MSG_FAILURE, null); // 调用message方法构造失败响应
}
/**
*
* @param <T>
* @return
* @param error ApiError
* @param data
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> failure(ApiError error, T data){
return message(error.getCode(), error.msg, data);
return message(error.getCode(), error.msg, data); // 调用message方法构造失败响应
}
/**
*
* @param ex
* @param <T>
* @return
* @param ex ServiceException
* @param <T>
* @return ApiRest<T> API
*/
protected <T> ApiRest<T> failure(ServiceException ex){
ApiRest<T> apiRest = message(ex.getCode(), ex.getMsg(), null);
return apiRest;
ApiRest<T> apiRest = message(ex.getCode(), ex.getMsg(), null); // 调用message方法构造失败响应
return apiRest; // 返回构造好的响应
}
}

@ -1,7 +1,10 @@
// 包声明,定义该类所在的包
package com.yf.exam.core.api.dto;
// 导入lombok库中的@Data注解用于自动生成getter、setter等方法
import lombok.Data;
// 导入Serializable接口用于对象序列化
import java.io.Serializable;
/**
@ -9,7 +12,11 @@ import java.io.Serializable;
* @author dav
* @date 2019/3/16 15:56
*/
// 使用@Data注解自动生成该类的getter、setter等方法
@Data
// 定义一个名为BaseDTO的公共类实现Serializable接口
public class BaseDTO implements Serializable {
// 该类目前没有任何字段或方法
}

@ -1,28 +1,28 @@
package com.yf.exam.core.api.dto;
// 文件路径: yfexam-exam-main/yfexam-exam-main/exam-api/src/main/java/com/yf/exam/core/api/dto/BaseIdReqDTO.java
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 com.yf.exam.core.api.dto.BaseDTO; // 导入BaseDTO类BaseIdReqDTO类将继承自它
import com.fasterxml.jackson.annotation.JsonIgnore; // 导入JsonIgnore注解用于在序列化时忽略某个字段
import io.swagger.annotations.ApiModel; // 导入ApiModel注解用于Swagger文档生成
import io.swagger.annotations.ApiModelProperty; // 导入ApiModelProperty注解用于Swagger文档生成
import lombok.Data; // 导入Lombok的Data注解用于自动生成getter、setter等方法
/**
* <p>
* ID
* </p>
*
* @author
* @since 2019-04-20 12:15
* @author // 类的作者信息
* @since 2019-04-20 12:15 // 类的创建时间
*/
@Data
@ApiModel(value="主键通用请求类", description="主键通用请求类")
public class BaseIdReqDTO extends BaseDTO {
@Data // 使用Lombok的Data注解自动生成toString、equals、hashCode、getter和setter方法
@ApiModel(value="主键通用请求类", description="主键通用请求类") // Swagger文档中显示的模型信息
public class BaseIdReqDTO extends BaseDTO { // 定义BaseIdReqDTO类继承自BaseDTO
@ApiModelProperty(value = "主键ID", required=true)
private String id;
@JsonIgnore
private String userId;
@ApiModelProperty(value = "主键ID", required=true) // Swagger文档中显示的属性信息表示该字段是必需的
private String id; // 定义主键ID字段
@JsonIgnore // 在序列化时忽略该字段不会被JSON输出
private String userId; // 定义用户ID字段通常用于内部逻辑不需要暴露给外部
}

@ -1,26 +1,28 @@
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 com.yf.exam.core.api.dto.BaseDTO; // 导入基础DTO类
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于API文档生成
import lombok.AllArgsConstructor; // 导入Lombok注解用于生成全参构造函数
import lombok.Data; // 导入Lombok注解用于自动生成getter、setter等方法
import lombok.NoArgsConstructor; // 导入Lombok注解用于生成无参构造函数
/**
* <p>
*
* ID
* </p>
*
* @author
* @since 2019-04-20 12:15
*/
@Data
@ApiModel(value="主键通用响应类", description="主键通用响应类")
@AllArgsConstructor
@NoArgsConstructor
public class BaseIdRespDTO extends BaseDTO {
@Data // 自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="主键通用响应类", description="主键通用响应类") // Swagger注解描述该类的用途
@AllArgsConstructor // 自动生成全参构造函数
@NoArgsConstructor // 自动生成无参构造函数
public class BaseIdRespDTO extends BaseDTO { // 继承自BaseDTO类
@ApiModelProperty(value = "主键ID", required=true)
private String id;
@ApiModelProperty(value = "主键ID", required=true) // Swagger注解描述id属性
private String id; // 主键ID属性必填
}

@ -1,26 +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 com.yf.exam.core.api.dto.BaseDTO; // 导入基础DTO类
import com.fasterxml.jackson.annotation.JsonIgnore; // 导入JsonIgnore注解用于序列化时忽略字段
import io.swagger.annotations.ApiModel; // 导入ApiModel注解用于Swagger文档生成
import io.swagger.annotations.ApiModelProperty; // 导入ApiModelProperty注解用于Swagger文档生成
import lombok.Data; // 导入Lombok的Data注解用于自动生成getter、setter等方法
import java.util.List;
import java.util.List; // 导入List类用于定义ID列表
/**
* ID
* IDID便API
* @author bool
* @date 2019-08-01 19:07
*/
@Data
@ApiModel(value="删除参数", description="删除参数")
public class BaseIdsReqDTO extends BaseDTO {
@Data // Lombok注解自动生成getter、setter、toString等方法
@ApiModel(value="删除参数", description="删除参数") // Swagger注解描述该类的用途
public class BaseIdsReqDTO extends BaseDTO { // 继承自BaseDTO类
@JsonIgnore // 在序列化时忽略该字段
private String userId; // 用户ID通常用于标识请求的用户
@JsonIgnore
private String userId;
@ApiModelProperty(value = "要删除的ID列表", required = true)
private List<String> ids;
@ApiModelProperty(value = "要删除的ID列表", required = true) // Swagger注解描述该字段
private List<String> ids; // 要删除的ID列表必填项
}

@ -1,32 +1,32 @@
package com.yf.exam.core.api.dto;
// 文件路径: yfexam-exam-main/yfexam-exam-main/exam-api/src/main/java/com/yf/exam/core/api/dto/BaseStateReqDTO.java
package com.yf.exam.core.api.dto; // 定义包名表示该类属于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 com.yf.exam.core.api.dto.BaseDTO; // 导入BaseDTO类BaseStateReqDTO类将继承自它
import io.swagger.annotations.ApiModel; // 导入ApiModel注解用于Swagger文档生成
import io.swagger.annotations.ApiModelProperty; // 导入ApiModelProperty注解用于Swagger文档生成
import lombok.AllArgsConstructor; // 导入Lombok库的AllArgsConstructor注解自动生成全参构造函数
import lombok.Data; // 导入Lombok库的Data注解自动生成getter、setter、toString等方法
import lombok.NoArgsConstructor; // 导入Lombok库的NoArgsConstructor注解自动生成无参构造函数
import java.util.List;
import java.util.List; // 导入List类用于定义ID列表
/**
* <p>
*
* </p>
*
* @author
* @since 2019-04-20 12:15
* @author // 类的作者
* @since 2019-04-20 12:15 // 类的创建时间
*/
@Data
@ApiModel(value="通用状态请求类", description="通用状态请求类")
@AllArgsConstructor
@NoArgsConstructor
public class BaseStateReqDTO extends BaseDTO {
@Data // 自动生成getter、setter、toString等方法
@ApiModel(value="通用状态请求类", description="通用状态请求类") // Swagger文档中类的描述
@AllArgsConstructor // 自动生成全参构造函数
@NoArgsConstructor // 自动生成无参构造函数
public class BaseStateReqDTO extends BaseDTO { // 定义BaseStateReqDTO类继承自BaseDTO
@ApiModelProperty(value = "要修改对象的ID列表", required=true) // Swagger文档中属性的描述表示该属性为必填项
private List<String> ids; // 定义一个ID列表用于存储要修改对象的ID
@ApiModelProperty(value = "要修改对象的ID列表", required=true)
private List<String> ids;
@ApiModelProperty(value = "通用状态0为正常1为禁用", required=true)
private Integer state;
@ApiModelProperty(value = "通用状态0为正常1为禁用", required=true) // Swagger文档中属性的描述表示该属性为必填项
private Integer state; // 定义一个状态字段0表示正常1表示禁用
}

@ -1,47 +1,44 @@
package com.yf.exam.core.api.dto;
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;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入MyBatis分页类
import com.fasterxml.jackson.annotation.JsonIgnore; // 导入Jackson注解用于忽略字段
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于API文档
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于API文档属性
import lombok.Data; // 导入Lombok注解用于自动生成getter和setter
/**
*
* @param <T>
* @param <T>
* @author bool
*/
@ApiModel(value="分页参数", description="分页参数")
@Data
public class PagingReqDTO<T> {
@ApiModel(value="分页参数", description="分页参数") // Swagger模型注解
@Data // Lombok注解自动生成getter、setter、toString等方法
public class PagingReqDTO<T> { // 定义分页请求DTO类使用泛型T
@ApiModelProperty(value = "当前页码", required = true, example = "1") // Swagger属性注解
private Integer current; // 当前页码
@ApiModelProperty(value = "当前页码", required = true, example = "1")
private Integer current;
@ApiModelProperty(value = "每页数量", required = true, example = "10") // Swagger属性注解
private Integer size; // 每页数量
@ApiModelProperty(value = "每页数量", required = true, example = "10")
private Integer size;
@ApiModelProperty(value = "查询参数") // Swagger属性注解
private T params; // 查询参数类型为泛型T
@ApiModelProperty(value = "查询参数")
private T params;
@ApiModelProperty(value = "排序字符") // Swagger属性注解
private String orderBy; // 排序字段
@ApiModelProperty(value = "排序字符")
private String orderBy;
@JsonIgnore
@ApiModelProperty(value = "当前用户的ID")
private String userId;
@JsonIgnore // Jackson注解忽略该字段
@ApiModelProperty(value = "当前用户的ID") // Swagger属性注解
private String userId; // 当前用户的ID
/**
* MyBatis
* @return
* @return MyBatisPage
*/
public Page toPage(){
Page page = new Page();
page.setCurrent(this.current);
page.setSize(this.size);
return page;
public Page toPage(){ // 定义转换方法
Page page = new Page(); // 创建Page对象
page.setCurrent(this.current); // 设置当前页码
page.setSize(this.size); // 设置每页数量
return page; // 返回Page对象
}
}

@ -1,29 +1,29 @@
package com.yf.exam.core.api.dto;
package com.yf.exam.core.api.dto; // 定义包名
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入分页类
/**
*
* @author bool
* @date 2019-07-20 15:17
* @param <T>
* @param <T>
*/
public class PagingRespDTO<T> extends Page<T> {
public class PagingRespDTO<T> extends Page<T> { // 定义分页响应类继承自Page类
/**
*
* @return
* @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;
public long getPages() { // 重写getPages方法
if (this.getSize() == 0L) { // 如果每页大小为0
return 0L; // 返回0
} else { // 否则
long pages = this.getTotal() / this.getSize(); // 计算总页数
if (this.getTotal() % this.getSize() != 0L) { // 如果总数不能被每页大小整除
++pages; // 页数加1
}
return pages;
return pages; // 返回总页数
}
}

@ -1,48 +1,48 @@
package com.yf.exam.core.api.utils;
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 com.alibaba.fastjson.serializer.SerializerFeature; // 导入FastJson序列化特性
import com.alibaba.fastjson.support.config.FastJsonConfig; // 导入FastJson配置类
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter; // 导入FastJson消息转换器
import org.springframework.http.MediaType; // 导入媒体类型类
import org.springframework.http.converter.HttpMessageConverter; // 导入HTTP消息转换器接口
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.nio.charset.Charset; // 导入字符集类
import java.util.ArrayList; // 导入ArrayList类
import java.util.List; // 导入List接口
/**
* JSON
* @author dav
* @date 2018/9/11 19:30
*/
public class JsonConverter {
public class JsonConverter { // 定义JsonConverter类
/**
* FastJson
*
* @return
* @return HttpMessageConverter
*/
public static HttpMessageConverter fastConverter() {
public static HttpMessageConverter fastConverter() { // 定义静态方法fastConverter
// 定义一个convert转换消息的对象
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter(); // 创建FastJson消息转换器实例
// 添加FastJson的配置信息
FastJsonConfig fastJsonConfig = new FastJsonConfig();
FastJsonConfig fastJsonConfig = new FastJsonConfig(); // 创建FastJson配置实例
// 默认转换器
fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat,
SerializerFeature.WriteNullNumberAsZero,
SerializerFeature.MapSortField,
SerializerFeature.WriteNullStringAsEmpty,
SerializerFeature.DisableCircularReferenceDetect,
SerializerFeature.WriteDateUseDateFormat,
SerializerFeature.WriteNullListAsEmpty);
fastJsonConfig.setCharset(Charset.forName("UTF-8"));
fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat, // 设置序列化特性:格式化输出
SerializerFeature.WriteNullNumberAsZero, // 将null数字写为0
SerializerFeature.MapSortField, // 对Map进行排序
SerializerFeature.WriteNullStringAsEmpty, // 将null字符串写为空
SerializerFeature.DisableCircularReferenceDetect, // 禁用循环引用检测
SerializerFeature.WriteDateUseDateFormat, // 使用日期格式化
SerializerFeature.WriteNullListAsEmpty); // 将null列表写为空列表
fastJsonConfig.setCharset(Charset.forName("UTF-8")); // 设置字符集为UTF-8
// 处理中文乱码问题
List<MediaType> fastMediaTypes = new ArrayList<>();
fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
fastConverter.setSupportedMediaTypes(fastMediaTypes);
List<MediaType> fastMediaTypes = new ArrayList<>(); // 创建媒体类型列表
fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8); // 添加支持的媒体类型UTF-8 JSON
fastConverter.setSupportedMediaTypes(fastMediaTypes); // 设置支持的媒体类型
// 在convert中添加配置信息
fastConverter.setFastJsonConfig(fastJsonConfig);
fastConverter.setFastJsonConfig(fastJsonConfig); // 设置FastJson配置
return fastConverter;
}
}
return fastConverter; // 返回FastJson消息转换器
} // 结束fastConverter方法
} // 结束JsonConverter类

@ -1,19 +1,21 @@
package com.yf.exam.core.enums;
// 文件路径: yfexam-exam-main/yfexam-exam-main/exam-api/src/main/java/com/yf/exam/core/enums/CommonState.java
package com.yf.exam.core.enums; // 定义包名
/**
*
*
* @author bool
* @date 2019-09-17 17:57
* @author bool // 作者信息
* @date 2019-09-17 17:57 // 日期信息
*/
public interface CommonState {
public interface CommonState { // 定义一个公共接口
/**
*
*/
Integer NORMAL = 0;
Integer NORMAL = 0; // 定义正常状态的常量值为0
/**
*
*/
Integer ABNORMAL = 1;
Integer ABNORMAL = 1; // 定义非正常状态的常量值为1
}

@ -1,18 +1,19 @@
package com.yf.exam.core.enums;
// 文件路径: yfexam-exam-main/yfexam-exam-main/exam-api/src/main/java/com/yf/exam/core/enums/OpenType.java
package com.yf.exam.core.enums; // 定义包名
/**
*
* @author bool
*/
public interface OpenType {
public interface OpenType { // 定义接口 OpenType
/**
*
*/
Integer OPEN = 1;
Integer OPEN = 1; // 定义常量 OPEN值为 1
/**
*
*/
Integer DEPT_OPEN = 2;
Integer DEPT_OPEN = 2; // 定义常量 DEPT_OPEN值为 2
}

@ -1,51 +1,52 @@
package com.yf.exam.core.exception;
// 文件路径: yfexam-exam-main/yfexam-exam-main/exam-api/src/main/java/com/yf/exam/core/exception/ServiceException.java
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;
import com.yf.exam.core.api.ApiError; // 导入ApiError类
import com.yf.exam.core.api.ApiRest; // 导入ApiRest类
import lombok.AllArgsConstructor; // 导入AllArgsConstructor注解
import lombok.Data; // 导入Data注解
import lombok.NoArgsConstructor; // 导入NoArgsConstructor注解
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ServiceException extends RuntimeException{
@Data // 自动生成getter、setter、toString等方法
@AllArgsConstructor // 生成包含所有字段的构造函数
@NoArgsConstructor // 生成无参构造函数
public class ServiceException extends RuntimeException{ // 定义ServiceException类继承RuntimeException
/**
*
*/
private Integer code;
private Integer code; // 定义错误码字段
/**
*
*/
private String msg;
private String msg; // 定义错误消息字段
/**
*
* @param apiRest
*/
public ServiceException(ApiRest apiRest){
this.code = apiRest.getCode();
this.msg = apiRest.getMsg();
public ServiceException(ApiRest apiRest){ // 构造函数接受ApiRest对象
this.code = apiRest.getCode(); // 初始化错误码
this.msg = apiRest.getMsg(); // 初始化错误消息
}
/**
*
* @param apiError
*/
public ServiceException(ApiError apiError){
this.code = apiError.getCode();
this.msg = apiError.msg;
public ServiceException(ApiError apiError){ // 构造函数接受ApiError对象
this.code = apiError.getCode(); // 初始化错误码
this.msg = apiError.msg; // 初始化错误消息
}
/**
*
* @param msg
*/
public ServiceException(String msg){
this.code = 1;
this.msg = msg;
public ServiceException(String msg){ // 构造函数,接受错误消息
this.code = 1; // 默认错误码为1
this.msg = msg; // 初始化错误消息
}
}

@ -1,46 +1,46 @@
package com.yf.exam.core.exception;
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.*;
import com.yf.exam.core.api.ApiRest; // 导入ApiRest类
import org.springframework.http.HttpStatus; // 导入HttpStatus类
import org.springframework.ui.Model; // 导入Model类
import org.springframework.web.bind.WebDataBinder; // 导入WebDataBinder类
import org.springframework.web.bind.annotation.*; // 导入所有注解
/**
*
* @author bool
* @date 2019-06-21 19:27
*/
@RestControllerAdvice
public class ServiceExceptionHandler {
@RestControllerAdvice // 声明这是一个全局异常处理类
public class ServiceExceptionHandler { // 定义ServiceExceptionHandler类
/**
* @RequestMapping
* @param binder
* @param binder
*/
@InitBinder
public void initWebBinder(WebDataBinder binder){
@InitBinder // 初始化数据绑定器
public void initWebBinder(WebDataBinder binder){ // 定义初始化方法
// 这里可以添加自定义的初始化逻辑
}
/**
* Model使@RequestMapping
* @param model
* @param model
*/
@ModelAttribute
public void addAttribute(Model model) {
@ModelAttribute // 将方法的返回值绑定到模型中
public void addAttribute(Model model) { // 定义添加属性的方法
// 这里可以添加需要绑定到模型的属性
}
/**
* ServiceException
* @param e
* @return
* @param e
* @return ApiRest API
*/
@ExceptionHandler({com.yf.exam.core.exception.ServiceException.class})
@ResponseStatus(HttpStatus.OK)
public ApiRest serviceExceptionHandler(ServiceException e) {
return new ApiRest(e);
@ExceptionHandler({com.yf.exam.core.exception.ServiceException.class}) // 指定捕获的异常类型
@ResponseStatus(HttpStatus.OK) // 设置响应状态为200 OK
public ApiRest serviceExceptionHandler(ServiceException e) { // 定义异常处理方法
return new ApiRest(e); // 返回ApiRest对象包含异常信息
}
}

@ -1,13 +1,12 @@
package com.yf.exam.core.utils;
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;
import org.dozer.DozerBeanMapper; // 导入DozerBeanMapper类
import java.util.ArrayList; // 导入ArrayList类
import java.util.Collection; // 导入Collection接口
import java.util.List; // 导入List接口
import java.util.function.Function; // 导入Function接口
import java.util.stream.Collectors; // 导入Collectors类
/**
* Dozer, Bean<->BeanMapper.:
@ -18,42 +17,42 @@ import java.util.stream.Collectors;
* 4. BAB.
*
*/
public class BeanMapper {
public class BeanMapper { // 定义BeanMapper类
/**
* Dozer, DozerMapper.
*/
private static DozerBeanMapper dozerBeanMapper = new DozerBeanMapper();
private static DozerBeanMapper dozerBeanMapper = new DozerBeanMapper(); // 创建DozerBeanMapper的单例
/**
* Dozer.
*/
public static <T> T map(Object source, Class<T> destinationClass) {
return dozerBeanMapper.map(source, destinationClass);
public static <T> T map(Object source, Class<T> destinationClass) { // 定义map方法转换对象类型
return dozerBeanMapper.map(source, destinationClass); // 使用Dozer进行对象转换
}
/**
* 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);
public static <T> List<T> mapList(Iterable<?> sourceList, Class<T> destinationClass) { // 定义mapList方法转换集合中的对象
List<T> destinationList = new ArrayList(); // 创建目标列表
for (Object sourceObject : sourceList) { // 遍历源列表中的每个对象
T destinationObject = dozerBeanMapper.map(sourceObject, destinationClass); // 转换对象
destinationList.add(destinationObject); // 将转换后的对象添加到目标列表
}
return destinationList;
return destinationList; // 返回目标列表
}
/**
* DozerAB.
*/
public static void copy(Object source, Object destinationObject) {
if(source!=null) {
dozerBeanMapper.map(source, destinationObject);
public static void copy(Object source, Object destinationObject) { // 定义copy方法拷贝对象A的值到对象B
if(source!=null) { // 检查源对象是否为null
dozerBeanMapper.map(source, destinationObject); // 使用Dozer进行值拷贝
}
}
public static <T, S> List<T> mapList(Collection<S> source, Function<? super S, ? extends T> mapper) {
return source.stream().map(mapper).collect(Collectors.toList());
public static <T, S> List<T> mapList(Collection<S> source, Function<? super S, ? extends T> mapper) { // 定义重载的mapList方法使用自定义映射函数
return source.stream().map(mapper).collect(Collectors.toList()); // 使用流和映射函数转换集合并返回列表
}
}

@ -1,31 +1,32 @@
package com.yf.exam.core.utils;
language:yfexam-exam-main/yfexam-exam-main/exam-api/src/main/java/com/yf/exam/core/utils/CronUtils.java
package com.yf.exam.core.utils; // 包声明,定义了类的包路径
import java.text.SimpleDateFormat;
import java.util.Date;
import java.text.SimpleDateFormat; // 导入用于格式化日期的类
import java.util.Date; // 导入日期类
/**
* quartz
* @author bool
* @date 2020/11/29 3:00
* @author bool // 作者信息
* @date 2020/11/29 3:00 // 日期信息
*/
public class CronUtils {
public class CronUtils { // 定义CronUtils类
/**
*
*/
private static final String DATE_FORMAT = "ss mm HH dd MM ? yyyy";
private static final String DATE_FORMAT = "ss mm HH dd MM ? yyyy"; // 定义日期格式的常量
/**
*
* @param date
* @return
* @param date // 输入的日期
* @return // 返回格式化后的cron表达式
*/
public static String dateToCron(final Date date){
SimpleDateFormat fmt = new SimpleDateFormat(DATE_FORMAT);
String formatTimeStr = "";
if (date != null) {
formatTimeStr = fmt.format(date);
public static String dateToCron(final Date date){ // 定义静态方法将日期转换为cron表达式
SimpleDateFormat fmt = new SimpleDateFormat(DATE_FORMAT); // 创建SimpleDateFormat对象
String formatTimeStr = ""; // 初始化格式化后的时间字符串
if (date != null) { // 检查日期是否为null
formatTimeStr = fmt.format(date); // 格式化日期
}
return formatTimeStr;
return formatTimeStr; // 返回格式化后的字符串
}
}

@ -1,9 +1,9 @@
package com.yf.exam.core.utils;
package com.yf.exam.core.utils; // 包声明,定义该类所在的包
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.text.SimpleDateFormat; // 导入用于日期格式化的类
import java.util.Calendar; // 导入日历类
import java.util.Date; // 导入日期类
import java.util.GregorianCalendar; // 导入公历日历类
/**
*
@ -13,27 +13,27 @@ import java.util.GregorianCalendar;
* @author Bool
* @version
*/
public class DateUtils {
public class DateUtils { // 定义DateUtils类
/**
*
* calcExpDays: <br/>
* @author Bool
* @param userCreateTime
* @return
* @param userCreateTime
* @return
* @since JDK 1.6
*/
public static int calcExpDays(Date userCreateTime){
public static int calcExpDays(Date userCreateTime){ // 计算日期差异的方法
Calendar start = Calendar.getInstance();
start.setTime(userCreateTime);
Calendar start = Calendar.getInstance(); // 获取当前日历实例
start.setTime(userCreateTime); // 设置开始时间为用户创建时间
Calendar now = Calendar.getInstance();
now.setTime(new Date());
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;
long l = now.getTimeInMillis() - start.getTimeInMillis(); // 计算时间差(毫秒)
int days = new Long(l / (1000 * 60 * 60 * 24)).intValue(); // 将毫秒转换为天数
return days; // 返回天数
}
@ -42,36 +42,34 @@ public class DateUtils {
* dateNow:. <br/>
* @author Bool
* @param format
* @return
* @return
*/
public static String dateNow(String format) {
SimpleDateFormat fmt = new SimpleDateFormat(format);
Calendar c = new GregorianCalendar();
return fmt.format(c.getTime());
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
* @param time
* @param format
* @return
*/
public static String formatDate(Date time, String format) {
SimpleDateFormat fmt = new SimpleDateFormat(format);
return fmt.format(time.getTime());
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
* @param date
* @return
*/
public static Date parseDate(String date) {
return parseDate(date, "yyyy-MM-dd HH:mm:ss");
public static Date parseDate(String date) { // 将字符串解析为日期的方法
return parseDate(date, "yyyy-MM-dd HH:mm:ss"); // 使用默认格式解析
}
@ -79,25 +77,23 @@ public class DateUtils {
*
* parseDate:使
* @author Bool
* @param date
* @param pattern
* @return
* @param date
* @param pattern
* @return
*/
public static Date parseDate(String date, String pattern) {
public static Date parseDate(String date, String pattern) { // 使用指定格式解析字符串为日期
if (pattern==null) {
pattern = "yyyy-MM-dd HH:mm:ss";
if (pattern==null) { // 如果未指定格式
pattern = "yyyy-MM-dd HH:mm:ss"; // 使用默认格式
}
SimpleDateFormat fmt = new SimpleDateFormat(pattern);
SimpleDateFormat fmt = new SimpleDateFormat(pattern); // 创建日期格式化对象
try {
return fmt.parse(date);
} catch (Exception ex) {
ex.printStackTrace();
return fmt.parse(date); // 尝试解析日期字符串
} catch (Exception ex) { // 捕获异常
ex.printStackTrace(); // 打印异常堆栈
}
return null;
return null; // 返回null表示解析失败
}
}

@ -1,7 +1,6 @@
package com.yf.exam.core.utils;
package com.yf.exam.core.utils; // 定义包名
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest类
/**
* IPIP
@ -11,55 +10,52 @@ import javax.servlet.http.HttpServletRequest;
* @author Bool
* @version
*/
public class IpUtils {
public class IpUtils { // 定义IpUtils类
/**
*
* getClientIp:IP
* @author Bool
* @param request
* @return
* @param request HttpServletRequest
* @return IP
*/
public static String extractClientIp(HttpServletRequest request) {
public static String extractClientIp(HttpServletRequest request) { // 定义静态方法extractClientIp接收HttpServletRequest参数
String ip = null;
String ip = null; // 初始化ip变量为null
//X-Forwarded-ForSquid 服务代理
String ipAddresses = request.getHeader("X-Forwarded-For");
String ipAddresses = request.getHeader("X-Forwarded-For"); // 获取请求头中的X-Forwarded-For字段
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) { // 检查ipAddresses是否为空或未知
//Proxy-Client-IPapache 服务代理
ipAddresses = request.getHeader("Proxy-Client-IP");
ipAddresses = request.getHeader("Proxy-Client-IP"); // 获取Proxy-Client-IP字段
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) { // 检查ipAddresses是否为空或未知
//WL-Proxy-Client-IPweblogic 服务代理
ipAddresses = request.getHeader("WL-Proxy-Client-IP");
ipAddresses = request.getHeader("WL-Proxy-Client-IP"); // 获取WL-Proxy-Client-IP字段
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) { // 检查ipAddresses是否为空或未知
//HTTP_CLIENT_IP有些代理服务器
ipAddresses = request.getHeader("HTTP_CLIENT_IP");
ipAddresses = request.getHeader("HTTP_CLIENT_IP"); // 获取HTTP_CLIENT_IP字段
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) { // 检查ipAddresses是否为空或未知
//X-Real-IPnginx服务代理
ipAddresses = request.getHeader("X-Real-IP");
ipAddresses = request.getHeader("X-Real-IP"); // 获取X-Real-IP字段
}
//有些网络通过多层代理那么获取到的ip就会有多个一般都是通过逗号,分割开来并且第一个ip为客户端的真实IP
if (ipAddresses != null && ipAddresses.length() != 0) {
ip = ipAddresses.split(",")[0];
if (ipAddresses != null && ipAddresses.length() != 0) { // 检查ipAddresses是否不为空
ip = ipAddresses.split(",")[0]; // 通过逗号分割并获取第一个IP地址
}
//还是不能获取到最后再通过request.getRemoteAddr();获取
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ip = request.getRemoteAddr();
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) { // 检查ip是否为空或未知
ip = request.getRemoteAddr(); // 最后通过getRemoteAddr获取IP地址
}
return ip;
return ip; // 返回获取到的IP地址
}
}

@ -1,22 +1,22 @@
/**
* 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;
package com.yf.exam.core.utils; // 定义包名
import lombok.extern.log4j.Log4j2; // 引入Log4j2日志库
import org.apache.commons.lang3.StringUtils; // 引入Apache Commons Lang的StringUtils类
import org.apache.commons.lang3.Validate; // 引入Apache Commons Lang的Validate类
import org.springframework.util.Assert; // 引入Spring的Assert类
import java.lang.reflect.Field; // 引入反射中的Field类
import java.lang.reflect.InvocationTargetException; // 引入反射中的InvocationTargetException类
import java.lang.reflect.Method; // 引入反射中的Method类
import java.lang.reflect.Modifier; // 引入反射中的Modifier类
import java.lang.reflect.ParameterizedType; // 引入反射中的ParameterizedType类
import java.lang.reflect.Type; // 引入反射中的Type类
import java.util.ArrayList; // 引入ArrayList类
import java.util.Arrays; // 引入Arrays类
import java.util.List; // 引入List接口
/**
* .
@ -24,32 +24,32 @@ import java.util.List;
* @author calvin
* @version 2016-01-15
*/
@Log4j2
public class Reflections {
@Log4j2 // 使用Log4j2注解
public class Reflections { // 定义Reflections类
private static final String SETTER_PREFIX = "set";
private static final String SETTER_PREFIX = "set"; // 定义setter方法前缀
private static final String GETTER_PREFIX = "get";
private static final String GETTER_PREFIX = "get"; // 定义getter方法前缀
private static final String CGLIB_CLASS_SEPARATOR = "$$";
private static final String CGLIB_CLASS_SEPARATOR = "$$"; // 定义CGLIB类分隔符
/**
*
*
* @param object
* @return
* @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();
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;
Field[] fields = new Field[fieldList.size()]; // 创建字段数组
fieldList.toArray(fields); // 将列表转换为数组
return fields; // 返回字段数组
}
@ -57,29 +57,29 @@ public class Reflections {
* 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[] {});
public static Object invokeGetter(Object obj, String propertyName) { // 定义调用getter方法
Object object = obj; // 初始化对象
for (String name : StringUtils.split(propertyName, ".")){ // 分割属性名
String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name); // 生成getter方法名
object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {}); // 调用getter方法
}
return 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 });
public static void invokeSetter(Object obj, String propertyName, Object value) { // 定义调用setter方法
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]); // 生成getter方法名
object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {}); // 调用getter方法
}else{ // 如果是最后一个属性
String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(names[i]); // 生成setter方法名
invokeMethodByName(object, setterMethodName, new Object[] { value }); // 调用setter方法
}
}
}
@ -87,36 +87,36 @@ public class Reflections {
/**
* , private/protected, getter.
*/
public static Object getFieldValue(final Object obj, final String fieldName) {
Field field = getAccessibleField(obj, fieldName);
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 + "]");
if (field == null) { // 如果字段不存在
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]"); // 抛出异常
}
Object result = null;
Object result = null; // 初始化结果
try {
result = field.get(obj);
} catch (IllegalAccessException e) {
log.error("不可能抛出的异常{}", e.getMessage());
result = field.get(obj); // 获取字段值
} catch (IllegalAccessException e) { // 捕获非法访问异常
log.error("不可能抛出的异常{}", e.getMessage()); // 记录错误
}
return result;
return result; // 返回结果
}
/**
* , private/protected, setter.
*/
public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
Field field = getAccessibleField(obj, fieldName);
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 + "]");
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());
field.set(obj, value); // 设置字段值
} catch (IllegalAccessException e) { // 捕获非法访问异常
log.error("不可能抛出的异常:{}", e.getMessage()); // 记录错误
}
}
@ -126,16 +126,16 @@ public class Reflections {
* +
*/
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 + "]");
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);
return method.invoke(obj, args); // 调用方法并返回结果
} catch (Exception e) { // 捕获异常
throw convertReflectionExceptionToUnchecked(e); // 转换异常
}
}
@ -144,16 +144,16 @@ public class Reflections {
* 使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 + "]");
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);
return method.invoke(obj, args); // 调用方法并返回结果
} catch (Exception e) { // 捕获异常
throw convertReflectionExceptionToUnchecked(e); // 转换异常
}
}
@ -162,20 +162,20 @@ public class Reflections {
*
* 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()) {
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 field = superClass.getDeclaredField(fieldName); // 获取声明的字段
makeAccessible(field); // 设置字段为可访问
return field; // 返回字段
} catch (NoSuchFieldException e) { // 捕获没有该字段的异常
// Field不在当前类定义,继续向上转型
continue;// new add
continue; // 继续循环
}
}
return null;
return null; // 返回null
}
/**
@ -186,21 +186,21 @@ public class Reflections {
* . 使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");
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()) {
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 method = searchType.getDeclaredMethod(methodName, parameterTypes); // 获取声明的方法
makeAccessible(method); // 设置方法为可访问
return method; // 返回方法
} catch (NoSuchMethodException e) { // 捕获没有该方法的异常
// Method不在当前类定义,继续向上转型
continue;// new add
continue; // 继续循环
}
}
return null;
return null; // 返回null
}
/**
@ -210,39 +210,39 @@ public class Reflections {
*
* . 使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;
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;
return null; // 返回null
}
/**
* private/protectedpublicJDKSecurityManager
*/
public static void makeAccessible(Method method) {
if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
&& !method.isAccessible()) {
method.setAccessible(true);
public static void makeAccessible(Method method) { // 定义设置方法为可访问的方法
if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers())) // 如果方法或类不是public
&& !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);
public static void makeAccessible(Field field) { // 定义设置字段为可访问的方法
if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers()) || Modifier // 如果字段或类不是public或字段是final
.isFinal(field.getModifiers())) && !field.isAccessible()) { // 且字段不可访问
field.setAccessible(true); // 设置为可访问
}
}
@ -256,8 +256,8 @@ public class Reflections {
* @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);
public static <T> Class<T> getClassGenricType(final Class clazz) { // 定义获取类的泛型类型的方法
return getClassGenricType(clazz, 0); // 调用重载方法
}
/**
@ -270,55 +270,54 @@ public class Reflections {
* @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) {
public static Class getClassGenricType(final Class clazz, final int index) { // 定义获取类的泛型类型的方法
Type genType = clazz.getGenericSuperclass(); // 获取类的泛型超类
Type genType = clazz.getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
log.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
return Object.class;
if (!(genType instanceof ParameterizedType)) { // 如果不是参数化类型
log.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType"); // 记录警告
return Object.class; // 返回Object.class
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); // 获取实际类型参数
if (index >= params.length || index < 0) {
if (index >= params.length || index < 0) { // 如果索引超出范围
log.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
+ params.length);
return Object.class;
+ params.length); // 记录警告
return Object.class; // 返回Object.class
}
if (!(params[index] instanceof Class)) {
log.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
return Object.class;
if (!(params[index] instanceof Class)) { // 如果参数不是Class类型
log.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter"); // 记录警告
return Object.class; // 返回Object.class
}
return (Class) params[index];
return (Class) params[index]; // 返回指定索引的Class类型
}
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;
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)) { // 如果类名包含CGLIB分隔符
Class<?> superClass = clazz.getSuperclass(); // 获取父类
if (superClass != null && !Object.class.equals(superClass)) { // 如果父类存在且不是Object
return superClass; // 返回父类
}
}
return clazz;
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;
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);
return new RuntimeException("Unexpected Checked Exception.", e); // 返回未知异常
}
}

@ -1,32 +1,33 @@
package com.yf.exam.core.utils;
language:yfexam-exam-main/yfexam-exam-main/exam-api/src/main/java/com/yf/exam/core/utils/SpringUtils.java
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;
import org.springframework.beans.BeansException; // 导入BeansException类
import org.springframework.context.ApplicationContext; // 导入ApplicationContext接口
import org.springframework.context.ApplicationContextAware; // 导入ApplicationContextAware接口
import org.springframework.stereotype.Component; // 导入Component注解
/**
* Spring
*
* @author bool
* @date 2019-12-09 15:55
* @author bool // 作者信息
* @date 2019-12-09 15:55 // 日期信息
*/
@Component
public class SpringUtils implements ApplicationContextAware {
@Component // 将该类标记为Spring组件
public class SpringUtils implements ApplicationContextAware { // 定义SpringUtils类并实现ApplicationContextAware接口
private static ApplicationContext applicationContext;
private static ApplicationContext applicationContext; // 静态变量用于存储ApplicationContext
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
applicationContext = context;
@Override // 重写setApplicationContext方法
public void setApplicationContext(ApplicationContext context) throws BeansException { // 设置ApplicationContext
applicationContext = context; // 将传入的context赋值给静态变量
}
public static <T> T getBean(Class<T> tClass) {
return applicationContext.getBean(tClass);
public static <T> T getBean(Class<T> tClass) { // 泛型方法根据类获取Bean
return applicationContext.getBean(tClass); // 从ApplicationContext中获取指定类型的Bean
}
public static <T> T getBean(String name, Class<T> type) {
return applicationContext.getBean(name, type);
public static <T> T getBean(String name, Class<T> type) { // 泛型方法根据名称和类型获取Bean
return applicationContext.getBean(name, type); // 从ApplicationContext中获取指定名称和类型的Bean
}
}

@ -1,39 +1,38 @@
package com.yf.exam.core.utils;
package com.yf.exam.core.utils; // 定义包名
import java.util.Map;
import java.util.Map; // 导入Map类
/**
*
* @author bool
* @date 2019-05-15 11:40
*/
public class StringUtils {
public class StringUtils { // 定义StringUtils类
/**
*
* @param str
* @return
* @param str
* @return nulltruefalse
*/
public static boolean isBlank(String str){
return str==null || "".equals(str);
public static boolean isBlank(String str){ // 定义静态方法isBlank
return str==null || "".equals(str); // 检查字符串是否为null或空
}
/**
* MAPxml<xml><key>value</key>...</xml>
* @param params
* @return
* @param params Map
* @return xml
*/
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(">");
public static String mapToXml(Map<String, String> params){ // 定义静态方法mapToXml
StringBuffer sb = new StringBuffer("<xml>"); // 创建StringBuffer并初始化为<xml>
for(String key:params.keySet()){ // 遍历Map中的每个key
sb.append("<") // 添加开始标签
.append(key).append(">") // 添加key
.append(params.get(key)) // 添加对应的value
.append("</").append(key).append(">"); // 添加结束标签
}
sb.append("</xml>");
return sb.toString();
sb.append("</xml>"); // 添加结束的</xml>标签
return sb.toString(); // 返回构建的xml字符串
}
}

@ -1,82 +1,83 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel;
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 com.google.common.collect.Lists; // 导入Lists类
import com.yf.exam.core.utils.Reflections; // 导入Reflections工具类
import com.yf.exam.core.utils.excel.annotation.ExcelField; // 导入ExcelField注解
import org.apache.commons.lang3.StringUtils; // 导入StringUtils工具类
import org.apache.poi.ss.usermodel.Cell; // 导入Cell类
import org.apache.poi.ss.usermodel.CellStyle; // 导入CellStyle类
import org.apache.poi.ss.usermodel.Comment; // 导入Comment类
import org.apache.poi.ss.usermodel.DataFormat; // 导入DataFormat类
import org.apache.poi.ss.usermodel.Font; // 导入Font类
import org.apache.poi.ss.usermodel.IndexedColors; // 导入IndexedColors类
import org.apache.poi.ss.usermodel.Row; // 导入Row类
import org.apache.poi.ss.usermodel.Sheet; // 导入Sheet类
import org.apache.poi.ss.usermodel.Workbook; // 导入Workbook类
import org.apache.poi.ss.util.CellRangeAddress; // 导入CellRangeAddress类
import org.apache.poi.xssf.streaming.SXSSFWorkbook; // 导入SXSSFWorkbook类
import org.apache.poi.xssf.usermodel.XSSFClientAnchor; // 导入XSSFClientAnchor类
import org.apache.poi.xssf.usermodel.XSSFRichTextString; // 导入XSSFRichTextString类
import org.slf4j.Logger; // 导入Logger接口
import org.slf4j.LoggerFactory; // 导入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;
import javax.servlet.http.HttpServletResponse; // 导入HttpServletResponse类
import java.io.IOException; // 导入IOException类
import java.io.OutputStream; // 导入OutputStream类
import java.lang.reflect.Field; // 导入Field类
import java.lang.reflect.Method; // 导入Method类
import java.net.URLEncoder; // 导入URLEncoder类
import java.util.Collections; // 导入Collections类
import java.util.Comparator; // 导入Comparator接口
import java.util.Date; // 导入Date类
import java.util.HashMap; // 导入HashMap类
import java.util.List; // 导入List接口
import java.util.Map; // 导入Map接口
/**
* ExcelXLSX @see org.apache.poi.ss.SpreadsheetVersion
* @author jeeplus
* @version 2016-04-21
*/
public class ExportExcel {
public class ExportExcel { // ExportExcel类定义
private static Logger log = LoggerFactory.getLogger(ExportExcel.class);
private static Logger log = LoggerFactory.getLogger(ExportExcel.class); // 日志记录器
/**
*
*/
private SXSSFWorkbook wb;
private SXSSFWorkbook wb; // 工作薄对象
/**
*
*/
private Sheet sheet;
private Sheet sheet; // 工作表对象
/**
*
*/
private Map<String, CellStyle> styles;
private Map<String, CellStyle> styles; // 样式列表
/**
*
*/
private int rownum;
private int rownum; // 当前行号
/**
* Object[]{ ExcelField, Field/Method }
*/
List<Object[]> annotationList = Lists.newArrayList();
List<Object[]> annotationList = Lists.newArrayList(); // 注解列表
/**
*
* @param title
* @param cls annotation.ExportField
*/
public ExportExcel(String title, Class<?> cls){
this(title, cls, 1);
public ExportExcel(String title, Class<?> cls){ // 构造函数
this(title, cls, 1); // 调用另一个构造函数
}
/**
@ -86,123 +87,123 @@ public class ExportExcel {
* @param type 1:2
* @param groups
*/
public ExportExcel(String title, Class<?> cls, int type, int... 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;
Field[] fs = cls.getDeclaredFields(); // 获取类的所有字段
for (Field f : fs){ // 遍历字段
ExcelField ef = f.getAnnotation(ExcelField.class); // 获取ExcelField注解
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;
for (int efg : ef.groups()){ // 遍历注解中的分组
if (g == efg){ // 如果匹配
inGroup = true; // 设置标志
annotationList.add(new Object[]{ef, f}); // 添加到注解列表
break; // 退出循环
}
}
}
}else{
annotationList.add(new Object[]{ef, f});
}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;
Method[] ms = cls.getDeclaredMethods(); // 获取类的所有方法
for (Method m : ms){ // 遍历方法
ExcelField ef = m.getAnnotation(ExcelField.class); // 获取ExcelField注解
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;
for (int efg : ef.groups()){ // 遍历注解中的分组
if (g == efg){ // 如果匹配
inGroup = true; // 设置标志
annotationList.add(new Object[]{ef, m}); // 添加到注解列表
break; // 退出循环
}
}
}
}else{
annotationList.add(new Object[]{ef, m});
}else{ // 如果没有分组
annotationList.add(new Object[]{ef, m}); // 添加到注解列表
}
}
}
// Field sorting
Collections.sort(annotationList, new Comparator<Object[]>() {
Collections.sort(annotationList, new Comparator<Object[]>() { // 对注解列表进行排序
@Override
public int compare(Object[] o1, Object[] o2) {
return new Integer(((ExcelField)o1[0]).sort()).compareTo(
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();
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];
if (type==1){ // 如果是导出数据
String[] ss = StringUtils.split(t, "**", 2); // 分割标题
if (ss.length==2){ // 如果有注释
t = ss[0]; // 去掉注释
}
}
headerList.add(t);
headerList.add(t); // 添加标题到表头列表
}
initialize(title, headerList);
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);
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(),
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!");
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(
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));
comment.setString(new XSSFRichTextString(ss[1])); // 设置注释内容
cell.setCellComment(comment); // 设置单元格注释
}else{ // 如果没有注释
cell.setCellValue(headerList.get(i)); // 设置单元格值
}
sheet.autoSizeColumn(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);
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.");
log.debug("Initialize success."); // 记录初始化成功日志
}
/**
@ -210,73 +211,73 @@ public class ExportExcel {
* @param wb
* @return
*/
private Map<String, CellStyle> createStyles(Workbook wb) {
Map<String, CellStyle> styles = new HashMap<>(16);
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);
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.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_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_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.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);
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 styles; // 返回样式列表
}
/**
*
* @return
*/
public Row addRow(){
return sheet.createRow(rownum++);
public Row addRow(){ // 添加行方法
return sheet.createRow(rownum++); // 创建新行并返回
}
@ -287,8 +288,8 @@ public class ExportExcel {
* @param val
* @return
*/
public Cell addCell(Row row, int column, Object val){
return this.addCell(row, column, val, 0, Class.class);
public Cell addCell(Row row, int column, Object val){ // 添加单元格方法
return this.addCell(row, column, val, 0, Class.class); // 调用重载方法
}
/**
@ -299,104 +300,104 @@ public class ExportExcel {
* @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{
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){ // 如果值为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){ // 如果字段类型不是Class
cell.setCellValue((String)fieldType.getMethod("setValue", Object.class).invoke(null, val)); // 设置单元格值
}else{ // 如果字段类型是Class
cell.setCellValue((String)Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(),
"fieldtype."+val.getClass().getSimpleName()+"Type")).getMethod("setValue", Object.class).invoke(null, val));
"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());
} catch (Exception ex) { // 捕获异常
log.info("Set cell value ["+row.getRowNum()+","+column+"] error: " + ex.toString()); // 记录错误日志
cell.setCellValue(val.toString()); // 设置单元格值为字符串
}
cell.setCellStyle(style);
return cell;
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[] {});
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]; // 获取ExcelField注解
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 = "";
}catch(Exception ex) { // 捕获异常
log.info(ex.toString()); // 记录错误日志
val = ""; // 设置值为空字符串
}
this.addCell(row, colunm++, val, ef.align(), ef.fieldType());
sb.append(val + ", ");
this.addCell(row, colunm++, val, ef.align(), ef.fieldType()); // 添加单元格
sb.append(val + ", "); // 添加值到字符串构建器
}
log.debug("Write success: ["+row.getRowNum()+"] "+sb.toString());
log.debug("Write success: ["+row.getRowNum()+"] "+sb.toString()); // 记录写入成功日志
}
return this;
return this; // 返回当前对象
}
/**
*
* @param os
*/
public ExportExcel write(OutputStream os) throws IOException{
wb.write(os);
return this;
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 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;
public ExportExcel dispose(){ // 清理临时文件方法
wb.dispose(); // 释放工作薄资源
return this; // 返回当前对象
}
}

@ -1,59 +1,58 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel;
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 com.google.common.collect.Lists; // 导入Google的Lists工具类
import com.yf.exam.core.utils.Reflections; // 导入自定义的Reflections工具类
import com.yf.exam.core.utils.excel.annotation.ExcelField; // 导入ExcelField注解
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons的StringUtils工具类
import org.apache.poi.hssf.usermodel.HSSFDateUtil; // 导入HSSFDateUtil类用于处理日期
import org.apache.poi.hssf.usermodel.HSSFWorkbook; // 导入HSSFWorkbook类用于处理XLS文件
import org.apache.poi.openxml4j.exceptions.InvalidFormatException; // 导入异常类
import org.apache.poi.ss.usermodel.Cell; // 导入Cell类表示单元格
import org.apache.poi.ss.usermodel.Row; // 导入Row类表示行
import org.apache.poi.ss.usermodel.Sheet; // 导入Sheet类表示工作表
import org.apache.poi.ss.usermodel.Workbook; // 导入Workbook类表示工作簿
import org.apache.poi.xssf.usermodel.XSSFWorkbook; // 导入XSSFWorkbook类用于处理XLSX文件
import org.slf4j.Logger; // 导入Logger接口
import org.slf4j.LoggerFactory; // 导入LoggerFactory类
import org.springframework.web.multipart.MultipartFile; // 导入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;
import java.io.IOException; // 导入IOException异常
import java.io.InputStream; // 导入InputStream类
import java.lang.reflect.Field; // 导入Field类用于反射
import java.lang.reflect.Method; // 导入Method类用于反射
import java.text.NumberFormat; // 导入NumberFormat类用于格式化数字
import java.text.SimpleDateFormat; // 导入SimpleDateFormat类用于格式化日期
import java.util.Collections; // 导入Collections类用于集合操作
import java.util.Comparator; // 导入Comparator接口用于比较
import java.util.Date; // 导入Date类表示日期
import java.util.List; // 导入List接口表示列表
/**
* ExcelXLSXLSX
* @author jeeplus
* @version 2016-03-10
*/
public class ImportExcel {
public class ImportExcel { // 定义ImportExcel类
private static Logger log = LoggerFactory.getLogger(ImportExcel.class);
private static Logger log = LoggerFactory.getLogger(ImportExcel.class); // 创建日志记录器
/**
*
*/
private Workbook wb;
private Workbook wb; // 定义工作簿对象
/**
*
*/
private Sheet sheet;
private Sheet sheet; // 定义工作表对象
/**
*
*/
private int headerNum;
private int headerNum; // 定义标题行号
/**
@ -65,8 +64,8 @@ public class ImportExcel {
* @throws IOException
*/
public ImportExcel(MultipartFile multipartFile, int headerNum, int sheetIndex)
throws InvalidFormatException, IOException {
this(multipartFile.getOriginalFilename(), multipartFile.getInputStream(), headerNum, sheetIndex);
throws InvalidFormatException, IOException { // 构造函数,接收文件、标题行号和工作表索引
this(multipartFile.getOriginalFilename(), multipartFile.getInputStream(), headerNum, sheetIndex); // 调用另一个构造函数
}
/**
@ -78,22 +77,22 @@ public class ImportExcel {
* @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);
throws IOException { // 构造函数,接收文件名、输入流、标题行号和工作表索引
if (StringUtils.isBlank(fileName)){ // 检查文件名是否为空
throw new RuntimeException("导入文档为空!"); // 抛出异常
}else if(fileName.toLowerCase().endsWith("xls")){ // 检查文件格式
this.wb = new HSSFWorkbook(is); // 创建HSSFWorkbook对象
}else if(fileName.toLowerCase().endsWith("xlsx")){
this.wb = new XSSFWorkbook(is);
this.wb = new XSSFWorkbook(is); // 创建XSSFWorkbook对象
}else{
throw new RuntimeException("文档格式不正确!");
throw new RuntimeException("文档格式不正确!"); // 抛出异常
}
if (this.wb.getNumberOfSheets()<sheetIndex){
throw new RuntimeException("文档中没有工作表!");
if (this.wb.getNumberOfSheets()<sheetIndex){ // 检查工作表索引是否有效
throw new RuntimeException("文档中没有工作表!"); // 抛出异常
}
this.sheet = this.wb.getSheetAt(sheetIndex);
this.headerNum = headerNum;
log.debug("Initialize success.");
this.sheet = this.wb.getSheetAt(sheetIndex); // 获取指定的工作表
this.headerNum = headerNum; // 设置标题行号
log.debug("Initialize success."); // 记录初始化成功的日志
}
/**
@ -101,24 +100,24 @@ public class ImportExcel {
* @param rownum
* @return
*/
public Row getRow(int rownum){
return this.sheet.getRow(rownum);
public Row getRow(int rownum){ // 获取指定行
return this.sheet.getRow(rownum); // 返回行对象
}
/**
*
* @return
*/
public int getDataRowNum(){
return headerNum+1;
public int getDataRowNum(){ // 获取数据行号
return headerNum+1; // 返回标题行号加一
}
/**
*
* @return
*/
public int getLastDataRowNum(){
return this.sheet.getLastRowNum()+headerNum;
public int getLastDataRowNum(){ // 获取最后一个数据行号
return this.sheet.getLastRowNum()+headerNum; // 返回最后一行号加标题行号
}
@ -128,38 +127,37 @@ public class ImportExcel {
* @param column
* @return
*/
public Object getCellValue(Row row, int column) {
Object val = "";
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) {
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);
if (HSSFDateUtil.isCellDateFormatted(cell)) { // 检查是否为日期格式
double d = cell.getNumericCellValue(); // 获取数值
Date date = HSSFDateUtil.getJavaDate(d); // 转换为Java日期
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所以需要转换一下
NumberFormat nf = NumberFormat.getInstance(); // 获取数字格式化实例
nf.setGroupingUsed(false); // 设置不使用分组
val = nf.format(cell.getNumericCellValue()); // 格式化数值
}
} 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();
} 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;
} catch (Exception e) { // 捕获异常
return val; // 返回值
}
return val;
return val; // 返回单元格值
}
/**
@ -167,137 +165,137 @@ public class ImportExcel {
* @param cls
* @param groups
*/
public <E> List<E> getDataList(Class<E> cls, int... groups) throws InstantiationException, IllegalAccessException{
List<Object[]> annotationList = Lists.newArrayList();
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;
Field[] fs = cls.getDeclaredFields(); // 获取类的所有字段
for (Field f : fs){ // 遍历字段
ExcelField ef = f.getAnnotation(ExcelField.class); // 获取字段上的ExcelField注解
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;
for (int efg : ef.groups()){ // 遍历注解中的分组
if (g == efg){ // 如果分组匹配
inGroup = true; // 设置标志
annotationList.add(new Object[]{ef, f}); // 添加到注解列表
break; // 跳出循环
}
}
}
}else{
annotationList.add(new Object[]{ef, f});
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;
Method[] ms = cls.getDeclaredMethods(); // 获取类的所有方法
for (Method m : ms){ // 遍历方法
ExcelField ef = m.getAnnotation(ExcelField.class); // 获取方法上的ExcelField注解
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;
for (int efg : ef.groups()){ // 遍历注解中的分组
if (g == efg){ // 如果分组匹配
inGroup = true; // 设置标志
annotationList.add(new Object[]{ef, m}); // 添加到注解列表
break; // 跳出循环
}
}
}
}else{
annotationList.add(new Object[]{ef, m});
annotationList.add(new Object[]{ef, m}); // 添加到注解列表
}
}
}
// Field sorting
Collections.sort(annotationList, new Comparator<Object[]>() {
Collections.sort(annotationList, new Comparator<Object[]>() { // 对注解列表进行排序
@Override
public int compare(Object[] o1, Object[] o2) {
return new Integer(((ExcelField)o1[0]).sort()).compareTo(
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];
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]; // 获取ExcelField注解
// 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){
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];
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");
if (valType == String.class){ // 检查值类型
String s = String.valueOf(val.toString()); // 转换为字符串
if(StringUtils.endsWith(s, ".0")){ // 检查是否以.0结尾
val = StringUtils.substringBefore(s, ".0"); // 去掉.0
}else{
val = String.valueOf(val.toString());
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 (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());
if (ef.fieldType() != Class.class){ // 检查字段类型
val = ef.fieldType().getMethod("getValue", String.class).invoke(null, val.toString()); // 调用getValue方法
}else{
val = Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(),
"fieldtype."+valType.getSimpleName()+"Type")).getMethod("getValue", String.class).invoke(null, val.toString());
"fieldtype."+valType.getSimpleName()+"Type")).getMethod("getValue", String.class).invoke(null, val.toString()); // 动态调用getValue方法
}
}
} catch (Exception ex) {
log.info("Get cell value ["+i+","+column+"] error: " + ex.toString());
val = null;
} catch (Exception ex) { // 捕获异常
log.info("Get cell value ["+i+","+column+"] error: " + ex.toString()); // 记录错误日志
val = null; // 设置值为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");
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"); // 转换为set方法名
}
Reflections.invokeMethod(e, mthodName, new Class[] {valType}, new Object[] {val});
Reflections.invokeMethod(e, mthodName, new Class[] {valType}, new Object[] {val}); // 调用set方法
}
}
sb.append(val+", ");
sb.append(val+", "); // 添加值到字符串构建器
}
dataList.add(e);
log.debug("Read success: ["+i+"] "+sb.toString());
dataList.add(e); // 添加对象到数据列表
log.debug("Read success: ["+i+"] "+sb.toString()); // 记录读取成功的日志
}
return dataList;
return dataList; // 返回数据列表
}
}

@ -1,59 +1,87 @@
// ... existing code ...
/**
* 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;
// 导入ElementType类用于定义注解的适用范围
import java.lang.annotation.Retention;
// 导入Retention类用于定义注解的保留策略
import java.lang.annotation.RetentionPolicy;
// 导入RetentionPolicy类定义注解的保留策略类型
import java.lang.annotation.Target;
// 导入Target类用于定义注解的目标
/**
* Excel
* @author jeeplus
* @version 2016-03-10
*/
// 注解类的描述,包含作者和版本信息
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
// 定义该注解可以应用于方法、字段和类
@Retention(RetentionPolicy.RUNTIME)
// 定义该注解在运行时可用
public @interface ExcelField {
// 定义ExcelField注解
/**
* get.area.nameoffice.name
*
*/
String value() default "";
// 字段名,默认为空字符串
/**
* ****
*
*/
String title();
// 字段标题,必填项
/**
* 012
*
*/
int type() default 0;
// 字段类型默认为0导出导入
/**
* 0123
*
*/
int align() default 0;
// 对齐方式默认为0自动
/**
*
*
*/
int sort() default 0;
// 字段排序默认为0升序
/**
* type
*
*/
String dictType() default "";
// 字典类型,默认为空字符串
/**
*
*
*/
Class<?> fieldType() default Class.class;
// 字段类型默认为Class.class
/**
*
*
*/
int[] groups() default {};
// 字段归属组,默认为空数组
}
// ... existing code ...

@ -1,56 +1,57 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel.fieldtype;
package com.yf.exam.core.utils.excel.fieldtype; // 定义包名
import com.google.common.collect.Lists;
import com.yf.exam.core.utils.StringUtils;
import com.google.common.collect.Lists; // 导入Google的Lists工具类
import com.yf.exam.core.utils.StringUtils; // 导入自定义的StringUtils工具类
import java.util.List;
import java.util.List; // 导入List接口
/**
*
* @author jeeplus
* @version 2016-5-29
*/
public class ListType {
public class ListType { // 定义ListType类
/**
*
*/
public static Object getValue(String val) {
List<String> list = Lists.newArrayList();
if(!StringUtils.isBlank(val)) {
for (String s : val.split(",")) {
list.add(s);
public static Object getValue(String val) { // 定义静态方法getValue接收一个字符串参数
List<String> list = Lists.newArrayList(); // 创建一个新的字符串列表
if(!StringUtils.isBlank(val)) { // 检查输入字符串是否为空
for (String s : val.split(",")) { // 按逗号分割字符串
list.add(s); // 将分割后的字符串添加到列表中
}
}
return list;
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;
public static String setValue(Object val) { // 定义静态方法setValue接收一个对象参数
if (val != null){ // 检查输入对象是否为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);
if(sb == null){ // 如果字符串缓冲区为空
sb = new StringBuffer(item); // 初始化缓冲区为当前字符串
}else{
sb.append(",").append(item);
sb.append(",").append(item); // 否则,添加逗号和当前字符串
}
}
if(sb!=null) {
return sb.toString().replace("[]", "");
if(sb!=null) { // 如果字符串缓冲区不为空
return sb.toString().replace("[]", ""); // 返回缓冲区内容并替换"[]"为空
}
}
return "";
return ""; // 如果输入对象为null返回空字符串
}
}

@ -1,7 +1,6 @@
package com.yf.exam.core.utils.file;
import java.security.MessageDigest;
package com.yf.exam.core.utils.file; // 包声明
import java.security.MessageDigest; // 导入MessageDigest类用于生成MD5哈希
/**
* MD5
@ -11,26 +10,25 @@ import java.security.MessageDigest;
* @author Bool
* @version
*/
public class Md5Util {
public class Md5Util { // 定义MD5工具类
/**
* MD5
* @param str
* @return
* @param str
* @return MD5
*/
public static String md5(String str) {
public static String md5(String str) { // 定义静态方法md5接受一个字符串参数
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));
try { // 开始异常处理
MessageDigest md = MessageDigest.getInstance("MD5"); // 获取MD5实例
byte[] array = md.digest(str.getBytes("UTF-8")); // 计算输入字符串的MD5哈希值
StringBuilder sb = new StringBuilder(); // 创建StringBuilder用于构建结果字符串
for (byte item : array) { // 遍历哈希字节数组
sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3)); // 将每个字节转换为十六进制并添加到StringBuilder
}
return sb.toString();
}catch(Exception e) {
return null;
return sb.toString(); // 返回最终的MD5哈希字符串
}catch(Exception e) { // 捕获异常
return null; // 如果发生异常返回null
}
}

@ -1,8 +1,7 @@
package com.yf.exam.core.utils.passwd;
package com.yf.exam.core.utils.passwd; // 定义包名
import com.yf.exam.core.utils.file.Md5Util;
import org.apache.commons.lang3.RandomStringUtils;
import com.yf.exam.core.utils.file.Md5Util; // 导入Md5Util类
import org.apache.commons.lang3.RandomStringUtils; // 导入RandomStringUtils类
/**
*
@ -12,7 +11,7 @@ import org.apache.commons.lang3.RandomStringUtils;
* @author Bool
* @version
*/
public class PassHandler {
public class PassHandler { // 定义PassHandler类
/**
* checkPass:
@ -22,9 +21,9 @@ public class PassHandler {
* @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);
public static boolean checkPass(String inputPass , String salt , String pass){ // 定义静态方法checkPass
String pwdMd5 = Md5Util.md5(inputPass); // 将输入密码进行MD5加密
return Md5Util.md5(pwdMd5 + salt).equals(pass); // 校验加密后的密码与数据库密码是否一致
}
@ -35,23 +34,23 @@ public class PassHandler {
* @param inputPass
* @return PassInfo
*/
public static PassInfo buildPassword(String inputPass) {
public static PassInfo buildPassword(String inputPass) { // 定义静态方法buildPassword
//产生一个6位数的随机码
String salt = RandomStringUtils.randomAlphabetic(6);
String salt = RandomStringUtils.randomAlphabetic(6); // 生成6位随机字母作为盐
//加密后的密码
String encryptPassword = Md5Util.md5(Md5Util.md5(inputPass)+salt);
String encryptPassword = Md5Util.md5(Md5Util.md5(inputPass)+salt); // 对输入密码和盐进行双重MD5加密
//返回对象
return new PassInfo(salt,encryptPassword);
return new PassInfo(salt,encryptPassword); // 返回包含盐和加密密码的PassInfo对象
}
public static void main(String[] args) {
public static void main(String[] args) { // 主方法
PassInfo info = buildPassword("190601");
PassInfo info = buildPassword("190601"); // 调用buildPassword方法生成密码信息
System.out.println(info.getPassword());
System.out.println(info.getSalt());
System.out.println(info.getPassword()); // 输出加密后的密码
System.out.println(info.getSalt()); // 输出生成的盐
}
}

@ -1,38 +1,45 @@
package com.yf.exam.core.utils.passwd;
package com.yf.exam.core.utils.passwd; // 定义包名
/**
*
* ClassName: PassInfo <br/>
* date: 2018213 7:13:50 <br/>
*
* @author Bool
* @version
* @author Bool // 作者
* @version // 版本信息
*/
public class PassInfo {
public class PassInfo { // 定义PassInfo类
//密码随机串码
private String salt;
// 密码随机串码
private String salt; // 声明salt变量
//MD5后的密码
private String password;
// MD5后的密码
private String password; // 声明password变量
// 构造函数初始化salt和password
public PassInfo(String salt, String password) {
super();
this.salt = salt;
this.password = password;
super(); // 调用父类构造函数
this.salt = salt; // 设置salt
this.password = password; // 设置password
}
// 获取salt
public String getSalt() {
return salt;
return salt; // 返回salt
}
// 设置salt
public void setSalt(String salt) {
this.salt = salt;
this.salt = salt; // 更新salt
}
// 获取password
public String getPassword() {
return password;
return password; // 返回password
}
// 设置password
public void setPassword(String password) {
this.password = password;
this.password = password; // 更新password
}
}

@ -1,14 +1,15 @@
package com.yf.exam.modules;
package com.yf.exam.modules; // 包名:表示该类属于 modules 包
/**
*
* @author bool
*
* 使
* @ bool
*/
public class Constant {
/**
*
*
* Token
*/
public static final String TOKEN = "token";
public static final String TOKEN = "token"; // 定义一个常量 TOKEN表示会话中的 Token 名称
}

@ -1,151 +1,144 @@
package com.yf.exam.modules.exam.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yf.exam.core.api.ApiRest;
import com.yf.exam.core.api.controller.BaseController;
import com.yf.exam.core.api.dto.BaseIdReqDTO;
import com.yf.exam.core.api.dto.BaseIdsReqDTO;
import com.yf.exam.core.api.dto.BaseStateReqDTO;
import com.yf.exam.core.api.dto.PagingReqDTO;
import com.yf.exam.modules.exam.dto.ExamDTO;
import com.yf.exam.modules.exam.dto.request.ExamSaveReqDTO;
import com.yf.exam.modules.exam.dto.response.ExamOnlineRespDTO;
import com.yf.exam.modules.exam.dto.response.ExamReviewRespDTO;
import com.yf.exam.modules.exam.entity.Exam;
import com.yf.exam.modules.exam.service.ExamService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
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={"考试"})
@RestController
@RequestMapping("/exam/api/exam/exam")
public class ExamController extends BaseController {
* <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;
private ExamService baseService; // 自动注入考试服务
/**
*
* @param reqDTO
* @return
*/
@RequiresRoles("sa")
@ApiOperation(value = "添加或修改")
@RequestMapping(value = "/save", method = { RequestMethod.POST})
public ApiRest save(@RequestBody ExamSaveReqDTO reqDTO) {
//复制参数
baseService.save(reqDTO);
return super.success();
*
* @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
* @return
*/
@RequiresRoles("sa")
@ApiOperation(value = "批量删除")
@RequestMapping(value = "/delete", method = { RequestMethod.POST})
public ApiRest edit(@RequestBody BaseIdsReqDTO reqDTO) {
//根据ID删除
baseService.removeByIds(reqDTO.getIds());
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
* @return
*/
@ApiOperation(value = "查找详情")
@RequestMapping(value = "/detail", method = { RequestMethod.POST})
public ApiRest<ExamSaveReqDTO> find(@RequestBody BaseIdReqDTO reqDTO) {
ExamSaveReqDTO dto = baseService.findDetail(reqDTO.getId());
return super.success(dto);
*
* @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
* @return
*
* @param reqDTO ID
* @return ApiRest
*/
@RequiresRoles("sa")
@ApiOperation(value = "查找详情")
@RequestMapping(value = "/state", method = { RequestMethod.POST})
public ApiRest state(@RequestBody BaseStateReqDTO reqDTO) {
@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());
Exam exam = new Exam();
exam.setState(reqDTO.getState());
exam.setUpdateTime(new Date());
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();
baseService.update(exam, wrapper); // 调用服务层更新考试状态
return super.success(); // 返回成功响应
}
/**
*
* @param reqDTO
* @return
*
* @param reqDTO
* @return ApiRest<IPage<ExamOnlineRespDTO>>
*/
@ApiOperation(value = "考试视角")
@RequestMapping(value = "/online-paging", method = { RequestMethod.POST})
public ApiRest<IPage<ExamOnlineRespDTO>> myPaging(@RequestBody PagingReqDTO<ExamDTO> reqDTO) {
//分页查询并转换
IPage<ExamOnlineRespDTO> page = baseService.onlinePaging(reqDTO);
return super.success(page);
@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
*/
@RequiresRoles("sa")
@ApiOperation(value = "分页查找")
@RequestMapping(value = "/paging", method = { RequestMethod.POST})
public ApiRest<IPage<ExamDTO>> paging(@RequestBody PagingReqDTO<ExamDTO> reqDTO) {
//分页查询并转换
IPage<ExamDTO> page = baseService.paging(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
*
* @param reqDTO
* @return ApiRest<IPage<ExamReviewRespDTO>>
*/
@RequiresRoles("sa")
@ApiOperation(value = "待阅试卷")
@RequestMapping(value = "/review-paging", method = { RequestMethod.POST})
public ApiRest<IPage<ExamReviewRespDTO>> reviewPaging(@RequestBody PagingReqDTO<ExamDTO> reqDTO) {
//分页查询并转换
IPage<ExamReviewRespDTO> page = baseService.reviewPaging(reqDTO);
return super.success(page);
@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); // 返回成功响应和分页结果
}
}

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

@ -1,33 +1,32 @@
package com.yf.exam.modules.exam.dto;
package com.yf.exam.modules.exam.dto; // 定义包名DTO类所在的包路径
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import io.swagger.annotations.ApiModel; // 导入Swagger注解用于描述模型
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解用于描述模型属性
import lombok.Data; // 导入Lombok注解用于简化数据类的编写
import java.io.Serializable;
import java.io.Serializable; // 导入Java的序列化接口用于确保对象可以被序列化
/**
* <p>
*
* </p>
*
* @author
* @since 2020-09-03 17:24
*/
@Data
@ApiModel(value="考试部门", description="考试部门")
public class ExamDepartDTO implements Serializable {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "ID", required=true)
private String id;
@ApiModelProperty(value = "考试ID", required=true)
private String examId;
@ApiModelProperty(value = "部门ID", required=true)
private String departId;
* <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; // 部门的唯一标识符,关联到具体的部门
}

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

@ -1,32 +1,30 @@
package com.yf.exam.modules.exam.dto.ext;
package com.yf.exam.modules.exam.dto.ext; // 定义包名DTO扩展类所在的包路径
import com.yf.exam.modules.exam.dto.ExamRepoDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
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
@ApiModel(value="考试题库扩展响应类", description="考试题库扩展响应类")
public class ExamRepoExtDTO extends ExamRepoDTO {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "单选题总量", required=true)
private Integer totalRadio;
@ApiModelProperty(value = "多选题总量", required=true)
private Integer totalMulti;
@ApiModelProperty(value = "判断题总量", required=true)
private Integer totalJudge;
* <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; // 判断题总量
}

@ -1,32 +1,30 @@
package com.yf.exam.modules.exam.dto.request;
package com.yf.exam.modules.exam.dto.request; // 定义包名请求DTO类所在的包路径
import com.yf.exam.modules.exam.dto.ExamDTO;
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
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;
import java.util.List; // 导入Java的List接口用于定义列表类型的属性
/**
* <p>
*
* </p>
*
* @author
* @since 2020-07-25 16:18
*/
@Data
@ApiModel(value="考试保存请求类", description="考试保存请求类")
public class ExamSaveReqDTO extends ExamDTO {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "题库列表", required=true)
private List<ExamRepoExtDTO> repoList;
@ApiModelProperty(value = "考试部门列表", required=true)
private List<String> departIds;
* <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
}

@ -1,22 +1,21 @@
package com.yf.exam.modules.exam.dto.response;
package com.yf.exam.modules.exam.dto.response; // 定义包名响应DTO类所在的包路径
import com.yf.exam.modules.exam.dto.ExamDTO;
import io.swagger.annotations.ApiModel;
import lombok.Data;
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
@ApiModel(value="在线考试分页响应类", description="在线考试分页响应类")
public class ExamOnlineRespDTO extends ExamDTO {
private static final long serialVersionUID = 1L;
* <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用于版本控制确保类的版本唯一性
}

@ -1,31 +1,28 @@
package com.yf.exam.modules.exam.dto.response;
package com.yf.exam.modules.exam.dto.response; // 定义包名响应DTO类所在的包路径
import com.yf.exam.modules.exam.dto.ExamDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
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
@ApiModel(value="阅卷分页响应类", description="阅卷分页响应类")
public class ExamReviewRespDTO extends ExamDTO {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "考试人数", required=true)
private Integer examUser;
@ApiModelProperty(value = "待阅试卷", required=true)
private Integer unreadPaper;
* <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; // 待阅试卷数量,表示尚未被阅卷的试卷数量
}

@ -1,100 +1,61 @@
package com.yf.exam.modules.exam.entity;
package com.yf.exam.modules.exam.entity; // 定义包名,实体类所在的包路径
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;
import java.util.Date;
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
@TableName("el_exam")
public class Exam extends Model<Exam> {
private static final long serialVersionUID = 1L;
/**
* ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
/**
*
*/
private String title;
/**
*
*/
private String content;
/**
* 123
*/
@TableField("open_type")
private Integer openType;
/**
*
*/
private Integer state;
/**
*
*/
@TableField("time_limit")
private Boolean timeLimit;
/**
*
*/
@TableField("start_time")
private Date startTime;
/**
*
*/
@TableField("end_time")
private Date endTime;
/**
*
*/
@TableField("create_time")
private Date createTime;
/**
*
*/
@TableField("update_time")
private Date updateTime;
/**
*
*/
@TableField("total_score")
private Integer totalScore;
/**
*
*/
@TableField("total_time")
private Integer totalTime;
/**
*
*/
@TableField("qualify_score")
private Integer qualifyScore;
* <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; // 及格分数,表示考试的及格分数线
}

@ -1,42 +1,47 @@
package com.yf.exam.modules.exam.entity;
package com.yf.exam.modules.exam.entity; // 定义包名,实体类所在的包路径
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;
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
@TableName("el_exam_depart")
public class ExamDepart extends Model<ExamDepart> {
* <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;
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的唯一性
/**
* ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
* ID
*
*/
@TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解指定这个字段为表的主键类型为自增ID
private String id;
/**
* ID
*/
@TableField("exam_id")
* ID
* ID
*/
@TableField("exam_id") // MyBatis Plus注解指定这个字段在数据库表中的列名
private String examId;
/**
* ID
*/
@TableField("depart_id")
* ID
* ID
*/
@TableField("depart_id") // MyBatis Plus注解指定这个字段在数据库表中的列名
private String departId;
}

@ -1,78 +1,87 @@
package com.yf.exam.modules.exam.entity;
package com.yf.exam.modules.exam.entity; // 定义包名,实体类所在的包路径
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;
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
@TableName("el_exam_repo")
public class ExamRepo extends Model<ExamRepo> {
* <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;
private static final long serialVersionUID = 1L; // 序列化ID用于版本控制确保类的唯一性
/**
* ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
* ID
*
*/
@TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解指定这个字段为表的主键类型为自增ID
private String id;
/**
* ID
*/
@TableField("exam_id")
* ID
* ID
*/
@TableField("exam_id") // MyBatis Plus注解指定这个字段在数据库表中的列名
private String examId;
/**
* ID
*/
@TableField("repo_id")
* ID
* ID
*/
@TableField("repo_id") // MyBatis Plus注解指定这个字段在数据库表中的列名
private String repoId;
/**
*
*/
@TableField("radio_count")
*
*
*/
@TableField("radio_count") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer radioCount;
/**
*
*/
@TableField("radio_score")
*
*
*/
@TableField("radio_score") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer radioScore;
/**
*
*/
@TableField("multi_count")
*
*
*/
@TableField("multi_count") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer multiCount;
/**
*
*/
@TableField("multi_score")
*
*
*/
@TableField("multi_score") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer multiScore;
/**
*
*/
@TableField("judge_count")
*
*
*/
@TableField("judge_count") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer judgeCount;
/**
*
*/
@TableField("judge_score")
*
*
*/
@TableField("judge_score") // MyBatis Plus注解指定这个字段在数据库表中的列名
private Integer judgeScore;
}

@ -1,15 +1,17 @@
package com.yf.exam.modules.exam.mapper;
package com.yf.exam.modules.exam.mapper; // 定义包名Mapper接口所在的包路径
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yf.exam.modules.exam.entity.ExamDepart;
/**
* <p>
* Mapper
* </p>
*
* @author
* @since 2020-09-03 17:24
*/
public interface ExamDepartMapper extends BaseMapper<ExamDepart> {
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操作创建、读取、更新、删除
}

@ -1,45 +1,52 @@
package com.yf.exam.modules.exam.mapper;
package com.yf.exam.modules.exam.mapper; // 定义包名Mapper接口所在的包路径
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yf.exam.modules.exam.dto.ExamDTO;
import com.yf.exam.modules.exam.dto.response.ExamReviewRespDTO;
import com.yf.exam.modules.exam.dto.response.ExamOnlineRespDTO;
import com.yf.exam.modules.exam.entity.Exam;
import org.apache.ibatis.annotations.Param;
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>
*
* @author
* @since 2020-07-25 16:18
*/
public interface ExamMapper extends BaseMapper<Exam> {
* <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
*
*
* @param page
* @param query
* @return IPage<ExamDTO> DTO
*/
IPage<ExamDTO> paging(Page page, @Param("query") ExamDTO query);
/**
*
* @param page
* @param query
* @return
*
*
* @param page
* @param query
* @return IPage<ExamReviewRespDTO> DTO
*/
IPage<ExamReviewRespDTO> reviewPaging(Page page, @Param("query") ExamDTO query);
/**
* 线-
* @param page
* @param query
* @return
* 线
*
* @param page
* @param query
* @return IPage<ExamOnlineRespDTO> 线DTO
*/
IPage<ExamOnlineRespDTO> online(Page page, @Param("query") ExamDTO query);
}

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

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

@ -1,40 +1,45 @@
package com.yf.exam.modules.exam.service;
package com.yf.exam.modules.exam.service; // 定义包名,服务接口所在的包路径
import com.baomidou.mybatisplus.extension.service.IService;
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO;
import com.yf.exam.modules.exam.entity.ExamRepo;
import com.baomidou.mybatisplus.extension.service.IService; // 导入MyBatis Plus的服务接口
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO; // 导入考试题库扩展DTO
import com.yf.exam.modules.exam.entity.ExamRepo; // 导入考试题库实体类
import java.util.List;
import java.util.List; // 导入Java的List接口
/**
* <p>
*
* </p>
*
* @author
* @since 2020-09-05 11:14
*/
public interface ExamRepoService extends IService<ExamRepo> {
* <p>
*
* </p>
* MyBatis PlusIService
*
* @author
* @since 2020-09-05 11:14
*/
public interface ExamRepoService extends IService<ExamRepo> { // 声明接口继承自IService并指定操作的实体类为ExamRepo
/**
*
* @param examId
* @param list
*
* ID
*
* @param examId ID
* @param list
*/
void saveAll(String examId, List<ExamRepoExtDTO> list);
/**
*
* @param examId
* @return
* ID
*
* @param examId ID
* @return List<ExamRepoExtDTO>
*/
List<ExamRepoExtDTO> listByExam(String examId);
/**
*
* @param examId
* ID
*
* @param examId ID
*/
void clear(String examId);
}

@ -1,64 +1,75 @@
package com.yf.exam.modules.exam.service;
package com.yf.exam.modules.exam.service; // 定义包名,服务接口所在的包路径
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yf.exam.core.api.dto.PagingReqDTO;
import com.yf.exam.modules.exam.dto.ExamDTO;
import com.yf.exam.modules.exam.dto.request.ExamSaveReqDTO;
import com.yf.exam.modules.exam.dto.response.ExamOnlineRespDTO;
import com.yf.exam.modules.exam.dto.response.ExamReviewRespDTO;
import com.yf.exam.modules.exam.entity.Exam;
import com.baomidou.mybatisplus.core.metadata.IPage; // 导入MyBatis Plus的分页结果接口
import com.baomidou.mybatisplus.extension.service.IService; // 导入MyBatis Plus的服务接口
import com.yf.exam.core.api.dto.PagingReqDTO; // 导入分页请求DTO
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; // 导入考试实体类
/**
* <p>
*
* </p>
*
* @author
* @since 2020-07-25 16:18
*/
public interface ExamService extends IService<Exam> {
* <p>
*
* </p>
* MyBatis PlusIService
*
* @author
* @since 2020-07-25 16:18
*/
public interface ExamService extends IService<Exam> { // 声明接口继承自IService并指定操作的实体类为Exam
/**
*
* @param reqDTO
*
*
* @param reqDTO
*/
void save(ExamSaveReqDTO reqDTO);
/**
*
* @param id
* @return
* ID
*
* @param id ID
* @return ExamSaveReqDTO
*/
ExamSaveReqDTO findDetail(String id);
/**
* --
* @param id
* @return
* ID
*
* @param id ID
* @return ExamDTO
*/
ExamDTO findById(String id);
/**
*
* @param reqDTO
* @return
*/
*
*
*
* @param reqDTO
* @return IPage<ExamDTO>
*/
IPage<ExamDTO> paging(PagingReqDTO<ExamDTO> reqDTO);
/**
* 线-
* @param reqDTO
* @return
* 线
*
* @param reqDTO
* @return IPage<ExamOnlineRespDTO> 线线
*/
IPage<ExamOnlineRespDTO> onlinePaging(PagingReqDTO<ExamDTO> reqDTO);
/**
*
* @param reqDTO
* @return
*
*
* @param reqDTO
* @return IPage<ExamReviewRespDTO>
*/
IPage<ExamReviewRespDTO> reviewPaging(PagingReqDTO<ExamDTO> reqDTO);
}

@ -1,66 +1,64 @@
package com.yf.exam.modules.exam.service.impl;
package com.yf.exam.modules.exam.service.impl; // 定义包名,服务实现类所在的包路径
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yf.exam.core.exception.ServiceException;
import com.yf.exam.modules.exam.entity.ExamDepart;
import com.yf.exam.modules.exam.mapper.ExamDepartMapper;
import com.yf.exam.modules.exam.service.ExamDepartService;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入MyBatis Plus的查询包装类
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 导入MyBatis Plus的服务实现类
import com.yf.exam.core.exception.ServiceException; // 导入自定义的服务异常类
import com.yf.exam.modules.exam.entity.ExamDepart; // 导入考试部门实体类
import com.yf.exam.modules.exam.mapper.ExamDepartMapper; // 导入考试部门Mapper接口
import com.yf.exam.modules.exam.service.ExamDepartService; // 导入考试部门服务接口
import org.springframework.stereotype.Service; // 导入Spring的服务注解
import org.springframework.util.CollectionUtils; // 导入Spring的集合工具类
import java.util.ArrayList;
import java.util.List;
import java.util.ArrayList; // 导入Java的ArrayList类
import java.util.List; // 导入Java的List接口
/**
* <p>
*
* </p>
*
* @author
* @since 2020-09-03 17:24
*/
@Service
public class ExamDepartServiceImpl extends ServiceImpl<ExamDepartMapper, ExamDepart> implements ExamDepartService {
* <p>
*
* </p>
* ExamDepartService
*
* @author
* @since 2020-09-03 17:24
*/
@Service // Spring注解声明这是一个服务组件
public class ExamDepartServiceImpl extends ServiceImpl<ExamDepartMapper, ExamDepart> implements ExamDepartService { // 声明类继承自ServiceImpl并实现ExamDepartService接口
@Override
public void saveAll(String examId, List<String> departs) {
// 先删除
// 先删除已有的部门
QueryWrapper<ExamDepart> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(ExamDepart::getExamId, examId);
this.remove(wrapper);
wrapper.lambda().eq(ExamDepart::getExamId, examId); // 构造查询条件查询指定考试ID的部门
this.remove(wrapper); // 根据条件删除部门
// 再增加
if(CollectionUtils.isEmpty(departs)){
throw new ServiceException(1, "请至少选择选择一个部门!!");
// 再增加新的部门
if (CollectionUtils.isEmpty(departs)) { // 检查部门列表是否为空
throw new ServiceException(1, "请至少选择选择一个部门!!"); // 如果为空,抛出异常
}
List<ExamDepart> list = new ArrayList<>();
List<ExamDepart> list = new ArrayList<>(); // 创建考试部门列表
for(String id: departs){
ExamDepart depart = new ExamDepart();
depart.setDepartId(id);
depart.setExamId(examId);
list.add(depart);
for (String id : departs) {
ExamDepart depart = new ExamDepart(); // 创建考试部门对象
depart.setDepartId(id); // 设置部门ID
depart.setExamId(examId); // 设置考试ID
list.add(depart); // 添加到列表
}
this.saveBatch(list);
this.saveBatch(list); // 批量保存部门
}
@Override
public List<String> listByExam(String examId) {
// 先删除
// 查找考试对应的部门
QueryWrapper<ExamDepart> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(ExamDepart::getExamId, examId);
List<ExamDepart> list = this.list(wrapper);
List<String> ids = new ArrayList<>();
if(!CollectionUtils.isEmpty(list)){
for(ExamDepart item: list){
ids.add(item.getDepartId());
wrapper.lambda().eq(ExamDepart::getExamId, examId); // 构造查询条件查询指定考试ID的部门
List<ExamDepart> list = this.list(wrapper); // 根据条件查询部门列表
List<String> ids = new ArrayList<>(); // 创建部门ID列表
if (!CollectionUtils.isEmpty(list)) { // 检查部门列表是否为空
for (ExamDepart item : list) {
ids.add(item.getDepartId()); // 添加部门ID到列表
}
}
return ids;
return ids; // 返回部门ID列表
}
}

@ -1,67 +1,63 @@
package com.yf.exam.modules.exam.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yf.exam.core.exception.ServiceException;
import com.yf.exam.core.utils.BeanMapper;
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO;
import com.yf.exam.modules.exam.entity.ExamRepo;
import com.yf.exam.modules.exam.mapper.ExamRepoMapper;
import com.yf.exam.modules.exam.service.ExamRepoService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.util.List;
package com.yf.exam.modules.exam.service.impl; // 定义包名,服务实现类所在的包路径
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入MyBatis Plus的查询包装类
import com.baomidou.mybatisplus.core.toolkit.IdWorker; // 导入MyBatis Plus的ID生成工具类
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 导入MyBatis Plus的服务实现类
import com.yf.exam.core.exception.ServiceException; // 导入自定义的服务异常类
import com.yf.exam.core.utils.BeanMapper; // 导入自定义的Bean映射工具类
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO; // 导入考试题库扩展DTO
import com.yf.exam.modules.exam.entity.ExamRepo; // 导入考试题库实体类
import com.yf.exam.modules.exam.mapper.ExamRepoMapper; // 导入考试题库Mapper接口
import com.yf.exam.modules.exam.service.ExamRepoService; // 导入考试题库服务接口
import org.springframework.stereotype.Service; // 导入Spring的服务注解
import org.springframework.transaction.annotation.Transactional; // 导入Spring的事务注解
import org.springframework.util.CollectionUtils; // 导入Spring的集合工具类
import java.util.List; // 导入Java的List接口
/**
* <p>
*
* </p>
*
* @author
* @since 2020-09-05 11:14
*/
@Service
public class ExamRepoServiceImpl extends ServiceImpl<ExamRepoMapper, ExamRepo> implements ExamRepoService {
@Transactional(rollbackFor = Exception.class)
* <p>
*
* </p>
* ExamRepoService
*
* @author
* @since 2020-09-05 11:14
*/
@Service // Spring注解声明这是一个服务组件
public class ExamRepoServiceImpl extends ServiceImpl<ExamRepoMapper, ExamRepo> implements ExamRepoService { // 声明类继承自ServiceImpl并实现ExamRepoService接口
@Transactional(rollbackFor = Exception.class) // Spring事务注解声明事务边界和回滚条件
@Override
public void saveAll(String examId, List<ExamRepoExtDTO> list) {
// 先删除
// 先删除已有的题库
QueryWrapper<ExamRepo> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(ExamRepo::getExamId, examId);
this.remove(wrapper);
wrapper.lambda().eq(ExamRepo::getExamId, examId); // 构造查询条件查询指定考试ID的题库
this.remove(wrapper); // 根据条件删除题库
// 再增加
if(CollectionUtils.isEmpty(list)){
throw new ServiceException(1, "必须选择题库!");
// 再增加新的题库
if (CollectionUtils.isEmpty(list)) { // 检查题库列表是否为空
throw new ServiceException(1, "必须选择题库!"); // 如果为空,抛出异常
}
List<ExamRepo> repos = BeanMapper.mapList(list, ExamRepo.class);
for(ExamRepo item: repos){
item.setExamId(examId);
item.setId(IdWorker.getIdStr());
List<ExamRepo> repos = BeanMapper.mapList(list, ExamRepo.class); // 使用BeanMapper将DTO列表转换为实体类列表
for (ExamRepo item : repos) {
item.setExamId(examId); // 设置考试ID
item.setId(IdWorker.getIdStr()); // 使用IdWorker生成ID
}
this.saveBatch(repos);
this.saveBatch(repos); // 批量保存题库
}
@Override
public List<ExamRepoExtDTO> listByExam(String examId) {
return baseMapper.listByExam(examId);
return baseMapper.listByExam(examId); // 调用Mapper接口的方法查找考试题库列表
}
@Override
public void clear(String examId) {
// 先删除
// 先删除已有的题库
QueryWrapper<ExamRepo> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(ExamRepo::getExamId, examId);
this.remove(wrapper);
wrapper.lambda().eq(ExamRepo::getExamId, examId); // 构造查询条件查询指定考试ID的题库
this.remove(wrapper); // 根据条件删除题库
}
}

@ -1,194 +1,173 @@
package com.yf.exam.modules.exam.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yf.exam.core.api.dto.PagingReqDTO;
import com.yf.exam.core.enums.OpenType;
import com.yf.exam.core.exception.ServiceException;
import com.yf.exam.core.utils.BeanMapper;
import com.yf.exam.modules.exam.dto.ExamDTO;
import com.yf.exam.modules.exam.dto.ExamRepoDTO;
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO;
import com.yf.exam.modules.exam.dto.request.ExamSaveReqDTO;
import com.yf.exam.modules.exam.dto.response.ExamOnlineRespDTO;
import com.yf.exam.modules.exam.dto.response.ExamReviewRespDTO;
import com.yf.exam.modules.exam.entity.Exam;
import com.yf.exam.modules.exam.mapper.ExamMapper;
import com.yf.exam.modules.exam.service.ExamDepartService;
import com.yf.exam.modules.exam.service.ExamRepoService;
import com.yf.exam.modules.exam.service.ExamService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import java.util.List;
package com.yf.exam.modules.exam.service.impl; // 定义包名,服务实现类所在的包路径
import com.baomidou.mybatisplus.core.metadata.IPage; // 导入MyBatis Plus的分页结果接口
import com.baomidou.mybatisplus.core.toolkit.IdWorker; // 导入MyBatis Plus的ID生成工具类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入MyBatis Plus的分页对象
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 导入MyBatis Plus的服务实现类
import com.yf.exam.core.api.dto.PagingReqDTO; // 导入分页请求DTO
import com.yf.exam.core.enums.OpenType; // 导入开放类型枚举
import com.yf.exam.core.exception.ServiceException; // 导入自定义的服务异常类
import com.yf.exam.core.utils.BeanMapper; // 导入自定义的Bean映射工具类
import com.yf.exam.modules.exam.dto.ExamDTO; // 导入考试DTO
import com.yf.exam.modules.exam.dto.ExamRepoDTO; // 导入考试题库DTO
import com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO; // 导入考试题库扩展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.mapper.ExamMapper; // 导入考试Mapper接口
import com.yf.exam.modules.exam.service.ExamDepartService; // 导入考试部门服务接口
import com.yf.exam.modules.exam.service.ExamRepoService; // 导入考试题库服务接口
import com.yf.exam.modules.exam.service.ExamService; // 导入考试服务接口
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的字符串工具类
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动注入注解
import org.springframework.dao.DuplicateKeyException; // 导入Spring的重复键异常类
import org.springframework.stereotype.Service; // 导入Spring的服务注解
import java.util.List; // 导入Java的List接口
/**
* <p>
*
* </p>
*
* @author
* @since 2020-07-25 16:18
*/
@Service
public class ExamServiceImpl extends ServiceImpl<ExamMapper, Exam> implements ExamService {
* <p>
*
* </p>
* ExamService
*
* @author
* @since 2020-07-25 16:18
*/
@Service // Spring注解声明这是一个服务组件
public class ExamServiceImpl extends ServiceImpl<ExamMapper, Exam> implements ExamService { // 声明类继承自ServiceImpl并实现ExamService接口
@Autowired
private ExamRepoService examRepoService;
private ExamRepoService examRepoService; // 自动注入考试题库服务
@Autowired
private ExamDepartService examDepartService;
private ExamDepartService examDepartService; // 自动注入考试部门服务
@Override
public void save(ExamSaveReqDTO reqDTO) {
// ID
String id = reqDTO.getId();
if(StringUtils.isBlank(id)){
id = IdWorker.getIdStr();
if(StringUtils.isBlank(id)){ // 如果ID为空则生成新的ID
id = IdWorker.getIdStr(); // 使用IdWorker生成ID
}
//复制参数
Exam entity = new Exam();
// 复制参数
Exam entity = new Exam(); // 创建考试实体
// 计算分值
this.calcScore(reqDTO);
this.calcScore(reqDTO); // 调用方法计算分值
// 复制基本数据
BeanMapper.copy(reqDTO, entity);
entity.setId(id);
BeanMapper.copy(reqDTO, entity); // 使用BeanMapper复制属性
entity.setId(id); // 设置ID
// 修复状态
if (reqDTO.getTimeLimit()!=null
if (reqDTO.getTimeLimit() != null
&& !reqDTO.getTimeLimit()
&& reqDTO.getState()!=null
&& reqDTO.getState() != null
&& reqDTO.getState() == 2) {
entity.setState(0);
entity.setState(0); // 如果不限时且状态为2则状态设置为0
} else {
entity.setState(reqDTO.getState());
entity.setState(reqDTO.getState()); // 否则直接设置状态
}
// 题库组卷
try {
examRepoService.saveAll(id, reqDTO.getRepoList());
examRepoService.saveAll(id, reqDTO.getRepoList()); // 调用考试题库服务保存题库
}catch (DuplicateKeyException e){
throw new ServiceException(1, "不能选择重复的题库!");
throw new ServiceException(1, "不能选择重复的题库!"); // 如果出现重复键异常,则抛出服务异常
}
// 开放的部门
if(OpenType.DEPT_OPEN.equals(reqDTO.getOpenType())){
examDepartService.saveAll(id, reqDTO.getDepartIds());
if(OpenType.DEPT_OPEN.equals(reqDTO.getOpenType())){ // 如果开放类型为部门开放
examDepartService.saveAll(id, reqDTO.getDepartIds()); // 调用考试部门服务保存部门
}
this.saveOrUpdate(entity);
this.saveOrUpdate(entity); // 保存或更新考试实体
}
@Override
public ExamSaveReqDTO findDetail(String id) {
ExamSaveReqDTO respDTO = new ExamSaveReqDTO();
Exam exam = this.getById(id);
BeanMapper.copy(exam, respDTO);
ExamSaveReqDTO respDTO = new ExamSaveReqDTO(); // 创建响应DTO
Exam exam = this.getById(id); // 根据ID查询考试实体
BeanMapper.copy(exam, respDTO); // 使用BeanMapper复制属性
// 考试部门
List<String> departIds = examDepartService.listByExam(id);
respDTO.setDepartIds(departIds);
List<String> departIds = examDepartService.listByExam(id); // 调用考试部门服务查询部门ID列表
respDTO.setDepartIds(departIds); // 设置部门ID列表
// 题库
List<ExamRepoExtDTO> repos = examRepoService.listByExam(id);
respDTO.setRepoList(repos);
List<ExamRepoExtDTO> repos = examRepoService.listByExam(id); // 调用考试题库服务查询题库列表
respDTO.setRepoList(repos); // 设置题库列表
return respDTO;
return respDTO; // 返回响应DTO
}
@Override
public ExamDTO findById(String id) {
ExamDTO respDTO = new ExamDTO();
Exam exam = this.getById(id);
BeanMapper.copy(exam, respDTO);
return respDTO;
ExamDTO respDTO = new ExamDTO(); // 创建响应DTO
Exam exam = this.getById(id); // 根据ID查询考试实体
BeanMapper.copy(exam, respDTO); // 使用BeanMapper复制属性
return respDTO; // 返回响应DTO
}
@Override
public IPage<ExamDTO> paging(PagingReqDTO<ExamDTO> reqDTO) {
// 创建分页对象
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize()); // 使用分页请求DTO创建分页对象
//创建分页对象
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize());
//转换结果
IPage<ExamDTO> pageData = baseMapper.paging(page, reqDTO.getParams());
return pageData;
}
// 转换结果
IPage<ExamDTO> pageData = baseMapper.paging(page, reqDTO.getParams()); // 调用Mapper接口的分页方法
return pageData; // 返回分页结果
}
@Override
public IPage<ExamOnlineRespDTO> onlinePaging(PagingReqDTO<ExamDTO> reqDTO) {
// 创建分页对象
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize());
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize()); // 使用分页请求DTO创建分页对象
// 查找分页
IPage<ExamOnlineRespDTO> pageData = baseMapper.online(page, reqDTO.getParams());
return pageData;
IPage<ExamOnlineRespDTO> pageData = baseMapper.online(page, reqDTO.getParams()); // 调用Mapper接口的在线考试分页方法
return pageData; // 返回分页结果
}
@Override
public IPage<ExamReviewRespDTO> reviewPaging(PagingReqDTO<ExamDTO> reqDTO) {
// 创建分页对象
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize());
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize()); // 使用分页请求DTO创建分页对象
// 查找分页
IPage<ExamReviewRespDTO> pageData = baseMapper.reviewPaging(page, reqDTO.getParams());
return pageData;
IPage<ExamReviewRespDTO> pageData = baseMapper.reviewPaging(page, reqDTO.getParams()); // 调用Mapper接口的阅卷分页方法
return pageData; // 返回分页结果
}
/**
*
* @param reqDTO
*
*
* @param reqDTO DTO
*/
private void calcScore(ExamSaveReqDTO reqDTO){
private void calcScore(ExamSaveReqDTO reqDTO) {
// 主观题分数
int objScore = 0;
// 题库组卷
List<ExamRepoExtDTO> repoList = reqDTO.getRepoList();
for(ExamRepoDTO item: repoList){
if(item.getRadioCount()!=null
&& item.getRadioCount()>0
&& item.getRadioScore()!=null
&& item.getRadioScore()>0){
objScore+=item.getRadioCount()*item.getRadioScore();
List<ExamRepoExtDTO> repoList = reqDTO.getRepoList(); // 获取题库列表
for(ExamRepoDTO item : repoList){ // 遍历题库列表
if(item.getRadioCount() != null && item.getRadioCount() > 0 && item.getRadioScore() != null && item.getRadioScore() > 0){
objScore += item.getRadioCount() * item.getRadioScore(); // 计算单选题分数
}
if(item.getMultiCount()!=null
&& item.getMultiCount()>0
&& item.getMultiScore()!=null
&& item.getMultiScore()>0){
objScore+=item.getMultiCount()*item.getMultiScore();
if(item.getMultiCount() != null && item.getMultiCount() > 0 && item.getMultiScore() != null && item.getMultiScore() > 0){
objScore += item.getMultiCount() * item.getMultiScore(); // 计算多选题分数
}
if(item.getJudgeCount()!=null
&& item.getJudgeCount()>0
&& item.getJudgeScore()!=null
&& item.getJudgeScore()>0){
objScore+=item.getJudgeCount()*item.getJudgeScore();
if(item.getJudgeCount() != null && item.getJudgeCount() > 0 && item.getJudgeScore() != null && item.getJudgeScore() > 0){
objScore += item.getJudgeCount() * item.getJudgeScore(); // 计算判断题分数
}
}
reqDTO.setTotalScore(objScore);
reqDTO.setTotalScore(objScore); // 设置总分值
}
}

@ -1,13 +1,19 @@
package com.yf.exam.modules.paper.controller;
package com.yf.exam.modules.paper.controller; // 定义当前类所在的包路径
// 引入分页查询结果的接口
import com.baomidou.mybatisplus.core.metadata.IPage;
// 引入统一的API响应封装类
import com.yf.exam.core.api.ApiRest;
// 引入基础控制器类提供通用的API响应方法
import com.yf.exam.core.api.controller.BaseController;
// 引入各种DTO类用于请求和响应数据传输
import com.yf.exam.core.api.dto.BaseIdReqDTO;
import com.yf.exam.core.api.dto.BaseIdRespDTO;
import com.yf.exam.core.api.dto.BaseIdsReqDTO;
import com.yf.exam.core.api.dto.PagingReqDTO;
// 引入工具类,用于对象之间的属性拷贝
import com.yf.exam.core.utils.BeanMapper;
// 引入试卷相关的DTO类
import com.yf.exam.modules.paper.dto.PaperDTO;
import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
import com.yf.exam.modules.paper.dto.request.PaperAnswerDTO;
@ -17,14 +23,22 @@ import com.yf.exam.modules.paper.dto.request.PaperQuQueryDTO;
import com.yf.exam.modules.paper.dto.response.ExamDetailRespDTO;
import com.yf.exam.modules.paper.dto.response.ExamResultRespDTO;
import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
// 引入试卷实体类
import com.yf.exam.modules.paper.entity.Paper;
// 引入试卷相关的业务处理服务类
import com.yf.exam.modules.paper.service.PaperService;
// 引入用户工具类,获取当前登录用户信息
import com.yf.exam.modules.user.UserUtils;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
// 引入Shiro注解用于角色权限管理
import org.apache.shiro.authz.annotation.RequiresRoles;
// 引入Spring的Bean工具类用于属性复制
import org.springframework.beans.BeanUtils;
// 引入Spring的自动注入注解用于自动注入服务
import org.springframework.beans.factory.annotation.Autowired;
// 引入Spring的Web注解定义HTTP请求的映射方式
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@ -34,123 +48,126 @@ import org.springframework.web.bind.annotation.RestController;
* <p>
*
* </p>
*
*
* @author
* @since 2020-05-25 16:33
*/
@Api(tags={"试卷"})
@RestController
@RequestMapping("/exam/api/paper/paper")
public class PaperController extends BaseController {
@Api(tags={"试卷"}) // Swagger API 文档注解,用于描述该接口属于试卷相关操作
@RestController // 标记为Spring的控制器处理HTTP请求
@RequestMapping("/exam/api/paper/paper") // 定义请求路径的基础路径
public class PaperController extends BaseController { // 继承BaseController类提供基本的API返回
@Autowired
@Autowired // 自动注入PaperService负责业务逻辑处理
private PaperService baseService;
/**
*
* @param reqDTO
* @return
*
* @param reqDTO
* @return
*/
@ApiOperation(value = "分页查找")
@RequestMapping(value = "/paging", method = { RequestMethod.POST})
@ApiOperation(value = "分页查找") // Swagger操作注解用于描述接口
@RequestMapping(value = "/paging", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest<IPage<PaperListRespDTO>> paging(@RequestBody PagingReqDTO<PaperListReqDTO> reqDTO) {
//分页查询并转换
// 调用业务层进行分页查询
IPage<PaperListRespDTO> page = baseService.paging(reqDTO);
// 返回成功响应,并附带查询结果
return super.success(page);
}
/**
*
* @param reqDTO
* @return
* @param reqDTO
* @return ID
*/
@ApiOperation(value = "创建试卷")
@RequestMapping(value = "/create-paper", method = { RequestMethod.POST})
@ApiOperation(value = "创建试卷") // Swagger操作注解用于描述接口
@RequestMapping(value = "/create-paper", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest<BaseIdRespDTO> save(@RequestBody PaperCreateReqDTO reqDTO) {
//复制参数
// 调用业务层创建试卷传入当前用户ID和考试ID
String paperId = baseService.createPaper(UserUtils.getUserId(), reqDTO.getExamId());
// 返回创建结果包括试卷ID
return super.success(new BaseIdRespDTO(paperId));
}
/**
*
* @param reqDTO
* @return
*
* @param reqDTO ID
* @return
*/
@ApiOperation(value = "试卷详情")
@RequestMapping(value = "/paper-detail", method = { RequestMethod.POST})
@ApiOperation(value = "试卷详情") // Swagger操作注解用于描述接口
@RequestMapping(value = "/paper-detail", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest<ExamDetailRespDTO> paperDetail(@RequestBody BaseIdReqDTO reqDTO) {
//根据ID删除
// 调用业务层获取试卷详情
ExamDetailRespDTO respDTO = baseService.paperDetail(reqDTO.getId());
// 返回成功响应,并附带试卷详情
return super.success(respDTO);
}
/**
*
* @param reqDTO
* @return
*
* @param reqDTO IDID
* @return
*/
@ApiOperation(value = "试题详情")
@RequestMapping(value = "/qu-detail", method = { RequestMethod.POST})
@ApiOperation(value = "试题详情") // Swagger操作注解用于描述接口
@RequestMapping(value = "/qu-detail", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest<PaperQuDetailDTO> quDetail(@RequestBody PaperQuQueryDTO reqDTO) {
//根据ID删除
// 调用业务层获取试题详情
PaperQuDetailDTO respDTO = baseService.findQuDetail(reqDTO.getPaperId(), reqDTO.getQuId());
// 返回成功响应,并附带试题详情
return super.success(respDTO);
}
/**
*
* @param reqDTO
* @return
* @param reqDTO
* @return
*/
@ApiOperation(value = "填充答案")
@RequestMapping(value = "/fill-answer", method = { RequestMethod.POST})
@ApiOperation(value = "填充答案") // Swagger操作注解用于描述接口
@RequestMapping(value = "/fill-answer", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest<PaperQuDetailDTO> fillAnswer(@RequestBody PaperAnswerDTO reqDTO) {
//根据ID删除
// 调用业务层填充答案操作
baseService.fillAnswer(reqDTO);
// 返回成功响应
return super.success();
}
/**
*
* @param reqDTO
* @return
* @param reqDTO ID
* @return
*/
@ApiOperation(value = "交卷操作")
@RequestMapping(value = "/hand-exam", method = { RequestMethod.POST})
@ApiOperation(value = "交卷操作") // Swagger操作注解用于描述接口
@RequestMapping(value = "/hand-exam", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest<PaperQuDetailDTO> handleExam(@RequestBody BaseIdReqDTO reqDTO) {
//根据ID删除
// 调用业务层进行交卷操作
baseService.handExam(reqDTO.getId());
// 返回成功响应
return super.success();
}
/**
*
* @param reqDTO
* @return
*
* @param reqDTO ID
* @return
*/
@ApiOperation(value = "试卷详情")
@RequestMapping(value = "/paper-result", method = { RequestMethod.POST})
@ApiOperation(value = "试卷结果") // Swagger操作注解用于描述接口
@RequestMapping(value = "/paper-result", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest<ExamResultRespDTO> paperResult(@RequestBody BaseIdReqDTO reqDTO) {
//根据ID删除
// 调用业务层获取试卷的考试结果
ExamResultRespDTO respDTO = baseService.paperResult(reqDTO.getId());
// 返回成功响应,并附带试卷结果
return super.success(respDTO);
}
/**
*
* @return
* @return
*/
@ApiOperation(value = "检测进行中的考试")
@RequestMapping(value = "/check-process", method = { RequestMethod.POST})
@ApiOperation(value = "检测进行中的考试") // Swagger操作注解用于描述接口
@RequestMapping(value = "/check-process", method = { RequestMethod.POST}) // 定义POST请求路径
public ApiRest<PaperDTO> checkProcess() {
//复制参数
// 调用业务层检测用户是否有未完成的考试
PaperDTO dto = baseService.checkProcess(UserUtils.getUserId());
// 返回成功响应,并附带考试进程数据
return super.success(dto);
}
}

@ -1,79 +1,83 @@
package com.yf.exam.modules.paper.dto;
package com.yf.exam.modules.paper.dto; // 定义当前类所在的包路径
// 引入Dict注解用于字典表的映射
import com.yf.exam.core.annon.Dict;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入Serializable接口用于对象序列化
import java.io.Serializable;
// 引入Date类用于表示日期和时间
import java.util.Date;
/**
* <p>
*
* </p>
*
* @author
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷", description="试卷")
public class PaperDTO implements Serializable {
private static final long serialVersionUID = 1L;
* <p>
*
* </p>
* ID
* 使
*
* @author
* @since 2020-05-25 17:31
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="试卷", description="试卷") // Swagger注解用于描述该类在API文档中的作用和说明
public class PaperDTO implements Serializable { // 实现Serializable接口表示该类的对象可以被序列化
@ApiModelProperty(value = "试卷ID", required=true)
private String id;
private static final long serialVersionUID = 1L; // 序列化版本ID用于序列化和反序列化操作
@Dict(dictTable = "sys_user", dicText = "real_name", dicCode = "id")
@ApiModelProperty(value = "用户ID", required=true)
private String userId;
@ApiModelProperty(value = "试卷ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String id; // 试卷ID
@Dict(dictTable = "sys_depart", dicText = "dept_name", dicCode = "id")
@ApiModelProperty(value = "部门ID", required=true)
private String departId;
@Dict(dictTable = "sys_user", dicText = "real_name", dicCode = "id") // 字典表映射,映射用户表的姓名字段
@ApiModelProperty(value = "用户ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String userId; // 用户ID
@ApiModelProperty(value = "规则ID", required=true)
private String examId;
@Dict(dictTable = "sys_depart", dicText = "dept_name", dicCode = "id") // 字典表映射,映射部门表的部门名称字段
@ApiModelProperty(value = "部门ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String departId; // 部门ID
@ApiModelProperty(value = "考试标题", required=true)
private String title;
@ApiModelProperty(value = "规则ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String examId; // 规则ID表示该试卷对应的考试规则
@ApiModelProperty(value = "考试时长", required=true)
private Integer totalTime;
@ApiModelProperty(value = "考试标题", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String title; // 考试标题,表示试卷的名称
@ApiModelProperty(value = "用户时长", required=true)
private Integer userTime;
@ApiModelProperty(value = "考试时长", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer totalTime; // 考试时长(单位:分钟)
@ApiModelProperty(value = "试卷总分", required=true)
private Integer totalScore;
@ApiModelProperty(value = "用户时长", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer userTime; // 用户已使用的时间(单位:分钟)
@ApiModelProperty(value = "及格分", required=true)
private Integer qualifyScore;
@ApiModelProperty(value = "试卷总分", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer totalScore; // 试卷总分
@ApiModelProperty(value = "客观分", required=true)
private Integer objScore;
@ApiModelProperty(value = "及格分", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer qualifyScore; // 及格分数
@ApiModelProperty(value = "观分", required=true)
private Integer subjScore;
@ApiModelProperty(value = "观分", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer objScore; // 客观题分数
@ApiModelProperty(value = "用户得分", required=true)
private Integer userScore;
@ApiModelProperty(value = "主观分", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer subjScore; // 主观题分数
@ApiModelProperty(value = "是否包含简答题", required=true)
private Boolean hasSaq;
@ApiModelProperty(value = "用户得分", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer userScore; // 用户得分
@ApiModelProperty(value = "试卷状态", required=true)
private Integer state;
@ApiModelProperty(value = "是否包含简答题", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Boolean hasSaq; // 是否包含简答题,布尔类型,表示该试卷是否有简答题
@ApiModelProperty(value = "创建时间", required=true)
private Date createTime;
@ApiModelProperty(value = "试卷状态", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer state; // 试卷状态,表示试卷的当前状态,如未开始、进行中、已结束等
@ApiModelProperty(value = "更新时间", required=true)
private Date updateTime;
@ApiModelProperty(value = "创建时间", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Date createTime; // 创建时间,表示试卷的创建时间
@ApiModelProperty(value = "截止时间")
private Date limitTime;
@ApiModelProperty(value = "更新时间", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Date updateTime; // 更新时间,表示试卷的最后更新时间
@ApiModelProperty(value = "截止时间") // Swagger注解描述该字段在API文档中的含义
private Date limitTime; // 截止时间,表示考试的最后提交时间
}

@ -1,48 +1,50 @@
package com.yf.exam.modules.paper.dto;
package com.yf.exam.modules.paper.dto; // 定义当前类所在的包路径
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入Serializable接口用于对象序列化
import java.io.Serializable;
/**
* <p>
*
* </p>
*
* @author
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")
public class PaperQuAnswerDTO implements Serializable {
private static final long serialVersionUID = 1L;
* <p>
*
* </p>
* IDID
*
*
* @author
* @since 2020-05-25 17:31
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案") // Swagger注解用于描述该类在API文档中的作用和说明
public class PaperQuAnswerDTO implements Serializable { // 实现Serializable接口表示该类的对象可以被序列化
@ApiModelProperty(value = "自增ID", required=true)
private String id;
private static final long serialVersionUID = 1L; // 序列化版本ID用于序列化和反序列化操作
@ApiModelProperty(value = "试卷ID", required=true)
private String paperId;
@ApiModelProperty(value = "自增ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String id; // 自增ID表示备选答案的唯一标识符
@ApiModelProperty(value = "回答项ID", required=true)
private String answerId;
@ApiModelProperty(value = "试卷ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String paperId; // 试卷ID表示该备选答案所属的试卷
@ApiModelProperty(value = "题目ID", required=true)
private String quId;
@ApiModelProperty(value = "回答项ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String answerId; // 回答项ID表示该备选答案的唯一标识符
@ApiModelProperty(value = "是否正确项", required=true)
private Boolean isRight;
@ApiModelProperty(value = "题目ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String quId; // 题目ID表示该备选答案所属的题目
@ApiModelProperty(value = "是否选中", required=true)
private Boolean checked;
@ApiModelProperty(value = "是否正确项", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Boolean isRight; // 是否正确项,布尔值,表示该备选答案是否是正确答案
@ApiModelProperty(value = "排序", required=true)
private Integer sort;
@ApiModelProperty(value = "是否选中", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Boolean checked; // 是否选中,布尔值,表示该备选答案是否已被选中
@ApiModelProperty(value = "选项标签", required=true)
private String abc;
@ApiModelProperty(value = "排序", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer sort; // 排序,表示该备选答案在题目中的排序位置
@ApiModelProperty(value = "选项标签", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String abc; // 选项标签,通常为 A、B、C、D 等,表示该备选答案的标识符
}

@ -1,54 +1,55 @@
package com.yf.exam.modules.paper.dto;
package com.yf.exam.modules.paper.dto; // 定义当前类所在的包路径
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入Serializable接口用于对象序列化
import java.io.Serializable;
/**
* <p>
*
* </p>
*
* @author
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷考题", description="试卷考题")
public class PaperQuDTO implements Serializable {
private static final long serialVersionUID = 1L;
* <p>
*
* </p>
* IDID
*
* @author
* @since 2020-05-25 17:31
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="试卷考题", description="试卷考题") // Swagger注解用于描述该类在API文档中的作用和说明
public class PaperQuDTO implements Serializable { // 实现Serializable接口表示该类的对象可以被序列化
@ApiModelProperty(value = "ID", required=true)
private String id;
private static final long serialVersionUID = 1L; // 序列化版本ID用于序列化和反序列化操作
@ApiModelProperty(value = "试卷ID", required=true)
private String paperId;
@ApiModelProperty(value = "ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String id; // 题目ID唯一标识符
@ApiModelProperty(value = "题目ID", required=true)
private String quId;
@ApiModelProperty(value = "试卷ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String paperId; // 试卷ID表示该题目所属的试卷
@ApiModelProperty(value = "题目类型", required=true)
private Integer quType;
@ApiModelProperty(value = "题目ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String quId; // 题目ID唯一标识该题目
@ApiModelProperty(value = "是否已答", required=true)
private Boolean answered;
@ApiModelProperty(value = "题目类型", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer quType; // 题目类型,表示题目的分类,如选择题、判断题、主观题等
@ApiModelProperty(value = "主观答案", required=true)
private String answer;
@ApiModelProperty(value = "是否已答", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Boolean answered; // 是否已答,布尔值,表示该题目是否已被回答
@ApiModelProperty(value = "问题排序", required=true)
private Integer sort;
@ApiModelProperty(value = "主观答案", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String answer; // 主观答案,表示对该题目的回答内容(适用于主观题)
@ApiModelProperty(value = "单题分分值", required=true)
private Integer score;
@ApiModelProperty(value = "问题排序", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer sort; // 问题排序,表示该题目在试卷中的顺序
@ApiModelProperty(value = "实际得分(主观题)", required=true)
private Integer actualScore;
@ApiModelProperty(value = "单题分分值", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer score; // 单题分值,表示该题目的满分
@ApiModelProperty(value = "是否答对", required=true)
private Boolean isRight;
@ApiModelProperty(value = "实际得分(主观题)", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer actualScore; // 实际得分,表示用户在该题目中实际得到的分数(适用于主观题)
@ApiModelProperty(value = "是否答对", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Boolean isRight; // 是否答对,布尔值,表示用户是否答对了该题目
}

@ -1,29 +1,30 @@
package com.yf.exam.modules.paper.dto.ext;
package com.yf.exam.modules.paper.dto.ext; // 定义该类所在的包路径
// 引入试题答案DTO类作为当前类的父类
import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
/**
* <p>
*
* </p>
*
* PaperQuAnswerDTO
* @author
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")
public class PaperQuAnswerExtDTO extends PaperQuAnswerDTO {
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案") // Swagger注解描述模型信息生成API文档时使用
public class PaperQuAnswerExtDTO extends PaperQuAnswerDTO { // 继承自PaperQuAnswerDTO类扩展了额外属性
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "试题图片", required=true)
private String image;
@ApiModelProperty(value = "答案内容", required=true)
private String content;
private static final long serialVersionUID = 1L; // 序列化版本号,用于序列化和反序列化时的版本控制
@ApiModelProperty(value = "试题图片", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String image; // 试题对应的图片内容
@ApiModelProperty(value = "答案内容", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String content; // 备选答案的具体内容
}

@ -1,32 +1,35 @@
package com.yf.exam.modules.paper.dto.ext;
package com.yf.exam.modules.paper.dto.ext; // 定义当前类所在的包路径
// 引入试题DTO类作为当前类的父类
import com.yf.exam.modules.paper.dto.PaperQuDTO;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入List集合用于存储多个备选答案
import java.util.List;
/**
* <p>
*
* </p>
*
* PaperQuDTO
* @author
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷题目详情类", description="试卷题目详情类")
public class PaperQuDetailDTO extends PaperQuDTO {
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="试卷题目详情类", description="试卷题目详情类") // Swagger注解用于描述该类在API文档中的作用和说明
public class PaperQuDetailDTO extends PaperQuDTO { // 继承自PaperQuDTO类扩展了额外属性
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 序列化版本号,用于序列化和反序列化时的版本控制
@ApiModelProperty(value = "图片", required=true)
private String image;
@ApiModelProperty(value = "图片", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String image; // 题目的图片内容
@ApiModelProperty(value = "题目内容", required=true)
private String content;
@ApiModelProperty(value = "题目内容", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String content; // 试题的具体内容
@ApiModelProperty(value = "答案内容", required=true)
List<PaperQuAnswerExtDTO> answerList;
@ApiModelProperty(value = "答案内容", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private List<PaperQuAnswerExtDTO> answerList; // 存储该题目的备选答案使用List集合存储多个答案
}

@ -1,22 +1,25 @@
package com.yf.exam.modules.paper.dto.request;
package com.yf.exam.modules.paper.dto.request; // 定义当前类所在的包路径
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入List集合用于存储多个答案
import java.util.List;
/**
* @author bool
*
* PaperQuQueryDTO
*/
@Data
@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")
public class PaperAnswerDTO extends PaperQuQueryDTO {
@ApiModelProperty(value = "回答列表", required=true)
private List<String> answers;
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类") // Swagger注解用于描述该类在API文档中的作用和说明
public class PaperAnswerDTO extends PaperQuQueryDTO { // 继承自PaperQuQueryDTO类扩展了额外属性
@ApiModelProperty(value = "主观答案", required=true)
private String answer;
@ApiModelProperty(value = "回答列表", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private List<String> answers; // 存储多个选择题答案的列表
@ApiModelProperty(value = "主观答案", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String answer; // 存储主观题的答案内容
}

@ -1,22 +1,26 @@
package com.yf.exam.modules.paper.dto.request;
package com.yf.exam.modules.paper.dto.request; // 定义当前类所在的包路径
// 引入父类BaseDTO用于继承基础字段和功能
import com.yf.exam.core.api.dto.BaseDTO;
// 引入Jackson注解用于处理JSON序列化时忽略某些字段
import com.fasterxml.jackson.annotation.JsonIgnore;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
/**
* @author bool
* IDID
*/
@Data
@ApiModel(value="试卷创建请求类", description="试卷创建请求类")
public class PaperCreateReqDTO extends BaseDTO {
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="试卷创建请求类", description="试卷创建请求类") // Swagger注解用于描述该类在API文档中的作用和说明
public class PaperCreateReqDTO extends BaseDTO { // 继承自BaseDTO类扩展了考试ID和用户ID字段
@JsonIgnore
private String userId;
@ApiModelProperty(value = "考试ID", required=true)
private String examId;
@JsonIgnore // Jackson注解表示在进行JSON序列化/反序列化时忽略该字段
private String userId; // 存储用户ID通常用于标识发起请求的用户但在JSON序列化中不会被传递
@ApiModelProperty(value = "考试ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String examId; // 存储考试ID用于创建试卷时指定关联的考试
}

@ -1,39 +1,40 @@
package com.yf.exam.modules.paper.dto.request;
package com.yf.exam.modules.paper.dto.request; // 定义当前类所在的包路径
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入Serializable接口用于对象序列化
import java.io.Serializable;
/**
* <p>
*
* </p>
*
* IDIDID
*
* @author
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷", description="试卷")
public class PaperListReqDTO implements Serializable {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "用户ID", required=true)
private String userId;
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="试卷", description="试卷") // Swagger注解描述该类在API文档中的作用和说明
public class PaperListReqDTO implements Serializable { // 实现Serializable接口支持对象的序列化
@ApiModelProperty(value = "部门ID", required=true)
private String departId;
private static final long serialVersionUID = 1L; // 序列化版本号,用于序列化和反序列化时的版本控制
@ApiModelProperty(value = "规则ID", required=true)
private String examId;
@ApiModelProperty(value = "用户ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String userId; // 存储请求发起者的用户ID通常用于标识用户
@ApiModelProperty(value = "用户昵称", required=true)
private String realName;
@ApiModelProperty(value = "部门ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String departId; // 存储请求者所在部门的ID用于查询特定部门的试卷
@ApiModelProperty(value = "试卷状态", required=true)
private Integer state;
@ApiModelProperty(value = "规则ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String examId; // 存储与试卷相关的考试规则ID用于标识试卷属于哪种考试
@ApiModelProperty(value = "用户昵称", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String realName; // 存储用户的真实姓名,用于标识请求者
@ApiModelProperty(value = "试卷状态", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private Integer state; // 存储试卷的状态,可能的值如:未开始、进行中、已完成等
}

@ -1,21 +1,25 @@
package com.yf.exam.modules.paper.dto.request;
package com.yf.exam.modules.paper.dto.request; // 定义当前类所在的包路径
// 引入父类BaseDTO用于继承基础字段和功能
import com.yf.exam.core.api.dto.BaseDTO;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
/**
* @author bool
*
* IDID
*/
@Data
@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")
public class PaperQuQueryDTO extends BaseDTO {
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类") // Swagger注解用于描述该类在API文档中的作用和说明
public class PaperQuQueryDTO extends BaseDTO { // 继承自BaseDTO类扩展了试卷ID和题目ID字段
@ApiModelProperty(value = "试卷ID", required=true)
private String paperId;
@ApiModelProperty(value = "题目ID", required=true)
private String quId;
@ApiModelProperty(value = "试卷ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String paperId; // 存储试卷ID用于查询特定试卷的题目详情
@ApiModelProperty(value = "题目ID", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String quId; // 存储题目ID用于查询指定试卷中的某一道题目
}

@ -1,38 +1,48 @@
package com.yf.exam.modules.paper.dto.response;
package com.yf.exam.modules.paper.dto.response; // 定义当前类所在的包路径
// 引入父类PaperDTO用于继承基础字段和功能
import com.yf.exam.modules.paper.dto.PaperDTO;
// 引入PaperQuDTO类用于表示试题的DTO
import com.yf.exam.modules.paper.dto.PaperQuDTO;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入Calendar类用于时间计算
import java.util.Calendar;
// 引入List集合用于存储试题列表
import java.util.List;
@Data
@ApiModel(value="考试详情", description="考试详情")
public class ExamDetailRespDTO extends PaperDTO {
/**
* <p>
*
* </p>
* PaperDTO
*
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="考试详情", description="考试详情") // Swagger注解用于描述该类在API文档中的作用和说明
public class ExamDetailRespDTO extends PaperDTO { // 继承自PaperDTO表示考试详情响应DTO
@ApiModelProperty(value = "单选题列表", required=true)
private List<PaperQuDTO> radioList;
@ApiModelProperty(value = "单选题列表", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private List<PaperQuDTO> radioList; // 存储单选题的列表使用PaperQuDTO表示单个试题
@ApiModelProperty(value = "多选题列表", required=true)
private List<PaperQuDTO> multiList;
@ApiModelProperty(value = "多选题列表", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private List<PaperQuDTO> multiList; // 存储多选题的列表使用PaperQuDTO表示单个试题
@ApiModelProperty(value = "判断题", required=true)
private List<PaperQuDTO> judgeList;
@ApiModelProperty(value = "判断题", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private List<PaperQuDTO> judgeList; // 存储判断题的列表使用PaperQuDTO表示单个试题
@ApiModelProperty(value = "剩余结束秒数", required=true)
public Long getLeftSeconds(){
@ApiModelProperty(value = "剩余结束秒数", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
public Long getLeftSeconds(){ // 计算剩余时间的方法,返回剩余的秒数
// 结束时间
Calendar cl = Calendar.getInstance();
cl.setTime(this.getCreateTime());
cl.add(Calendar.MINUTE, getTotalTime());
Calendar cl = Calendar.getInstance(); // 获取当前时间的Calendar实例
cl.setTime(this.getCreateTime()); // 设置Calendar的时间为试卷的创建时间
cl.add(Calendar.MINUTE, getTotalTime()); // 在创建时间的基础上加上试卷的总时间(分钟)
return (cl.getTimeInMillis() - System.currentTimeMillis()) / 1000;
// 计算剩余时间(单位:秒)
return (cl.getTimeInMillis() - System.currentTimeMillis()) / 1000; // 返回剩余时间(当前时间到结束时间的差值,以秒为单位)
}
}

@ -1,18 +1,29 @@
package com.yf.exam.modules.paper.dto.response;
package com.yf.exam.modules.paper.dto.response; // 定义当前类所在的包路径
// 引入父类PaperDTO用于继承基础字段和功能
import com.yf.exam.modules.paper.dto.PaperDTO;
// 引入PaperQuDetailDTO类用于表示试题详细信息
import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入List集合用于存储试题列表
import java.util.List;
@Data
@ApiModel(value="考试结果展示响应类", description="考试结果展示响应类")
public class ExamResultRespDTO extends PaperDTO {
/**
* <p>
*
* </p>
* PaperDTO
*
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="考试结果展示响应类", description="考试结果展示响应类") // Swagger注解用于描述该类在API文档中的作用和说明
public class ExamResultRespDTO extends PaperDTO { // 继承自PaperDTO表示考试结果展示响应DTO
@ApiModelProperty(value = "问题列表", required=true)
private List<PaperQuDetailDTO> quList;
@ApiModelProperty(value = "问题列表", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private List<PaperQuDetailDTO> quList; // 存储试题详细信息的列表使用PaperQuDetailDTO表示每个试题的详细数据
}

@ -1,26 +1,29 @@
package com.yf.exam.modules.paper.dto.response;
package com.yf.exam.modules.paper.dto.response; // 定义当前类所在的包路径
// 引入父类PaperDTO用于继承基本的试卷信息
import com.yf.exam.modules.paper.dto.PaperDTO;
// 引入Swagger注解用于API文档生成
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
/**
* <p>
*
* </p>
*
* @author
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷列表响应类", description="试卷列表响应类")
public class PaperListRespDTO extends PaperDTO {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "人员", required=true)
private String realName;
* <p>
*
* </p>
* PaperDTOrealName
*
*
* @author
* @since 2020-05-25 17:31
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@ApiModel(value="试卷列表响应类", description="试卷列表响应类") // Swagger注解用于描述该类在API文档中的作用和说明
public class PaperListRespDTO extends PaperDTO { // 继承自PaperDTO表示试卷列表响应DTO
private static final long serialVersionUID = 1L; // 序列化版本ID用于序列化和反序列化操作
@ApiModelProperty(value = "人员", required=true) // Swagger注解描述该字段在API文档中的含义并标注该字段为必填项
private String realName; // 存储人员姓名,用于表示与该试卷相关的人员信息
}

@ -1,125 +1,104 @@
package com.yf.exam.modules.paper.entity;
package com.yf.exam.modules.paper.entity; // 定义当前类所在的包路径
// 引入MyBatis Plus的相关注解
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
// 引入Date类用于时间相关的字段
import java.util.Date;
/**
* <p>
*
* </p>
*
* @author
* @since 2020-05-25 17:31
*/
@Data
@TableName("el_paper")
public class Paper extends Model<Paper> {
private static final long serialVersionUID = 1L;
* <p>
*
* </p>
* `el_paper`
*
* @author
* @since 2020-05-25 17:31
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@TableName("el_paper") // MyBatis Plus注解指定该实体类对应的数据库表名
public class Paper extends Model<Paper> { // 继承MyBatis Plus的Model类提供了CRUD等基础操作
private static final long serialVersionUID = 1L; // 序列化版本ID用于序列化和反序列化操作
/**
* ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
@TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解指定主键字段及其生成策略
private String id; // 试卷ID唯一标识符
/**
* ID
*/
@TableField("user_id")
private String userId;
@TableField("user_id") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private String userId; // 用户ID表示创建该试卷的用户
/**
* ID
*/
@TableField("depart_id")
private String departId;
@TableField("depart_id") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private String departId; // 部门ID表示该试卷所属的部门
/**
* ID
*/
@TableField("exam_id")
private String examId;
@TableField("exam_id") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private String examId; // 规则ID表示该试卷所属的考试规则
/**
*
*/
private String title;
private String title; // 考试标题,表示试卷的名称或标题
/**
*
*/
@TableField("total_time")
private Integer totalTime;
@TableField("total_time") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer totalTime; // 考试时长,单位为分钟
/**
*
*/
@TableField("user_time")
private Integer userTime;
@TableField("user_time") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer userTime; // 用户实际用时,单位为分钟
/**
*
*/
@TableField("total_score")
private Integer totalScore;
@TableField("total_score") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer totalScore; // 试卷的总分数
/**
*
*/
@TableField("qualify_score")
private Integer qualifyScore;
@TableField("qualify_score") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer qualifyScore; // 及格分数,表示通过该试卷的最低分数
/**
*
*/
@TableField("obj_score")
private Integer objScore;
@TableField("obj_score") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer objScore; // 客观题部分的得分
/**
*
*/
@TableField("subj_score")
private Integer subjScore;
@TableField("subj_score") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer subjScore; // 主观题部分的得分
/**
*
*/
@TableField("user_score")
private Integer userScore;
@TableField("user_score") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer userScore; // 用户在该试卷上的得分
/**
*
*/
@TableField("has_saq")
private Boolean hasSaq;
@TableField("has_saq") // MyBatis Plus注解指定字段与数据库表字段的映射关系
/**
*
*/
private Integer state;
/**
*
*/
@TableField("create_time")
private Date createTime;
/**
*
*/
@TableField("update_time")
private Date updateTime;
/**
*
*/
@TableField("limit_time")
private Date limitTime;
}

@ -1,80 +1,82 @@
package com.yf.exam.modules.paper.entity;
package com.yf.exam.modules.paper.entity; // 定义当前类所在的包路径
// 引入MyBatis Plus的相关注解
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
/**
* <p>
*
* </p>
*
* @author
* @since 2020-05-25 17:31
*/
@Data
@TableName("el_paper_qu")
public class PaperQu extends Model<PaperQu> {
* <p>
*
* </p>
* `el_paper_qu`
*
* @author
* @since 2020-05-25 17:31
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@TableName("el_paper_qu") // MyBatis Plus注解指定该实体类对应的数据库表名
public class PaperQu extends Model<PaperQu> { // 继承MyBatis Plus的Model类提供了基础的CRUD等操作
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 序列化版本ID用于序列化和反序列化操作
/**
* ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
@TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解指定主键字段及其生成策略
private String id; // 题目ID唯一标识符
/**
* ID
*/
@TableField("paper_id")
private String paperId;
@TableField("paper_id") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private String paperId; // 试卷ID表示该题目所属的试卷ID
/**
* ID
*/
@TableField("qu_id")
private String quId;
@TableField("qu_id") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private String quId; // 题目ID唯一标识符
/**
*
*/
@TableField("qu_type")
private Integer quType;
@TableField("qu_type") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer quType; // 题目类型,表示该题目属于哪种类型(例如单选题、多选题、主观题等)
/**
*
*/
private Boolean answered;
private Boolean answered; // 是否已经回答,布尔值,表示该题目是否已经被回答
/**
*
*/
private String answer;
private String answer; // 主观题的答案,保存用户的回答内容
/**
*
*/
private Integer sort;
private Integer sort; // 问题在试卷中的排序,决定题目的显示顺序
/**
*
*/
private Integer score;
private Integer score; // 每道题的分值,表示该题目的得分值
/**
* ()
*/
@TableField("actual_score")
private Integer actualScore;
@TableField("actual_score") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Integer actualScore; // 主观题的实际得分,可能与用户给出的答案相关
/**
*
*/
@TableField("is_right")
private Boolean isRight;
@TableField("is_right") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Boolean isRight; // 是否答对,布尔值,表示用户是否答对了该题目
}

@ -1,68 +1,71 @@
package com.yf.exam.modules.paper.entity;
package com.yf.exam.modules.paper.entity; // 定义当前类所在的包路径
// 引入MyBatis Plus的相关注解
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
// 引入Lombok注解用于自动生成getter、setter等方法
import lombok.Data;
/**
* <p>
*
* </p>
*
* @author
* @since 2020-05-25 17:31
*/
@Data
@TableName("el_paper_qu_answer")
public class PaperQuAnswer extends Model<PaperQuAnswer> {
* <p>
*
* </p>
* `el_paper_qu_answer`
*
* @author
* @since 2020-05-25 17:31
*/
@Data // Lombok注解自动生成getter、setter、toString、equals和hashCode方法
@TableName("el_paper_qu_answer") // MyBatis Plus注解指定该实体类对应的数据库表名
public class PaperQuAnswer extends Model<PaperQuAnswer> { // 继承MyBatis Plus的Model类提供了基础的CRUD等操作
private static final long serialVersionUID = 1L; // 序列化版本ID用于序列化和反序列化操作
/**
* ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
@TableId(value = "id", type = IdType.ASSIGN_ID) // MyBatis Plus注解指定主键字段及其生成策略
private String id; // 唯一标识符ID数据库中的主键
/**
* ID
*/
@TableField("paper_id")
private String paperId;
@TableField("paper_id") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private String paperId; // 该备选答案对应的试卷ID
/**
* ID
*/
@TableField("answer_id")
private String answerId;
@TableField("answer_id") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private String answerId; // 该备选答案的唯一标识符ID
/**
* ID
*/
@TableField("qu_id")
private String quId;
@TableField("qu_id") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private String quId; // 该备选答案所属的题目ID
/**
*
*/
@TableField("is_right")
private Boolean isRight;
@TableField("is_right") // MyBatis Plus注解指定字段与数据库表字段的映射关系
private Boolean isRight; // 是否是正确答案布尔值true 表示正确false 表示错误)
/**
*
*/
private Boolean checked;
private Boolean checked; // 该备选答案是否被选中布尔值true 表示已选中false 表示未选中)
/**
*
*/
private Integer sort;
private Integer sort; // 备选答案的排序,决定该答案在选项中的位置
/**
*
*/
private String abc;
private String abc; // 备选答案的标签通常为A、B、C、D等用于显示选项
}

@ -1,33 +1,38 @@
package com.yf.exam.modules.paper.enums;
package com.yf.exam.modules.paper.enums; // 定义当前类所在的包路径
/**
*
* <p>
*
* </p>
* 使
*
* @author bool
* @date 2019-10-30 13:11
*/
public interface ExamState {
/**
*
*
*/
Integer ENABLE = 0;
/**
*
*
*/
Integer DISABLED = 1;
/**
*
*
*/
Integer READY_START = 2;
/**
*
*
*/
Integer OVERDUE = 3;
}

@ -1,33 +1,38 @@
package com.yf.exam.modules.paper.enums;
package com.yf.exam.modules.paper.enums; // 定义当前类所在的包路径
/**
*
* <p>
*
* </p>
* 使
*
* @author bool
* @date 2019-10-30 13:11
*/
public interface PaperState {
/**
*
*
*/
Integer ING = 0;
/**
*
*
*/
Integer WAIT_OPT = 1;
/**
*
*
*/
Integer FINISHED = 2;
/**
*
* 退
*/
Integer BREAK = 3;
}

@ -1,45 +1,61 @@
package com.yf.exam.modules.paper.job;
import com.yf.exam.ability.job.service.JobService;
import com.yf.exam.modules.paper.service.PaperService;
import lombok.extern.log4j.Log4j2;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
package com.yf.exam.modules.paper.job; // 定义类所在的包路径
import com.yf.exam.ability.job.service.JobService; // 导入 JobService 类,用于获取任务数据
import com.yf.exam.modules.paper.service.PaperService; // 导入 PaperService 类,用于处理试卷相关的业务逻辑
import lombok.extern.log4j.Log4j2; // 引入 log4j2 日志工具
import org.quartz.Job; // 导入 Quartz 作业接口
import org.quartz.JobDetail; // 导入 Quartz JobDetail 类
import org.quartz.JobExecutionContext; // 导入 Quartz JobExecutionContext 类
import org.quartz.JobExecutionException; // 导入 Quartz JobExecutionException 类
import org.springframework.beans.factory.annotation.Autowired; // 引入 Spring 注解,用于自动注入依赖
import org.springframework.stereotype.Component; // 引入 Spring 组件注解,标识为 Spring Bean
/**
*
* <p>
* Quartz
* PaperService
* </p>
*
* @author bool
*/
@Log4j2
@Component
@Log4j2 // 启用 log4j2 日志记录
@Component // 标识该类为一个 Spring 组件Spring 会自动将其注册为 Bean
public class BreakExamJob implements Job {
// 自动注入 PaperService用于处理与试卷相关的业务逻辑
@Autowired
private PaperService paperService;
/**
*
*
* <p>
* Quartz
* PaperService
* </p>
*
* @param jobExecutionContext Quartz
* @throws JobExecutionException
*/
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
JobDetail detail = jobExecutionContext.getJobDetail();
String name = detail.getKey().getName();
String group = detail.getKey().getGroup();
// 从 jobExecutionContext 中获取任务的详细信息
JobDetail detail = jobExecutionContext.getJobDetail(); // 获取任务详情
String name = detail.getKey().getName(); // 获取任务名称
String group = detail.getKey().getGroup(); // 获取任务分组
// 获取任务的附加数据,通常是任务触发时的相关参数
String data = String.valueOf(detail.getJobDataMap().get(JobService.TASK_DATA));
// 打印任务执行日志,便于调试和跟踪
log.info("++++++++++定时任务:处理到期的交卷");
log.info("++++++++++jobName:{}", name);
log.info("++++++++++jobGroup:{}", group);
log.info("++++++++++taskData:{}", data);
// 强制交卷
// 调用 PaperService 进行强制交卷操作
// data 参数通常是考试 ID 或者某种标识符,用于识别需要交卷的考试
paperService.handExam(data);
}
}

@ -1,39 +1,46 @@
package com.yf.exam.modules.paper.mapper;
package com.yf.exam.modules.paper.mapper; // 定义类所在的包路径
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yf.exam.modules.paper.dto.PaperDTO;
import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;
import com.yf.exam.modules.paper.dto.response.PaperListRespDTO;
import com.yf.exam.modules.paper.entity.Paper;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入 MyBatis-Plus 的 BaseMapper
import com.baomidou.mybatisplus.core.metadata.IPage; // 引入分页结果接口 IPage
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 引入分页插件 Page
import com.yf.exam.modules.paper.dto.PaperDTO; // 引入 DTO 类,表示试卷数据传输对象
import com.yf.exam.modules.paper.dto.request.PaperListReqDTO; // 引入请求 DTO 类,表示查询试卷时的请求参数
import com.yf.exam.modules.paper.dto.response.PaperListRespDTO; // 引入响应 DTO 类,表示查询试卷时的响应结果
import com.yf.exam.modules.paper.entity.Paper; // 引入实体类,表示试卷数据表中的记录
import org.apache.ibatis.annotations.Param; // 引入 MyBatis 注解,用于指定 SQL 查询中的参数
import java.util.List;
/**
* <p>
* Mapper
* </p>
*
* @author
* @since 2020-05-25 16:33
*/
public interface PaperMapper extends BaseMapper<Paper> {
* <p>
* Mapper
* </p>
*
* @author
* @since 2020-05-25 16:33
*/
public interface PaperMapper extends BaseMapper<Paper> { // 继承 MyBatis-Plus 提供的 BaseMapper自动实现 CRUD 操作
/**
*
* @param page
* @param query
* @return
* <p>
* `Page` `PaperListReqDTO`
* </p>
*
* @param page
* @param query ID ID
* @return `IPage<PaperListRespDTO>`
*/
IPage<PaperListRespDTO> paging(Page page, @Param("query") PaperListReqDTO query);
/**
*
* @param query
* @return
* <p>
*
* </p>
*
* @param query ID ID
* @return `List<PaperListRespDTO>` DTO
*/
List<PaperListRespDTO> list(@Param("query") PaperDTO query);
}

@ -1,27 +1,33 @@
package com.yf.exam.modules.paper.mapper;
package com.yf.exam.modules.paper.mapper; // 指定该类所在的包路径
// 导入BaseMapper接口提供通用的CRUD操作
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
// 导入PaperQuAnswerExtDTO类表示试卷考题备选答案的扩展数据传输对象
import com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO;
// 导入PaperQuAnswer实体类表示试卷考题备选答案的数据模型
import com.yf.exam.modules.paper.entity.PaperQuAnswer;
// 导入MyBatis的注解指定方法参数在SQL中的名称
import org.apache.ibatis.annotations.Param;
// 导入List接口表示返回类型为List集合用于存储多个备选答案
import java.util.List;
/**
* <p>
* Mapper
* Mapper
* </p>
* MyBatis-PlusBaseMapperCRUD
*
* @author
* @since 2020-05-25 16:33
*/
public interface PaperQuAnswerMapper extends BaseMapper<PaperQuAnswer> {
public interface PaperQuAnswerMapper extends BaseMapper<PaperQuAnswer> { // 继承自BaseMapper接口提供了所有的基本CRUD操作
/**
*
* @param paperId
* @param quId
* @return
* @param paperId ID
* @param quId ID
* @return IDID
*/
List<PaperQuAnswerExtDTO> list(@Param("paperId") String paperId, @Param("quId") String quId);
List<PaperQuAnswerExtDTO> list(@Param("paperId") String paperId, @Param("quId") String quId); // 根据试卷ID和题目ID查询对应的备选答案列表
}

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

Loading…
Cancel
Save