p8lx96rj2
/
online-exam-system
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

api1 #2

Open
pmiseyvfw wants to merge 2 commits from guxuan_branch into develop
Conversation 0 Commits 2 Files Changed 259
259 changed files with 28305 additions and 0 deletions
Show Stats Download Patch File Download Diff File

BIN
exam-api1.zip
View File

Binary file not shown.

214
exam-api1/pom.xml
Unescape View File

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

70
exam-api1/src/main/java/com/yf/exam/ExamApplication.java
Unescape View File

@ -0,0 +1,70 @@
package com.yf.exam;
import com.yf.exam.core.api.utils.JsonConverter;
import lombok.extern.log4j.Log4j2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.Environment;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;
/**
* 云帆在线考试系统
* 系统主启动类，负责Spring Boot应用的初始化和配置
* @author bool
* @email 18365918@qq.com
* @date 2020-03-04 19:41
*/
@Log4j2
@SpringBootApplication
public class ExamApplication implements WebMvcConfigurer {
/**
* 应用主入口方法
* 启动Spring Boot应用并打印访问信息
* @param args 命令行参数
* @throws UnknownHostException 当无法获取本地主机地址时抛出
*/
public static void main(String[] args) throws UnknownHostException {
// 启动Spring Boot应用
ConfigurableApplicationContext application = SpringApplication.run(ExamApplication.class, args);
// 获取环境配置信息
Environment env = application.getEnvironment();
// 获取本机IP地址
String ip = InetAddress.getLocalHost().getHostAddress();
// 获取服务器端口
String port = env.getProperty("server.port");
// 获取应用上下文路径
String path = env.getProperty("server.servlet.context-path");
// 未配置上下文路径时默认设为空白
if(path == null){
path = "";
}
// 打印系统启动成功信息和访问地址
log.info("\n----------------------------------------------------------\n\t" +
"云帆考试系统启动成功，访问路径如下:\n\t" +
"本地路径: \t\thttp://localhost:" + port + path + "/\n\t" +
"网络地址: \thttp://" + ip + ":" + port + path + "/\n\t" +
"API文档: \t\thttp://" + ip + ":" + port + path + "/doc.html\n" +
"----------------------------------------------------------");
}
/**
* 扩展HTTP消息转换器
* 配置FastJson作为JSON序列化工具，并设置最高优先级
* @param converters HTTP消息转换器列表
*/
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
// 保留原有converter,把新增fastConverter插入集合头,保证优先级
converters.add(0, JsonConverter.fastConverter());
}
}

15
exam-api1/src/main/java/com/yf/exam/ability/Constant.java
Unescape View File

@ -0,0 +1,15 @@
package com.yf.exam.ability;
/**
* 通用常量
* @author bool
*/
public class Constant {
/**
* 文件上传路径
*/
public static final String FILE_PREFIX = "/upload/file/";
}

13
exam-api1/src/main/java/com/yf/exam/ability/job/enums/JobGroup.java
Unescape View File

@ -0,0 +1,13 @@
package com.yf.exam.ability.job.enums;
/**
* 任务分组
* @author van
*/
public interface JobGroup {
/**
* 系统任务
*/
String SYSTEM = "system";
}

14
exam-api1/src/main/java/com/yf/exam/ability/job/enums/JobPrefix.java
Unescape View File

@ -0,0 +1,14 @@
package com.yf.exam.ability.job.enums;
/**
* 任务前缀
* @author bool
*/
public interface JobPrefix {
/**
* 强制交卷的
*/
String BREAK_EXAM = "break_exam_";
}

53
exam-api1/src/main/java/com/yf/exam/ability/job/service/JobService.java
Unescape View File

@ -0,0 +1,53 @@
package com.yf.exam.ability.job.service;
/**
* 任务业务类，用于动态处理任务信息
* @author bool
* @date 2020/11/29 下午2:17
*/
public interface JobService {
/**
* 任务数据
*/
String TASK_DATA = "taskData";
/**
* 添加定时任务
* @param jobClass
* @param jobName
* @param cron
* @param data
*/
void addCronJob(Class jobClass, String jobName, String cron, String data);
/**
* 添加立即执行的任务
* @param jobClass
* @param jobName
* @param data
*/
void addCronJob(Class jobClass, String jobName, String data);
/**
* 暂停任务
* @param jobName
* @param jobGroup
*/
void pauseJob(String jobName, String jobGroup);
/**
* 恢复任务
* @param triggerName
* @param triggerGroup
*/
void resumeJob(String triggerName, String triggerGroup);
/**
* 删除job
* @param jobName
* @param jobGroup
*/
void deleteJob(String jobName, String jobGroup);
}

123
exam-api1/src/main/java/com/yf/exam/ability/job/service/impl/JobServiceImpl.java
Unescape View File

@ -0,0 +1,123 @@
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;
/**
* @author bool
*/
@Log4j2
@Service
public class JobServiceImpl implements JobService {
/**
* Quartz定时任务核心的功能实现类
*/
private Scheduler scheduler;
/**
* 注入
* @param schedulerFactoryBean
*/
public JobServiceImpl(@Autowired SchedulerFactoryBean schedulerFactoryBean) {
scheduler = schedulerFactoryBean.getScheduler();
}
@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();
}
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;
// 有表达式的按表达式
if(!StringUtils.isEmpty(cron)){
log.info("+++++表达式执行:"+ JSON.toJSONString(jobDetail));
//表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup).withSchedule(scheduleBuilder).build();
}else{
// 无表达式则立即执行
log.info("+++++立即执行:"+ JSON.toJSONString(jobDetail));
trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup).startNow().build();
}
scheduler.scheduleJob(jobDetail, trigger);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void addCronJob(Class jobClass, String jobName, String data) {
// 立即执行任务
this.addCronJob(jobClass, jobName, null, data);
}
@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();
}
}
@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();
}
}
@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();
}
}
}

29
exam-api1/src/main/java/com/yf/exam/ability/shiro/CNFilterFactoryBean.java
Unescape View File

@ -0,0 +1,29 @@
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 javax.servlet.Filter;
import java.util.Map;
/**
* 自定义过滤器，用于处理中文URL问题
* 如：下载文件中包含中文会返回400错误，https://youdomain.com/upload/file/云帆考试系统用户手册.pdf
* @author van
*/
public class CNFilterFactoryBean extends ShiroFilterFactoryBean {
@Override
protected FilterChainManager createFilterChainManager() {
FilterChainManager manager = super.createFilterChainManager();
// URL携带中文400，servletPath中文校验bug
Map<String, Filter> filterMap = manager.getFilters();
Filter invalidRequestFilter = filterMap.get(DefaultFilter.invalidRequest.name());
if (invalidRequestFilter instanceof InvalidRequestFilter) {
((InvalidRequestFilter) invalidRequestFilter).setBlockNonAscii(false);
}
return manager;
}
}

131
exam-api1/src/main/java/com/yf/exam/ability/shiro/ShiroRealm.java
Unescape View File

@ -0,0 +1,131 @@
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;
/**
* 用户登录鉴权和获取用户授权
* @author bool
*/
@Component
@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);
}
}

53
exam-api1/src/main/java/com/yf/exam/ability/shiro/aop/JwtFilter.java
Unescape View File

@ -0,0 +1,53 @@
package com.yf.exam.ability.shiro.aop;
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;
/**
* 鉴权登录拦截器
* @author bool
*/
@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;
}
}
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String token = httpServletRequest.getHeader(Constant.TOKEN);
JwtToken jwtToken = new JwtToken(token);
// 提交给realm进行登入，如果错误他会抛出异常并被捕获
getSubject(request, response).login(jwtToken);
// 如果没有抛出异常则代表登入成功，返回true
return true;
}
}

33
exam-api1/src/main/java/com/yf/exam/ability/shiro/jwt/JwtToken.java
Unescape View File

@ -0,0 +1,33 @@
package com.yf.exam.ability.shiro.jwt;
import lombok.Data;
import org.apache.shiro.authc.AuthenticationToken;
/**
* @author bool
*/
@Data
public class JwtToken implements AuthenticationToken {
private static final long serialVersionUID = 1L;
/**
* JWT的字符token
*/
private String token;
public JwtToken(String token) {
this.token = token;
}
@Override
public Object getPrincipal() {
return token;
}
@Override
public Object getCredentials() {
return token;
}
}

99
exam-api1/src/main/java/com/yf/exam/ability/shiro/jwt/JwtUtils.java
Unescape View File

@ -0,0 +1,99 @@
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 java.util.Calendar;
import java.util.Date;
/**
* JWT工具类
* @author bool
*/
public class JwtUtils {
/**
* 有效期24小时
*/
private static final long EXPIRE_TIME = 24 * 60 * 60 * 1000;
/**
* 校验是否正确
* @param token
* @param username
* @return
*/
public static boolean verify(String token, String username) {
try {
// 根据密码生成JWT效验器
Algorithm algorithm = Algorithm.HMAC256(encryptSecret(username));
JWTVerifier verifier = JWT.require(algorithm)
.withClaim("username", username)
.build();
// 效验TOKEN
verifier.verify(token);
return true;
} catch (Exception exception) {
return false;
}
}
/**
* 从Token中解密获得用户名
* @param token
* @return
*/
public static String getUsername(String token) {
try {
DecodedJWT jwt = JWT.decode(token);
return jwt.getClaim("username").asString();
} catch (JWTDecodeException e) {
return null;
}
}
/**
* 生成JWT Token字符串
* @param username
* @return
*/
public static String sign(String 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);
}
/**
* 根据用户名和秘钥，生成一个新的秘钥，用于JWT加强一些安全性
* @param userName
* @return
*/
private static String encryptSecret(String userName){
// 一个简单的登录规则，用户名+当前月份为加密串，意思每个月会变，要重新登录
// 可自行修改此规则
Calendar cl = Calendar.getInstance();
cl.setTimeInMillis(System.currentTimeMillis());
StringBuffer sb = new StringBuffer(userName)
.append("&")
.append(cl.get(Calendar.MONTH));
// 获取MD5
String secret = Md5Util.md5(sb.toString());
return Md5Util.md5(userName + "&" + secret);
}
}

32
exam-api1/src/main/java/com/yf/exam/ability/upload/config/UploadConfig.java
Unescape View File

@ -0,0 +1,32 @@
package com.yf.exam.ability.upload.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
/**
* 文件上传配置
* @author van
*/
@Data
@Configuration
@ConfigurationProperties(prefix = "conf.upload")
public class UploadConfig {
/**
* 访问路径
*/
private String url;
/**
* 物理目录
*/
private String dir;
/**
* 允许的后缀
*/
private String [] allowExtensions;
}

57
exam-api1/src/main/java/com/yf/exam/ability/upload/controller/UploadController.java
Unescape View File

@ -0,0 +1,57 @@
package com.yf.exam.ability.upload.controller;
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;
/**
* 本地文件上传下载请求类
* @author bool
*/
@Log4j2
@Api(tags = {"文件上传"})
@RestController
public class UploadController extends BaseController {
@Autowired
private UploadService uploadService;
/**
* 文件上传
* @param reqDTO
* @return
*/
@PostMapping("/common/api/file/upload")
@ApiOperation(value = "文件上传", notes = "此接口较为特殊，参数都通过表单方式提交，而非JSON")
public ApiRest<UploadRespDTO> upload(@ModelAttribute UploadReqDTO reqDTO) {
// 上传并返回URL
UploadRespDTO respDTO = uploadService.upload(reqDTO);
return super.success(respDTO);
}
/**
* 独立文件下载
* @param request
* @param response
*/
@GetMapping(Constant.FILE_PREFIX+"**")
@ApiOperation(value = "文件下载", notes = "文件下载")
public void download(HttpServletRequest request, HttpServletResponse response) {
uploadService.download(request, response);
}
}

22
exam-api1/src/main/java/com/yf/exam/ability/upload/dto/UploadReqDTO.java
Unescape View File

@ -0,0 +1,22 @@
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;
/**
* 文件上传请求类
* @author
* @date 2019-12-26 17:54
*/
@Data
@ApiModel(value="文件上传参数", description="文件上传参数")
public class UploadReqDTO extends BaseDTO {
@ApiModelProperty(value = "上传文件内容", required=true)
private MultipartFile file;
}

23
exam-api1/src/main/java/com/yf/exam/ability/upload/dto/UploadRespDTO.java
Unescape View File

@ -0,0 +1,23 @@
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;
/**
* 上传文件结果
* @author bool
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value="文件上传响应", description="文件上传响应")
public class UploadRespDTO extends BaseDTO {
@ApiModelProperty(value = "上传后的完整的URL地址", required=true)
private String url;
}

30
exam-api1/src/main/java/com/yf/exam/ability/upload/service/UploadService.java
Unescape View File

@ -0,0 +1,30 @@
package com.yf.exam.ability.upload.service;
import com.yf.exam.ability.upload.dto.UploadReqDTO;
import com.yf.exam.ability.upload.dto.UploadRespDTO;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 阿里云OSS业务类
* @author bool
* @date 2019-07-12 16:45
*/
public interface UploadService {
/**
* 文件上传
* @param reqDTO
* @return
*/
UploadRespDTO upload(UploadReqDTO reqDTO);
/**
* 下载文件
* @param request
* @param response
*/
void download(HttpServletRequest request, HttpServletResponse response);
}

135
exam-api1/src/main/java/com/yf/exam/ability/upload/service/impl/UploadServiceImpl.java
Unescape View File

@ -0,0 +1,135 @@
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;
/**
* 文件上传业务类
* @author bool
* @date 2019-07-30 21:02
*/
@Log4j2
@Service
public class UploadServiceImpl implements UploadService {
@Autowired
private UploadConfig conf;
@Override
public UploadRespDTO upload(UploadReqDTO reqDTO) {
// 文件内容
MultipartFile file = reqDTO.getFile();
// 验证文件后缀
boolean allow = FilenameUtils.isExtension(file.getOriginalFilename(), conf.getAllowExtensions());
if(!allow){
throw new ServiceException("文件类型不允许上传！");
}
// 上传文件夹
String fileDir = conf.getDir();
// 真实物理地址
String fullPath;
try {
// 新文件
String filePath = FileUtils.processPath(file);
// 文件保存地址
fullPath = fileDir + filePath;
// 创建文件夹
FileUtils.checkDir(fullPath);
// 上传文件
FileCopyUtils.copy(file.getInputStream(), new FileOutputStream(fullPath));
return this.generateResult(filePath);
} catch (IOException e) {
e.printStackTrace();
throw new ServiceException("文件上传失败："+e.getMessage());
}
}
@Override
public void download(HttpServletRequest request, HttpServletResponse response) {
// 获取真实的文件路径
String filePath = this.getRealPath(request.getRequestURI());
// 处理中文问题
try {
filePath = URLDecoder.decode(filePath, "utf-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
System.out.println("++++完整路径为："+filePath);
try {
FileUtils.writeRange(request, response, filePath);
} catch (IOException e) {
response.setStatus(404);
log.error("预览文件失败" + e.getMessage());
}
}
/**
* 构造返回
* @param fileName
* @return
*/
private UploadRespDTO generateResult(String fileName) {
//获取加速域名
String domain = conf.getUrl();
// 返回结果
return new UploadRespDTO(domain + fileName);
}
/**
* 获取真实物理文件地址
* @param uri
* @return
*/
public String getRealPath(String uri){
String regx = Constant.FILE_PREFIX+"(.*)";
// 查找全部变量
Pattern pattern = Pattern.compile(regx);
Matcher m = pattern.matcher(uri);
if (m.find()) {
String str = m.group(1);
return conf.getDir() + str;
}
return null;
}
}

172
exam-api1/src/main/java/com/yf/exam/ability/upload/utils/FileUtils.java
Unescape View File

@ -0,0 +1,172 @@
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 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;
/**
* 文件工具类
* @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();
}
}
}

47
exam-api1/src/main/java/com/yf/exam/ability/upload/utils/MediaUtils.java
Unescape View File

@ -0,0 +1,47 @@
package com.yf.exam.ability.upload.utils;
import org.apache.commons.lang3.StringUtils;
import java.util.HashMap;
import java.util.Map;
/**
* 媒体工具，判断媒体类型
* @author bool
* @date 2019-11-14 16:21
*/
public class MediaUtils {
public static final Map<String, String> MEDIA_MAP = new HashMap(){
{
//本来是pdf的
put(".pdf", "application/pdf");
//视频
put(".mp4", "video,video/mp4");
}
};
/**
* 获得文件类型
* @param filePath
* @return
*/
public static String getContentType(String filePath){
if(!StringUtils.isBlank(filePath)
&& filePath.indexOf(".")!=-1) {
// 后缀转换成小写
String suffix = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
if (MEDIA_MAP.containsKey(suffix)) {
return MEDIA_MAP.get(suffix);
}
}
return "application/octet-stream";
}
}

317
exam-api1/src/main/java/com/yf/exam/aspect/DictAspect.java
Unescape View File

@ -0,0 +1,317 @@
package com.yf.exam.aspect;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yf.exam.core.annon.Dict;
import com.yf.exam.core.api.ApiRest;
import com.yf.exam.core.utils.Reflections;
import com.yf.exam.modules.sys.system.service.SysDictService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* 数据字典AOP类，处理数据字典值
*
* @author bool
*/
@Aspect
@Component
@Slf4j
public class DictAspect {
@Autowired
private SysDictService sysDictService;
/**
* 切入Controller执行
* @param pjp
* @return
* @throws Throwable
*/
@Around("execution(public * com.yf.exam..*.*Controller.*(..))")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
return this.translate(pjp);
}
/**
* 进行翻译并返回，调用前必须实现：BaseDictService
*
* @param pjp
* @return
* @throws Throwable
*/
public Object translate(ProceedingJoinPoint pjp) throws Throwable {
// 处理字典
return this.parseAllDictText(pjp.proceed());
}
/**
* 转换全部数据字典
*
* @param result
*/
private Object parseAllDictText(Object result) {
// 非ApiRest类型不处理
if (result instanceof ApiRest) {
parseFullDictText(result);
}
return result;
}
/**
* 转换所有类型的数据字典、包含子列表
*
* @param result
*/
private void parseFullDictText(Object result) {
try {
Object rest = ((ApiRest) result).getData();
// 不处理普通数据类型
if (rest == null || this.isBaseType(rest.getClass())) {
return;
}
// 分页的
if (rest instanceof IPage) {
List<Object> items = new ArrayList<>(16);
for (Object record : ((IPage) rest).getRecords()) {
Object item = this.parseObject(record);
items.add(item);
}
((IPage) rest).setRecords(items);
return;
}
// 数据列表的
if (rest instanceof List) {
List<Object> items = new ArrayList<>();
for (Object record : ((List) rest)) {
Object item = this.parseObject(record);
items.add(item);
}
// 重新回写值
((ApiRest) result).setData(items);
return;
}
// 处理单对象
Object item = this.parseObject(((ApiRest) result).getData());
((ApiRest) result).setData(item);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 处理数据字典值
*
* @param record
* @return
*/
public Object parseObject(Object record) {
if (record == null) {
return null;
}
// 不处理普通数据类型
if (this.isBaseType(record.getClass())) {
return record;
}
// 转换JSON字符
String json = JSON.toJSONString(record);
JSONObject item = JSONObject.parseObject(json);
for (Field field : Reflections.getAllFields(record)) {
// 如果是List类型
if (List.class.isAssignableFrom(field.getType())) {
try {
List list = this.processList(field, item.getObject(field.getName(), List.class));
item.put(field.getName(), list);
continue;
} catch (Exception e) {
e.printStackTrace();
}
continue;
}
// 处理普通字段
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
String textValue = this.translateDictValue(code, text, table, key);
if (StringUtils.isEmpty(textValue)) {
textValue = "";
}
item.put(field.getName() + "_dictText", textValue);
continue;
}
//日期格式转换
if ("java.util.Date".equals(field.getType().getName()) && item.get(field.getName()) != null) {
// 获取注解
JsonFormat ann = field.getAnnotation(JsonFormat.class);
// 格式化方式
SimpleDateFormat fmt;
// 使用注解指定的
if (ann != null && !StringUtils.isEmpty(ann.pattern())) {
fmt = new SimpleDateFormat(ann.pattern());
} else {
// 默认时间样式
fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
item.put(field.getName(), fmt.format(new Date((Long) item.get(field.getName()))));
continue;
}
}
return item;
}
/**
* 获得类型为List的值
*
* @param field
* @return
*/
private List<Object> processList(Field field, List list) {
// 空判断
if (list == null || list.size() == 0) {
return new ArrayList<>();
}
// 获得List属性的真实类
Type genericType = field.getGenericType();
Class<?> actualType = null;
if (genericType instanceof ParameterizedType) {
// 尝试获取数据类型
ParameterizedType pt = (ParameterizedType) genericType;
try {
actualType = (Class) pt.getActualTypeArguments()[0];
}catch (Exception e){
return list;
}
}
// 常规列表无需处理
if (isBaseType(actualType)) {
return list;
}
// 返回列表
List<Object> result = new ArrayList<>(16);
for (int i = 0; i < list.size(); i++) {
// 创建实例-->赋值-->字典处理
Object data = list.get(i);
try {
data = JSON.parseObject(JSON.toJSONString(data), actualType);
}catch (Exception e){
// 转换出错不处理
}
// 处理后的数据
Object pds = this.parseObject(data);
result.add(pds);
}
return result;
}
/**
* 翻译实现
*
* @param code
* @param text
* @param table
* @param key
* @return
*/
private String translateDictValue(String code, String text, String table, String key) {
if (StringUtils.isEmpty(key)) {
return null;
}
try {
// 翻译值
String dictText = null;
if (!StringUtils.isEmpty(table)) {
dictText = sysDictService.findDict(table, text, code, key.trim());
}
if (!StringUtils.isEmpty(dictText)) {
return dictText;
}
} catch (Exception e) {
e.printStackTrace();
}
return "";
}
/**
* 判断是否基本类型
*
* @param clazz
* @return
*/
private boolean isBaseType(Class clazz) {
// 基础数据类型
if (clazz.equals(java.lang.Integer.class) ||
clazz.equals(java.lang.Byte.class) ||
clazz.equals(java.lang.Long.class) ||
clazz.equals(java.lang.Double.class) ||
clazz.equals(java.lang.Float.class) ||
clazz.equals(java.lang.Character.class) ||
clazz.equals(java.lang.Short.class) ||
clazz.equals(java.lang.Boolean.class)) {
return true;
}
// String类型
if (clazz.equals(java.lang.String.class)) {
return true;
}
// 数字
if (clazz.equals(java.lang.Number.class)) {
return true;
}
return false;
}
}

144
exam-api1/src/main/java/com/yf/exam/aspect/mybatis/QueryInterceptor.java
Unescape View File

@ -0,0 +1,144 @@
package com.yf.exam.aspect.mybatis;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.yf.exam.modules.sys.user.dto.response.SysUserLoginDTO;
import lombok.extern.log4j.Log4j2;
import net.sf.jsqlparser.parser.CCJSqlParserManager;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.DefaultReflectorFactory;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.apache.shiro.SecurityUtils;
import java.io.StringReader;
import java.sql.Connection;
import java.util.Properties;
/**
* 查询拦截器，用于拦截处理通用的信息、如用户ID、多租户信息等；
* 特别注意：此处继承了PaginationInterceptor分页，分页必须在拦截数据后执行，否则容易出现分页不准确，分页计数大于实际数量等问题
* @author bool
*/
@Log4j2
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class}),})
public class QueryInterceptor extends PaginationInterceptor implements Interceptor {
/**
* 客户ID
*/
private static final String USER_FILTER = "{{userId}}";
@Override
public Object intercept(Invocation invocation) throws Throwable {
StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
MetaObject metaObject = MetaObject.forObject(statementHandler, SystemMetaObject.DEFAULT_OBJECT_FACTORY, SystemMetaObject.DEFAULT_OBJECT_WRAPPER_FACTORY, new DefaultReflectorFactory());
MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
//sql语句类型
SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
// 只过滤查询的
if (SqlCommandType.SELECT == sqlCommandType) {
// 获得原始SQL
String sql = statementHandler.getBoundSql().getSql();
// 不处理
if(!sql.contains(USER_FILTER)){
return super.intercept(invocation);
}
// 处理SQL语句
String outSql = this.parseSql(sql);
// 设置SQL
metaObject.setValue("delegate.boundSql.sql", outSql);
// 再分页
return super.intercept(invocation);
}
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
}
/**
* 获取当前登录用户
* @return
*/
private SysUserLoginDTO getLoginUser() {
try {
return SecurityUtils.getSubject().getPrincipal() != null ? (SysUserLoginDTO) SecurityUtils.getSubject().getPrincipal() : null;
} catch (Exception e) {
return null;
}
}
/**
* 替换用户ID
* @param sql
* @return
*/
private String processUserId(String sql) {
// 当前用户
SysUserLoginDTO user = this.getLoginUser();
String userId = user.getId();
if(StringUtils.isNotBlank(userId)){
return sql.replace(USER_FILTER, userId);
}
return null;
}
/**
* 处理注入用户信息
* @param src
* @return
*/
private String parseSql(String src) {
CCJSqlParserManager parserManager = new CCJSqlParserManager();
try {
Select select = (Select) parserManager.parse(new StringReader(src));
PlainSelect selectBody = (PlainSelect) select.getSelectBody();
// 过滤客户
String sql = selectBody.toString();
// 过滤用户ID
sql = this.processUserId(sql);
// 获得SQL
return sql;
} catch (Exception e) {
e.printStackTrace();
}
return src;
}
}

80
exam-api1/src/main/java/com/yf/exam/aspect/mybatis/UpdateInterceptor.java
Unescape View File

@ -0,0 +1,80 @@
package com.yf.exam.aspect.mybatis;
import com.baomidou.mybatisplus.extension.handlers.AbstractSqlParserHandler;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import java.lang.reflect.Field;
import java.sql.Timestamp;
import java.util.Objects;
import java.util.Properties;
/**
* 自动给创建时间个更新时间加值
* @author bool
*/
@Intercepts(value = {@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
public class UpdateInterceptor extends AbstractSqlParserHandler implements Interceptor {
/**
* 创建时间
*/
private static final String CREATE_TIME = "createTime";
/**
* 更新时间
*/
private static final String UPDATE_TIME = "updateTime";
@Override
public Object intercept(Invocation invocation) throws Throwable {
MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
// SQL操作命令
SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
// 获取新增或修改的对象参数
Object parameter = invocation.getArgs()[1];
// 获取对象中所有的私有成员变量（对应表字段）
Field[] declaredFields = parameter.getClass().getDeclaredFields();
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)) {
if (SqlCommandType.INSERT.equals(sqlCommandType)) {
field.setAccessible(true);
field.set(parameter, new Timestamp(System.currentTimeMillis()));
}
}
if (Objects.equals(UPDATE_TIME, fieldName)) {
if (SqlCommandType.INSERT.equals(sqlCommandType) || SqlCommandType.UPDATE.equals(sqlCommandType)) {
field.setAccessible(true);
field.set(parameter, new Timestamp(System.currentTimeMillis()));
}
}
}
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
if (target instanceof Executor) {
return Plugin.wrap(target, this);
}
return target;
}
@Override
public void setProperties(Properties properties) {
}
}

99
exam-api1/src/main/java/com/yf/exam/aspect/utils/InjectUtils.java
Unescape View File

@ -0,0 +1,99 @@
package com.yf.exam.aspect.utils;
import com.alibaba.fastjson.JSON;
import com.yf.exam.core.api.ApiError;
import com.yf.exam.core.api.ApiRest;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Field;
/**
* 注入工具类
* @author bool
* @date 2019-07-17 09:32
*/
@Log4j2
@Component
public class InjectUtils {
/**
* 给对象字段赋值
*
* @param object 赋值的对象
* @param value 值
* @param fields 字段
* @throws Exception 异常
*/
public void setValue(Object object, Object value, String... fields) throws Exception {
//设置同类的属性
for (String fieldName : fields) {
//获取当前
Field field = this.getFiled(object.getClass(), fieldName);
if(field == null){
continue;
}
field.setAccessible(true);
field.set(object, value);
}
}
/**
* 获取字段名对应的字段
*
* @param clazz 目标类
* @param fieldName 字段名
*/
private Field getFiled(Class clazz, String fieldName) {
System.out.println("注入的类："+clazz.toString());
//是否具有包含关系
try {
//获取当前类的属性
return clazz.getDeclaredField(fieldName);
}catch (Exception e){
log.error(clazz.toString() + ": not exist field, try superclass " + fieldName);
//如果为空且存在父类，则往上找
if(clazz.getSuperclass()!=null){
return this.getFiled(clazz.getSuperclass(), fieldName);
}
return null;
}
}
/**
* 打印结果返回
* @param response
* @throws IOException
*/
public static void restError(HttpServletResponse response) {
try {
//固定错误
ApiRest apiRest = new ApiRest(ApiError.ERROR_10010002);
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json");
response.getWriter().write(JSON.toJSONString(apiRest));
response.getWriter().close();
}catch (IOException e){
}
}
}

35
exam-api1/src/main/java/com/yf/exam/config/CorsConfig.java
Unescape View File

@ -0,0 +1,35 @@
package com.yf.exam.config;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
/**
* 网关全局设置，允许跨域
* @author bool
* @date 2019-08-13 17:28
*/
@Configuration
public class CorsConfig {
@Bean
public FilterRegistrationBean corsFilter() {
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
CorsConfiguration config = new CorsConfiguration();
config.setAllowCredentials(true);
config.addAllowedOrigin(CorsConfiguration.ALL);
config.addAllowedHeader(CorsConfiguration.ALL);
config.addAllowedMethod(CorsConfiguration.ALL);
source.registerCorsConfiguration("/**", config);
FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(source));
bean.setOrder(Ordered.HIGHEST_PRECEDENCE);
return bean;
}
}

28
exam-api1/src/main/java/com/yf/exam/config/MultipartConfig.java
Unescape View File

@ -0,0 +1,28 @@
package com.yf.exam.config;
import org.springframework.boot.web.servlet.MultipartConfigFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.unit.DataSize;
import javax.servlet.MultipartConfigElement;
/**
* 文件上传配置
* @author bool
* @date 2019-07-29 16:23
*/
@Configuration
public class MultipartConfig {
@Bean
public MultipartConfigElement multipartConfigElement() {
MultipartConfigFactory factory = new MultipartConfigFactory();
// 单个数据大小
factory.setMaxFileSize(DataSize.ofMegabytes(5000L));
/// 总上传数据大小
factory.setMaxRequestSize(DataSize.ofMegabytes(5000L));
return factory.createMultipartConfig();
}
}

37
exam-api1/src/main/java/com/yf/exam/config/MybatisConfig.java
Unescape View File

@ -0,0 +1,37 @@
package com.yf.exam.config;
import com.yf.exam.aspect.mybatis.QueryInterceptor;
import com.yf.exam.aspect.mybatis.UpdateInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* Mybatis过滤器配置
* 注意：必须按顺序进行配置，否则容易出现业务异常
* @author bool
*/
@Configuration
@MapperScan("com.yf.exam.modules.**.mapper")
public class MybatisConfig {
/**
* 数据查询过滤器
*/
@Bean
public QueryInterceptor queryInterceptor() {
QueryInterceptor query = new QueryInterceptor();
query.setLimit(-1L);
return query;
}
/**
* 插入数据过滤器
*/
@Bean
public UpdateInterceptor updateInterceptor() {
return new UpdateInterceptor();
}
}

77
exam-api1/src/main/java/com/yf/exam/config/ScheduledConfig.java
Unescape View File

@ -0,0 +1,77 @@
package com.yf.exam.config;
import lombok.extern.log4j.Log4j2;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 任务调度配置
* @author bool
*/
@Log4j2
@Configuration
@EnableScheduling
@EnableAsync
public class ScheduledConfig implements SchedulingConfigurer, AsyncConfigurer {
/**
* 定时任务使用的线程池
* @return
*/
@Bean(destroyMethod = "shutdown", name = "taskScheduler")
public ThreadPoolTaskScheduler taskScheduler(){
ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
scheduler.setPoolSize(10);
scheduler.setThreadNamePrefix("task-");
scheduler.setAwaitTerminationSeconds(600);
scheduler.setWaitForTasksToCompleteOnShutdown(true);
return scheduler;
}
/**
* 异步任务执行线程池
* @return
*/
@Bean(name = "asyncExecutor")
public ThreadPoolTaskExecutor asyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setQueueCapacity(1000);
executor.setKeepAliveSeconds(600);
executor.setMaxPoolSize(20);
executor.setThreadNamePrefix("taskExecutor-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
return executor;
}
@Override
public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
ThreadPoolTaskScheduler taskScheduler = taskScheduler();
scheduledTaskRegistrar.setTaskScheduler(taskScheduler);
}
@Override
public Executor getAsyncExecutor() {
return asyncExecutor();
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return (throwable, method, objects) -> {
log.error("异步任务执行出现异常, message {}, emthod {}, params {}", throwable, method, objects);
};
}
}

127
exam-api1/src/main/java/com/yf/exam/config/ShiroConfig.java
Unescape View File

@ -0,0 +1,127 @@
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;
/**
* Shiro配置类
* @author bool
*/
@Slf4j
@Configuration
public class ShiroConfig {
/**
* Filter Chain定义说明
*
* 1、一个URL可以配置多个Filter，使用逗号分隔
* 2、当设置多个过滤器时，全部验证通过，才视为通过
* 3、部分过滤器可指定参数，如perms，roles
*/
@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;
}
}

65
exam-api1/src/main/java/com/yf/exam/config/SwaggerConfig.java
Unescape View File

@ -0,0 +1,65 @@
package com.yf.exam.config;
import com.github.xiaoymin.swaggerbootstrapui.annotations.EnableSwaggerBootstrapUI;
import io.swagger.annotations.ApiOperation;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.ApiKey;
import springfox.documentation.service.Contact;
import springfox.documentation.service.SecurityScheme;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
import java.util.Collections;
/**
* Swagger配置
* @author bool
* @date 2020/8/19 20:53
*/
@Configuration
@EnableSwagger2
@EnableSwaggerBootstrapUI
@ConfigurationProperties(prefix = "swagger")
public class SwaggerConfig {
@Bean
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()));
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder().title("考试系统接口")
.description("考试系统接口")
.contact(new Contact("Van", "https://exam.yfhl.net", "18365918@qq.com"))
.version("1.0.0")
.build();
}
/**
* 授权头部
* @return
*/
@Bean
SecurityScheme securityScheme() {
return new ApiKey("token", "token", "header");
}
}

33
exam-api1/src/main/java/com/yf/exam/core/annon/Dict.java
Unescape View File

@ -0,0 +1,33 @@
package com.yf.exam.core.annon;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 数据字典注解
* 用于标记字段与数据字典的映射关系，实现字典值的转换和显示
* @author bool
*/
// 注解只能用于字段上
@Target(ElementType.FIELD)
//注解在运行时保留，可以通过反射机制读取
@Retention(RetentionPolicy.RUNTIME)
public @interface Dict {
/**
* 字典类型编码
* 指定数据字典的类型编码，用于从字典表中查询对应的字典项
*/
String dicCode();
/**
* 字典显示文本
* 字典值对应的显示文本，如果不指定则根据dicCode自动查询
*/
String dicText() default "";
/**
* 字典表名
* 指定字典数据所在的表名，如果不指定则使用默认的字典表
*/
String dictTable() default "";
}

81
exam-api1/src/main/java/com/yf/exam/core/api/ApiError.java
Unescape View File

@ -0,0 +1,81 @@
package com.yf.exam.core.api;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* 全局错误码定义，用于定义接口的响应数据，
* 枚举名称全部使用代码命名，在系统中调用，免去取名难的问题。
* @author bool
* @date 2019-06-14 21:15
*/
// 使用Lombok注解生成无参构造器和全参构造器
@NoArgsConstructor
@AllArgsConstructor
public enum ApiError implements Serializable {
/**
* 通用错误，接口参数不全
*/
ERROR_10010001("参数不全或类型错误！"),
ERROR_10010002("您还未登录，请先登录！"),
ERROR_10010003("数据不存在！"),
ERROR_10010012("图形验证码错误！"),
ERROR_10010013("短信验证码错误！"),
ERROR_10010014("不允许重复评论！"),
/**
* 考试相关错误
*/
ERROR_20010001("试题被删除，无法继续考试！"),
ERROR_20010002("您有正在进行的考试！"),
/**
* 账户相关错误
*/
ERROR_90010001("账号不存在，请确认！"),
ERROR_90010002("账号或密码错误！"),
ERROR_90010003("至少要包含一个角色！"),
ERROR_90010004("管理员账号无法修改！"),
ERROR_90010005("账号被禁用，请联系管理员！"),
ERROR_90010006("活动用户不足，无法开启竞拍！"),
ERROR_90010007("旧密码不正确，请确认！"),
/**
* 数据相关错误
*/
ERROR_60000001("数据不存在！");
/**
* 错误信息
* 存储每个错误码对应的详细错误描述
*/
public String msg;
/**
* 生成Markdown格式文档，用于更新文档用的
* 遍历所有错误码枚举，输出为Markdown格式的键值对
* @param args 命令行参数
*/
public static void main(String[] args) {
// 遍历枚举中的所有错误码常量
for (ApiError e : ApiError.values()) {
// 输出格式：'错误码数字':'错误信息'
// 移除ERROR_前缀，只保留数字部分
System.out.println("'"+e.name().replace("ERROR_", "")+"':'"+e.msg+"',");
}
}
/**
* 获取错误码
* 将枚举名称中的ERROR_前缀移除，返回纯数字的错误码
* @return 错误码数字，如10010001、20010001等
*/
public Integer getCode(){
// 移除ERROR_前缀并将字符串转换为整数
return Integer.parseInt(this.name().replace("ERROR_", ""));
}
}

73
exam-api1/src/main/java/com/yf/exam/core/api/ApiRest.java
Unescape View File

@ -0,0 +1,73 @@
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;
/**
* 数据结果返回的封装
* 统一的API响应格式封装类，用于所有接口的返回结果
* @author bool
* @date 2018/11/20 09:48
*/
// 使用Lombok注解自动生成getter、setter、toString等方法
@Data
//使用Lombok注解生成无参数构造器
@NoArgsConstructor
//Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="接口响应", description="接口响应")
public class ApiRest<T>{
/**
* 响应消息
* 用于返回操作的成功或失败描述信息
*/
@ApiModelProperty(value = "响应消息")
private String msg;
/**
* 响应代码
* 0为成功，1为失败，其他为具体错误码
*/
@ApiModelProperty(value = "响应代码,0为成功,1为失败", required = true)
private Integer code;
/**
* 请求或响应body
* 泛型数据，用于返回具体的业务数据
*/
@ApiModelProperty(value = "响应内容")
protected T data;
/**
* 是否成功
* 根据响应代码判断操作是否成功
* @return true表示成功，false表示失败
*/
public boolean isSuccess(){
return code.equals(0);
}
/**
* 构造函数
* 通过ServiceException异常对象构造响应
* @param error ServiceException异常实例
*/
public ApiRest(ServiceException error){
this.code = error.getCode();
this.msg = error.getMsg();
}
/**
* 构造函数
* 通过ApiError枚举构造响应
* @param error ApiError枚举实例
*/
public ApiRest(ApiError error){
this.code = error.getCode();
this.msg = error.msg;
}
}

166
exam-api1/src/main/java/com/yf/exam/core/api/controller/BaseController.java
Unescape View File

@ -0,0 +1,166 @@
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;
/**
* 基础控制器
* 提供统一的API响应封装方法，包含成功和失败的多种构造方式
* @author Dav
*/
public class BaseController {
/**
* 成功默认消息
*/
private static final Integer CODE_SUCCESS = 0;
private static final String MSG_SUCCESS = "操作成功！";
/**
* 失败默认消息
*/
private static final Integer CODE_FAILURE = 1;
private static final String MSG_FAILURE = "请求失败！";
/**
* 完成消息构造
* 通用的响应消息构造方法，用于创建ApiRest对象
* @param code 响应状态码
* @param message 响应消息
* @param data 响应数据
* @param <T> 数据类型泛型
* @return 封装好的ApiRest响应对象
*/
protected <T> ApiRest<T> message(Integer code, String message, T data){
ApiRest<T> response = new ApiRest<>();
response.setCode(code);
response.setMsg(message);
if(data!=null) {
response.setData(data);
}
return response;
}
/**
* 请求成功空数据
* 返回成功的响应，不带任何数据
* @param <T> 数据类型泛型
* @return 成功的ApiRest响应对象
*/
protected <T> ApiRest<T> success(){
return message(0, "请求成功！", null);
}
/**
* 请求成功，通用代码
* 返回成功的响应，包含自定义消息和数据
* @param message 自定义成功消息
* @param data 响应数据
* @param <T> 数据类型泛型
* @return 成功的ApiRest响应对象
*/
protected <T> ApiRest<T> success(String message, T data){
return message(CODE_SUCCESS, message, data);
}
/**
* 请求成功，仅内容
* 返回成功的响应，使用默认消息和自定义数据
* @param data 响应数据
* @param <T> 数据类型泛型
* @return 成功的ApiRest响应对象
*/
protected <T> ApiRest<T> success(T data){
return message(CODE_SUCCESS, MSG_SUCCESS, data);
}
/**
* 请求失败，完整构造
* 返回失败的响应，包含自定义状态码、消息和数据
* @param code 自定义失败状态码
* @param message 自定义失败消息
* @param data 响应数据
* @param <T> 数据类型泛型
* @return 失败的ApiRest响应对象
*/
protected <T> ApiRest<T> failure(Integer code, String message, T data){
return message(code, message, data);
}
/**
* 请求失败，消息和内容
* 返回失败的响应，包含自定义消息和数据，使用默认失败状态码
* @param message 自定义失败消息
* @param data 响应数据
* @param <T> 数据类型泛型
* @return 失败的ApiRest响应对象
*/
protected <T> ApiRest<T> failure(String message, T data){
return message(CODE_FAILURE, message, data);
}
/**
* 请求失败，消息
* 返回失败的响应，仅包含自定义消息，使用默认失败状态码
* @param message 自定义失败消息
* @param <T> 数据类型泛型
* @return 失败的ApiRest响应对象
*/
protected <T> ApiRest<T> failure(String message){
return message(CODE_FAILURE, message, null);
}
/**
* 请求失败，仅内容
* 返回失败的响应，包含自定义数据，使用默认失败状态码和消息
* @param data 响应数据
* @param <T> 数据类型泛型
* @return 失败的ApiRest响应对象
*/
protected <T> ApiRest<T> failure(T data){
return message(CODE_FAILURE, MSG_FAILURE, data);
}
/**
* 请求失败，仅内容
* 返回失败的响应，使用默认失败状态码和消息，不带数据
* @param <T> 数据类型泛型
* @return 失败的ApiRest响应对象
*/
protected <T> ApiRest<T> failure(){
return message(CODE_FAILURE, MSG_FAILURE, null);
}
/**
* 请求失败，使用预定义错误码
* 返回失败的响应，使用ApiError枚举中定义的错误码和消息
* @param error ApiError枚举实例
* @param data 响应数据
* @param <T> 数据类型泛型
* @return 失败的ApiRest响应对象
*/
protected <T> ApiRest<T> failure(ApiError error, T data){
return message(error.getCode(), error.msg, data);
}
/**
* 请求失败，使用ServiceException异常
* 返回失败的响应，从ServiceException中提取错误码和消息
* @param ex ServiceException异常实例
* @param <T> 数据类型泛型
* @return 失败的ApiRest响应对象
*/
protected <T> ApiRest<T> failure(ServiceException ex){
ApiRest<T> apiRest = message(ex.getCode(), ex.getMsg(), null);
return apiRest;
}
}

21
exam-api1/src/main/java/com/yf/exam/core/api/dto/BaseDTO.java
Unescape View File

@ -0,0 +1,21 @@
package com.yf.exam.core.api.dto;
import lombok.Data;
import java.io.Serializable;
/**
* 请求和响应的基础类，用于处理序列化
* 所有DTO类的基类，提供序列化支持
* @author dav
* @date 2019/3/16 15:56
*/
// 使用Lombok注解自动生成getter、setter、toString、equals、hashCode等方法
@Data
public class BaseDTO implements Serializable {
/**
* 实现Serializable接口，支持对象序列化
* 序列化版本号由JVM自动生成
* 所有DTO类都应继承此类，确保网络传输和持久化的兼容性
*/
}

35
exam-api1/src/main/java/com/yf/exam/core/api/dto/BaseIdReqDTO.java
Unescape View File

@ -0,0 +1,35 @@
package com.yf.exam.core.api.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* <p>
* 主键通用请求类，用于根据ID查询
* </p>
*
* @author 聪明笨狗
* @since 2019-04-20 12:15
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
@ApiModel(value="主键通用请求类", description="主键通用请求类")
public class BaseIdReqDTO extends BaseDTO {
/**
* 主键ID
* Swagger文档中标记为必填字段
*/
@ApiModelProperty(value = "主键ID", required=true)
private String id;
/**
* 用户ID
* 使用JsonIgnore注解，在JSON序列化时忽略此字段
* 避免将用户ID暴露给前端
*/
@JsonIgnore
private String userId;
}

35
exam-api1/src/main/java/com/yf/exam/core/api/dto/BaseIdRespDTO.java
Unescape View File

@ -0,0 +1,35 @@
package com.yf.exam.core.api.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* <p>
* 主键通用响应类，用于添加后返回内容
* 通常在新增操作完成后返回生成的主键ID
* </p>
*
* @author 聪明笨狗
* @since 2019-04-20 12:15
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
//Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="主键通用响应类", description="主键通用响应类")
//Lombok注解，生成全参数构造器
@AllArgsConstructor
//Lombok注解，生成无参数构造器
@NoArgsConstructor
public class BaseIdRespDTO extends BaseDTO {
/**
* 主键ID
* 用于返回新增或操作成功后生成的主键标识
* Swagger文档中标记为必填字段
*/
@ApiModelProperty(value = "主键ID", required=true)
private String id;
}

36
exam-api1/src/main/java/com/yf/exam/core/api/dto/BaseIdsReqDTO.java
Unescape View File

@ -0,0 +1,36 @@
package com.yf.exam.core.api.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* 通用ID列表类操作，用于批量删除、修改状态等
* 支持批量操作多个ID的场景
* @author bool
* @date 2019-08-01 19:07
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
//Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="删除参数", description="删除参数")
public class BaseIdsReqDTO extends BaseDTO {
/**
* 用户ID
* 使用JsonIgnore注解，在JSON序列化时忽略此字段
* 避免将用户ID暴露给前端，通常在后端通过其他方式设置
*/
@JsonIgnore
private String userId;
/**
* ID列表
* 用于存储要操作的多个ID，支持批量处理
* Swagger文档中标记为必填字段
*/
@ApiModelProperty(value = "要删除的ID列表", required = true)
private List<String> ids;
}

44
exam-api1/src/main/java/com/yf/exam/core/api/dto/BaseStateReqDTO.java
Unescape View File

@ -0,0 +1,44 @@
package com.yf.exam.core.api.dto;
import com.yf.exam.core.api.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* <p>
* 通用状态请求类，用于修改状态什么的
* </p>
*
* @author 聪明笨狗
* @since 2019-04-20 12:15
*/
@Data
//Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="通用状态请求类", description="通用状态请求类")
//Lombok注解，生成全参数构造器
@AllArgsConstructor
//Lombok注解，生成无参数构造器
@NoArgsConstructor
public class BaseStateReqDTO extends BaseDTO {
/**
* 要修改状态的ID列表
* 支持批量操作多个对象
* Swagger文档中标记为必填字段
*/
@ApiModelProperty(value = "要修改对象的ID列表", required=true)
private List<String> ids;
/**
* 通用状态值
* 0为正常，1为禁用
* 可根据业务需求扩展其他状态值
* Swagger文档中标记为必填字段
*/
@ApiModelProperty(value = "通用状态，0为正常，1为禁用", required=true)
private Integer state;
}

69
exam-api1/src/main/java/com/yf/exam/core/api/dto/PagingReqDTO.java
Unescape View File

@ -0,0 +1,69 @@
package com.yf.exam.core.api.dto;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* 分页查询类
* 通用分页查询参数封装，支持带查询条件的分布查询
* @param <T> 查询参数类型泛型
* @author bool
*/
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="分页参数", description="分页参数")
//使用Lombok注解自动生成getter、setter等方法
@Data
public class PagingReqDTO<T> {
/**
* 当前页码
* 从1开始计数
*/
@ApiModelProperty(value = "当前页码", required = true, example = "1")
private Integer current;
/**
* 每页数量
* 每页显示的记录数
*/
@ApiModelProperty(value = "每页数量", required = true, example = "10")
private Integer size;
/**
* 查询参数
* 泛型参数，用于封装具体的查询条件
*/
@ApiModelProperty(value = "查询参数")
private T params;
/**
* 排序字符
* 用于指定排序字段和排序方式，如："create_time desc"
*/
@ApiModelProperty(value = "排序字符")
private String orderBy;
/**
* 当前用户的ID
* 使用JsonIgnore注解，在JSON序列化时忽略此字段
* 通常在后端通过安全上下文自动设置
*/
@JsonIgnore
@ApiModelProperty(value = "当前用户的ID")
private String userId;
/**
* 转换成MyBatis的简单分页对象
* 将当前分页参数转换为MyBatis-Plus的Page对象
* @return MyBatis-Plus的Page分页对象
*/
public Page toPage(){
Page page = new Page();
// 设置当前页码
page.setCurrent(this.current);
// 设置每页数量
page.setSize(this.size);
return page;
}
}

36
exam-api1/src/main/java/com/yf/exam/core/api/dto/PagingRespDTO.java
Unescape View File

@ -0,0 +1,36 @@
package com.yf.exam.core.api.dto;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
* 分页响应类
* 扩展MyBatis-Plus的Page类，自定义分页计算逻辑
* @author bool
* @date 2019-07-20 15:17
* @param <T> 数据类型泛型
*/
public class PagingRespDTO<T> extends Page<T> {
/**
* 获取页面总数量
* 重写父类的分页计算方法，确保总页数计算准确
* 处理总记录数除以每页大小的余数情况
* @return 总页数
*/
@Override
public long getPages() {
// 如果每页大小为0，则总页数为0
if (this.getSize() == 0L) {
return 0L;
} else {
// 计算基础页数：总记录数 / 每页大小
long pages = this.getTotal() / this.getSize();
// 如果有余数，页数加1
if (this.getTotal() % this.getSize() != 0L) {
++pages;
}
return pages;
}
}
}

60
exam-api1/src/main/java/com/yf/exam/core/api/utils/JsonConverter.java
Unescape View File

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

22
exam-api1/src/main/java/com/yf/exam/core/enums/CommonState.java
Unescape View File

@ -0,0 +1,22 @@
package com.yf.exam.core.enums;
/**
* 通用的状态枚举信息
* 定义系统中通用的状态常量，用于统一状态管理
* @author bool
* @date 2019-09-17 17:57
*/
public interface CommonState {
/**
* 普通状态，正常的
* 表示对象处于正常可用状态，如：启用、上架、正常等
*/
Integer NORMAL = 0;
/**
* 非正常状态，禁用，下架等
* 表示对象处于不可用状态，如：禁用、下架、删除等
*/
Integer ABNORMAL = 1;
}

21
exam-api1/src/main/java/com/yf/exam/core/enums/OpenType.java
Unescape View File

@ -0,0 +1,21 @@
package com.yf.exam.core.enums;
/**
* 开放方式
* 定义系统中资源或功能的开放范围类型
* @author bool
*/
public interface OpenType {
/**
* 完全开放
* 表示资源或功能对所有用户开放，无权限限制
*/
Integer OPEN = 1;
/**
* 部门开放
* 表示资源或功能仅对特定部门或组织内的用户开放
*/
Integer DEPT_OPEN = 2;
}

63
exam-api1/src/main/java/com/yf/exam/core/exception/ServiceException.java
Unescape View File

@ -0,0 +1,63 @@
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;
/**
* 服务异常类
* 自定义业务异常，用于统一处理业务逻辑中的异常情况
*/
// 使用Lombok注解自动生成getter、setter、toString等方法
@Data
// 使用Lombok注解生成全参数构造器
@AllArgsConstructor
// 使用Lombok注解生成无参数构造器
@NoArgsConstructor
public class ServiceException extends RuntimeException{
/**
* 错误码
* 用于标识具体的错误类型，便于前端处理
*/
private Integer code;
/**
* 错误消息
* 错误的详细描述信息，用于展示给用户或日志记录
*/
private String msg;
/**
* 从结果初始化
* 通过ApiRest响应对象构造异常
* @param apiRest ApiRest响应对象
*/
public ServiceException(ApiRest apiRest){
this.code = apiRest.getCode();
this.msg = apiRest.getMsg();
}
/**
* 从枚举中获取参数
* 通过ApiError枚举构造异常
* @param apiError ApiError枚举实例
*/
public ServiceException(ApiError apiError){
this.code = apiError.getCode();
this.msg = apiError.msg;
}
/**
* 异常构造
* 通过错误消息构造异常，默认错误码为1
* @param msg 错误消息
*/
public ServiceException(String msg){
this.code = 1;
this.msg = msg;
}
}

55
exam-api1/src/main/java/com/yf/exam/core/exception/ServiceExceptionHandler.java
Unescape View File

@ -0,0 +1,55 @@
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.*;
/**
* 统一异常处理类
* 全局异常处理器，用于统一处理Controller层抛出的异常
* @author bool
* @date 2019-06-21 19:27
*/
// Spring注解，声明为全局RestController异常处理器
@RestControllerAdvice
public class ServiceExceptionHandler {
/**
* 应用到所有@RequestMapping注解方法，在其执行之前初始化数据绑定器
* 可以用于注册自定义的属性编辑器或验证器
* @param binder 数据绑定器
*/
@InitBinder
public void initWebBinder(WebDataBinder binder){
// 此处可以添加自定义的数据绑定逻辑
// 如注册自定义的属性编辑器、验证器等
}
/**
* 把值绑定到Model中，使全局@RequestMapping可以获取到该值
* 在所有Controller方法执行前，向Model中添加公共属性
* @param model Spring MVC的Model对象
*/
@ModelAttribute
public void addAttribute(Model model) {
// 此处可以向Model中添加全局共享的属性
// 这些属性在所有Controller的RequestMapping方法中都可访问
}
/**
* 捕获ServiceException
* 专门处理自定义的业务异常ServiceException
* @param e 捕获到的ServiceException异常对象
* @return 统一的API响应格式
*/
@ExceptionHandler({com.yf.exam.core.exception.ServiceException.class})
// 设置HTTP响应状态码为200，业务错误通过code字段区分
@ResponseStatus(HttpStatus.OK)
public ApiRest serviceExceptionHandler(ServiceException e) {
// 将ServiceException转换为统一的API响应格式
return new ApiRest(e);
}
}

83
exam-api1/src/main/java/com/yf/exam/core/utils/BeanMapper.java
Unescape View File

@ -0,0 +1,83 @@
package com.yf.exam.core.utils;
import org.dozer.DozerBeanMapper;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 简单封装Dozer, 实现深度转换Bean<->Bean的Mapper.实现:
*
* 1. 持有Mapper的单例.
* 2. 返回值类型转换.
* 3. 批量转换Collection中的所有对象.
* 4. 区分创建新的B对象与将对象A值复制到已存在的B对象两种函数.
*
* 对象映射工具类，封装Dozer框架，提供便捷的Bean转换功能
*/
public class BeanMapper {
/**
* 持有Dozer单例, 避免重复创建DozerMapper消耗资源.
* 静态实例，整个应用共享，提高性能
*/
private static DozerBeanMapper dozerBeanMapper = new DozerBeanMapper();
/**
* 基于Dozer转换对象的类型.
* 将源对象转换为目标类型的对象（创建新实例）
* @param source 源对象
* @param destinationClass 目标类型Class
* @param <T> 目标类型泛型
* @return 转换后的目标类型对象
*/
public static <T> T map(Object source, Class<T> destinationClass) {
return dozerBeanMapper.map(source, destinationClass);
}
/**
* 基于Dozer转换Collection中对象的类型.
* 批量转换集合中的对象到目标类型
* @param sourceList 源对象集合
* @param destinationClass 目标类型Class
* @param <T> 目标类型泛型
* @return 转换后的目标类型对象列表
*/
public static <T> List<T> mapList(Iterable<?> sourceList, Class<T> destinationClass) {
List<T> destinationList = new ArrayList();
for (Object sourceObject : sourceList) {
T destinationObject = dozerBeanMapper.map(sourceObject, destinationClass);
destinationList.add(destinationObject);
}
return destinationList;
}
/**
* 基于Dozer将对象A的值拷贝到对象B中.
* 将源对象的属性值复制到已存在的目标对象中
* @param source 源对象
* @param destinationObject 目标对象（已存在实例）
*/
public static void copy(Object source, Object destinationObject) {
if(source!=null) {
dozerBeanMapper.map(source, destinationObject);
}
}
/**
* 使用Java 8 Function接口转换集合
* 提供更灵活的集合转换方式，支持自定义映射逻辑
* @param source 源集合
* @param mapper 映射函数
* @param <T> 目标类型泛型
* @param <S> 源类型泛型
* @return 转换后的目标类型对象列表
*/
public static <T, S> List<T> mapList(Collection<S> source, Function<? super S, ? extends T> mapper) {
return source.stream().map(mapper).collect(Collectors.toList());
}
}

45
exam-api1/src/main/java/com/yf/exam/core/utils/CronUtils.java
Unescape View File

@ -0,0 +1,45 @@
package com.yf.exam.core.utils;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 时间转换quartz表达式
* 提供日期时间与Quartz Cron表达式之间的转换功能
* @author bool
* @date 2020/11/29 下午3:00
*/
public class CronUtils {
/**
* 格式化数据
* Quartz Cron表达式的时间格式：秒 分 时 日 月 星期 年
* 格式说明：
* - ss: 秒 (0-59)
* - mm: 分 (0-59)
* - HH: 时 (0-23)
* - dd: 日 (1-31)
* - MM: 月 (1-12)
* - ? : 星期忽略（与日期冲突时使用）
* - yyyy: 年
*/
private static final String DATE_FORMAT = "ss mm HH dd MM ? yyyy";
/**
* 准确的时间点到表达式
* 将具体的日期时间转换为Quartz Cron表达式
* 用于在指定精确时间执行任务
* @param date 需要转换的日期时间对象
* @return Quartz Cron表达式字符串，如果date为null则返回空字符串
*/
public static String dateToCron(final Date date){
// 创建指定格式的日期格式化器
SimpleDateFormat fmt = new SimpleDateFormat(DATE_FORMAT);
String formatTimeStr = "";
if (date != null) {
// 将Date对象格式化为Cron表达式字符串
formatTimeStr = fmt.format(date);
}
return formatTimeStr;
}
}

117
exam-api1/src/main/java/com/yf/exam/core/utils/DateUtils.java
Unescape View File

@ -0,0 +1,117 @@
package com.yf.exam.core.utils;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
/**
* 日期处理工具类
* 提供日期计算、格式化、解析等常用日期操作功能
* ClassName: DateUtils <br/>
* date: 2018年12月13日 下午6:34:02 <br/>
*
* @author Bool
* @version
*/
public class DateUtils {
/**
*
* calcExpDays:计算某个日期与当前日期相差的天数，如果计算的日期大于现在时间，将返回负数；否则返回正数 <br/>
* 用于计算两个日期之间的天数差异，常用于计算过期天数、剩余天数等场景
* @author Bool
* @param userCreateTime 需要比较的日期
* @return 相差的天数（正数表示过去的天数，负数表示未来的天数）
* @since JDK 1.6
*/
public static int calcExpDays(Date userCreateTime){
// 创建目标日期的Calendar实例
Calendar start = Calendar.getInstance();
start.setTime(userCreateTime);
// 创建当前日期的Calendar实例
Calendar now = Calendar.getInstance();
now.setTime(new Date());
// 计算两个日期之间的毫秒数差值
long l = now.getTimeInMillis() - start.getTimeInMillis();
// 将毫秒数转换为天数（1000毫秒 * 60秒 * 60分钟 * 24小时）
int days = new Long(l / (1000 * 60 * 60 * 24)).intValue();
return days;
}
/**
*
* dateNow:获取当前时间的字符串格式，根据传入的格式化来展示. <br/>
* 获取当前系统时间的格式化字符串表示
* @author Bool
* @param format 日期格式化模式字符串（如："yyyy-MM-dd HH:mm:ss"）
* @return 格式化后的当前日期时间字符串
*/
public static String dateNow(String format) {
SimpleDateFormat fmt = new SimpleDateFormat(format);
Calendar c = new GregorianCalendar();
return fmt.format(c.getTime());
}
/**
* formatDate:格式化日期，返回指定的格式 <br/>
* 将Date对象格式化为指定格式的字符串
* @author Bool
* @param time 需要格式化的日期对象
* @param format 日期格式化模式字符串
* @return 格式化后的日期时间字符串
*/
public static String formatDate(Date time, String format) {
SimpleDateFormat fmt = new SimpleDateFormat(format);
return fmt.format(time.getTime());
}
/**
* parseDate:将字符串转换成日期，使用：yyyy-MM-dd HH:mm:ss 来格式化
* 使用默认格式解析字符串为Date对象
* @author Bool
* @param date 需要解析的日期字符串
* @return 解析后的Date对象，解析失败返回null
*/
public static Date parseDate(String date) {
return parseDate(date, "yyyy-MM-dd HH:mm:ss");
}
/**
*
* parseDate:将字符串转换成日期，使用指定格式化来格式化
* 使用指定格式解析字符串为Date对象
* @author Bool
* @param date 需要解析的日期字符串
* @param pattern 日期格式化模式字符串，如果为null则使用默认格式
* @return 解析后的Date对象，解析失败返回null
*/
public static Date parseDate(String date, String pattern) {
// 如果模式字符串为空，使用默认格式
if (pattern==null) {
pattern = "yyyy-MM-dd HH:mm:ss";
}
// 创建指定格式的日期格式化器
SimpleDateFormat fmt = new SimpleDateFormat(pattern);
try {
// 尝试解析日期字符串
return fmt.parse(date);
} catch (Exception ex) {
// 解析失败时打印异常堆栈
ex.printStackTrace();
}
// 解析失败返回null
return null;
}
}

76
exam-api1/src/main/java/com/yf/exam/core/utils/IpUtils.java
Unescape View File

@ -0,0 +1,76 @@
package com.yf.exam.core.utils;
import javax.servlet.http.HttpServletRequest;
/**
* IP获取工具类，用户获取网络请求过来的真实IP
* 通过多种HTTP头部信息获取客户端的真实IP地址，处理代理服务器场景
* ClassName: IpUtils <br/>
* date: 2018年2月13日 下午7:27:52 <br/>
*
* @author Bool
* @version
*/
public class IpUtils {
/**
*
* getClientIp:通过请求获取客户端的真实IP地址
* 按照优先级从多种HTTP头部中提取客户端真实IP，处理多层代理情况
* @author Bool
* @param request HTTP请求对象
* @return 客户端的真实IP地址
*/
public static String extractClientIp(HttpServletRequest request) {
String ip = null;
//X-Forwarded-For：Squid 服务代理
// 标准代理头部，格式：client, proxy1, proxy2
String ipAddresses = request.getHeader("X-Forwarded-For");
// 如果X-Forwarded-For头部不存在或无效，尝试下一个头部
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
//Proxy-Client-IP：apache 服务代理
// Apache代理服务器使用的头部
ipAddresses = request.getHeader("Proxy-Client-IP");
}
// 继续尝试其他代理头部
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
//WL-Proxy-Client-IP：weblogic 服务代理
// WebLogic代理服务器使用的头部
ipAddresses = request.getHeader("WL-Proxy-Client-IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
//HTTP_CLIENT_IP：有些代理服务器
// 一些非标准代理服务器使用的头部
ipAddresses = request.getHeader("HTTP_CLIENT_IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
//X-Real-IP：nginx服务代理
// Nginx代理服务器使用的头部
ipAddresses = request.getHeader("X-Real-IP");
}
//有些网络通过多层代理，那么获取到的ip就会有多个，一般都是通过逗号（,）分割开来，并且第一个ip为客户端的真实IP
// 处理多个IP的情况，取第一个IP作为客户端真实IP
if (ipAddresses != null && ipAddresses.length() != 0) {
ip = ipAddresses.split(",")[0];
}
//还是不能获取到，最后再通过request.getRemoteAddr();获取
// 如果所有代理头部都无法获取IP，使用Servlet API的getRemoteAddr方法
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ip = request.getRemoteAddr();
}
return ip;
}
}

403
exam-api1/src/main/java/com/yf/exam/core/utils/Reflections.java
Unescape View File

@ -0,0 +1,403 @@
/**
* Copyright (c) 2005-2012 springside.org.cn
*/
package com.yf.exam.core.utils;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.springframework.util.Assert;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 反射工具类.
* 提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class, 被AOP过的真实类等工具函数.
* @author calvin
* @version 2016-01-15
*/
@Log4j2
public class Reflections {
// Setter方法前缀
private static final String SETTER_PREFIX = "set";
// Getter方法前缀
private static final String GETTER_PREFIX = "get";
// CGLIB代理类分隔符
private static final String CGLIB_CLASS_SEPARATOR = "$$";
/**
* 获取类的所有属性，包括父类
* 递归遍历类的继承层次结构，获取所有声明的字段
*
* @param object 目标对象
* @return 包含所有字段的数组，包括父类的字段
*/
public static Field[] getAllFields(Object object) {
Class<?> clazz = object.getClass();
List<Field> fieldList = new ArrayList<>();
// 循环遍历所有父类，直到Object类
while (clazz != null) {
fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
clazz = clazz.getSuperclass();
}
Field[] fields = new Field[fieldList.size()];
fieldList.toArray(fields);
return fields;
}
/**
* 调用Getter方法.
* 支持多级，如：对象名.对象名.方法
* @param obj 目标对象
* @param propertyName 属性名，支持点分格式（如：user.address.city）
* @return 属性值
*/
public static Object invokeGetter(Object obj, String propertyName) {
Object object = obj;
// 按点号分割属性路径，逐级调用getter方法
for (String name : StringUtils.split(propertyName, ".")){
String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name);
object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
}
return object;
}
/**
* 调用Setter方法, 仅匹配方法名。
* 支持多级，如：对象名.对象名.方法
* @param obj 目标对象
* @param propertyName 属性名，支持点分格式
* @param value 要设置的值
*/
public static void invokeSetter(Object obj, String propertyName, Object value) {
Object object = obj;
String[] names = StringUtils.split(propertyName, ".");
// 遍历属性路径，对中间对象调用getter，对最终属性调用setter
for (int i=0; i<names.length; i++){
if(i<names.length-1){
// 中间路径：调用getter方法获取下一级对象
String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(names[i]);
object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
}else{
// 最终路径：调用setter方法设置值
String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(names[i]);
invokeMethodByName(object, setterMethodName, new Object[] { value });
}
}
}
/**
* 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数.
* @param obj 目标对象
* @param fieldName 字段名
* @return 字段值
*/
public static Object getFieldValue(final Object obj, final String fieldName) {
// 获取可访问的字段对象
Field field = getAccessibleField(obj, fieldName);
if (field == null) {
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
}
Object result = null;
try {
// 直接读取字段值
result = field.get(obj);
} catch (IllegalAccessException e) {
log.error("不可能抛出的异常{}", e.getMessage());
}
return result;
}
/**
* 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.
* @param obj 目标对象
* @param fieldName 字段名
* @param value 要设置的值
*/
public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
// 获取可访问的字段对象
Field field = getAccessibleField(obj, fieldName);
if (field == null) {
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
}
try {
// 直接设置字段值
field.set(obj, value);
} catch (IllegalAccessException e) {
log.error("不可能抛出的异常:{}", e.getMessage());
}
}
/**
* 直接调用对象方法, 无视private/protected修饰符.
* 用于一次性调用的情况，否则应使用getAccessibleMethod()函数获得Method后反复调用.
* 同时匹配方法名+参数类型，
* @param obj 目标对象
* @param methodName 方法名
* @param parameterTypes 参数类型数组
* @param args 参数值数组
* @return 方法返回值
*/
public static Object invokeMethod(final Object obj, final String methodName, final Class<?>[] parameterTypes,
final Object[] args) {
// 获取可访问的方法对象
Method method = getAccessibleMethod(obj, methodName, parameterTypes);
if (method == null) {
throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
}
try {
// 调用方法
return method.invoke(obj, args);
} catch (Exception e) {
// 将反射异常转换为运行时异常
throw convertReflectionExceptionToUnchecked(e);
}
}
/**
* 直接调用对象方法, 无视private/protected修饰符，
* 用于一次性调用的情况，否则应使用getAccessibleMethodByName()函数获得Method后反复调用.
* 只匹配函数名，如果有多个同名函数调用第一个。
* @param obj 目标对象
* @param methodName 方法名
* @param args 参数值数组
* @return 方法返回值
*/
public static Object invokeMethodByName(final Object obj, final String methodName, final Object[] args) {
// 获取可访问的方法对象（仅按方法名匹配）
Method method = getAccessibleMethodByName(obj, methodName);
if (method == null) {
throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
}
try {
// 调用方法
return method.invoke(obj, args);
} catch (Exception e) {
// 将反射异常转换为运行时异常
throw convertReflectionExceptionToUnchecked(e);
}
}
/**
* 循环向上转型, 获取对象的DeclaredField, 并强制设置为可访问.
*
* 如向上转型到Object仍无法找到, 返回null.
* @param obj 目标对象
* @param fieldName 字段名
* @return 可访问的字段对象，找不到返回null
*/
public static Field getAccessibleField(final Object obj, final String fieldName) {
// 参数校验
Validate.notNull(obj, "object can't be null");
Validate.notBlank(fieldName, "fieldName can't be blank");
// 循环向上转型查找字段
for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()) {
try {
Field field = superClass.getDeclaredField(fieldName);
// 设置字段可访问
makeAccessible(field);
return field;
} catch (NoSuchFieldException e) {//NOSONAR
// Field不在当前类定义,继续向上转型
continue;// new add
}
}
return null;
}
/**
* 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问.
* 如向上转型到Object仍无法找到, 返回null.
* 匹配函数名+参数类型。
*
* 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args)
* @param obj 目标对象
* @param methodName 方法名
* @param parameterTypes 参数类型数组
* @return 可访问的方法对象，找不到返回null
*/
public static Method getAccessibleMethod(final Object obj, final String methodName,
final Class<?>... parameterTypes) {
// 参数校验
Validate.notNull(obj, "object can't be null");
Validate.notBlank(methodName, "methodName can't be blank");
// 循环向上转型查找方法
for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
try {
Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
// 设置方法可访问
makeAccessible(method);
return method;
} catch (NoSuchMethodException e) {
// Method不在当前类定义,继续向上转型
continue;// new add
}
}
return null;
}
/**
* 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问.
* 如向上转型到Object仍无法找到, 返回null.
* 只匹配函数名。
*
* 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args)
* @param obj 目标对象
* @param methodName 方法名
* @return 可访问的方法对象，找不到返回null
*/
public static Method getAccessibleMethodByName(final Object obj, final String methodName) {
// 参数校验
Validate.notNull(obj, "object can't be null");
Validate.notBlank(methodName, "methodName can't be blank");
// 循环向上转型查找方法（仅按方法名）
for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
Method[] methods = searchType.getDeclaredMethods();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
// 设置方法可访问
makeAccessible(method);
return method;
}
}
}
return null;
}
/**
* 改变private/protected的方法为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。
* @param method 要设置为可访问的方法
*/
public static void makeAccessible(Method method) {
if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
&& !method.isAccessible()) {
method.setAccessible(true);
}
}
/**
* 改变private/protected的成员变量为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。
* @param field 要设置为可访问的字段
*/
public static void makeAccessible(Field field) {
if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers()) || Modifier
.isFinal(field.getModifiers())) && !field.isAccessible()) {
field.setAccessible(true);
}
}
/**
* 通过反射, 获得Class定义中声明的泛型参数的类型, 注意泛型必须定义在父类处
* 如无法找到, 返回Object.class.
* eg.
* public UserDao extends HibernateDao<User>
*
* @param clazz The class to introspect
* @return the first generic declaration, or Object.class if cannot be determined
*/
@SuppressWarnings("unchecked")
public static <T> Class<T> getClassGenricType(final Class clazz) {
return getClassGenricType(clazz, 0);
}
/**
* 通过反射, 获得Class定义中声明的父类的泛型参数的类型.
* 如无法找到, 返回Object.class.
*
* 如public UserDao extends HibernateDao<User,Long>
*
* @param clazz clazz The class to introspect
* @param index the Index of the generic ddeclaration,start from 0.
* @return the index generic declaration, or Object.class if cannot be determined
*/
public static Class getClassGenricType(final Class clazz, final int index) {
// 获取父类类型
Type genType = clazz.getGenericSuperclass();
// 检查是否为参数化类型
if (!(genType instanceof ParameterizedType)) {
log.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
return Object.class;
}
// 获取泛型参数类型数组
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
// 检查索引是否有效
if (index >= params.length || index < 0) {
log.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
+ params.length);
return Object.class;
}
// 检查是否为Class类型
if (!(params[index] instanceof Class)) {
log.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
return Object.class;
}
return (Class) params[index];
}
/**
* 获取被AOP代理后的真实类
* @param instance 实例对象
* @return 真实类
*/
public static Class<?> getUserClass(Object instance) {
Assert.notNull(instance, "Instance must not be null");
Class clazz = instance.getClass();
// 检查是否为CGLIB代理类
if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
Class<?> superClass = clazz.getSuperclass();
// 返回父类（真实类）
if (superClass != null && !Object.class.equals(superClass)) {
return superClass;
}
}
return clazz;
}
/**
* 将反射时的checked exception转换为unchecked exception.
* @param e 反射异常
* @return 转换后的运行时异常
*/
public static RuntimeException convertReflectionExceptionToUnchecked(Exception e) {
if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException
|| e instanceof NoSuchMethodException) {
// 参数或访问异常转换为IllegalArgumentException
return new IllegalArgumentException(e);
} else if (e instanceof InvocationTargetException) {
// 调用目标异常转换为RuntimeException
return new RuntimeException(((InvocationTargetException) e).getTargetException());
} else if (e instanceof RuntimeException) {
// 已经是运行时异常，直接返回
return (RuntimeException) e;
}
// 其他受检异常包装为RuntimeException
return new RuntimeException("Unexpected Checked Exception.", e);
}
}

61
exam-api1/src/main/java/com/yf/exam/core/utils/SpringUtils.java
Unescape View File

@ -0,0 +1,61 @@
package com.yf.exam.core.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* Spring获取工具
* 用于在非Spring管理类中获取Spring容器中的Bean实例
* 实现ApplicationContextAware接口，在Spring启动时自动注入ApplicationContext
*
* @author bool
* @date 2019-12-09 15:55
*/
// 声明为Spring组件，由Spring容器管理
@Component
public class SpringUtils implements ApplicationContextAware {
/**
* Spring应用上下文对象
* 静态变量，用于在整个应用中共享ApplicationContext实例
*/
private static ApplicationContext applicationContext;
/**
* 实现ApplicationContextAware接口的方法
* Spring容器在启动时会自动调用此方法，注入ApplicationContext
* @param context Spring应用上下文对象
* @throws BeansException 如果注入过程中发生异常
*/
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
// 将Spring注入的ApplicationContext赋值给静态变量
applicationContext = context;
}
/**
* 根据类型获取Spring容器中的Bean实例
* 适用于按类型唯一匹配的Bean获取
* @param tClass Bean的类型Class对象
* @param <T> Bean的泛型类型
* @return Spring容器中指定类型的Bean实例
*/
public static <T> T getBean(Class<T> tClass) {
return applicationContext.getBean(tClass);
}
/**
* 根据名称和类型获取Spring容器中的Bean实例
* 适用于同一类型有多个实现，需要按名称区分的场景
* @param name Bean的名称（在Spring容器中的标识）
* @param type Bean的类型Class对象
* @param <T> Bean的泛型类型
* @return Spring容器中指定名称和类型的Bean实例
*/
public static <T> T getBean(String name, Class<T> type) {
return applicationContext.getBean(name, type);
}
}

46
exam-api1/src/main/java/com/yf/exam/core/utils/StringUtils.java
Unescape View File

@ -0,0 +1,46 @@
package com.yf.exam.core.utils;
import java.util.Map;
/**
* 字符串常用工具类
* 提供字符串处理和格式转换的常用方法
* @author bool
* @date 2019-05-15 11:40
*/
public class StringUtils {
/**
* 判断是否为空字符
* 检查字符串是否为null或空字符串
* @param str 需要检查的字符串
* @return 如果字符串为null或空字符串返回true，否则返回false
*/
public static boolean isBlank(String str){
return str==null || "".equals(str);
}
/**
* 将MAP转换成一个xml格式，格式为<xml><key>value</key>...</xml>
* 将Map中的键值对转换为XML格式字符串，常用于微信支付等接口的数据传输
* @param params 需要转换的Map对象，键值对将作为XML的标签和内容
* @return 转换后的XML格式字符串
*/
public static String mapToXml(Map<String, String> params){
// 创建StringBuffer用于高效构建XML字符串
StringBuffer sb = new StringBuffer("<xml>");
// 遍历Map中的所有键
for(String key:params.keySet()){
// 为每个键值对构建XML标签：<key>value</key>
sb.append("<")
.append(key).append(">")
.append(params.get(key))
.append("</").append(key).append(">");
}
// 添加XML结束标签
sb.append("</xml>");
return sb.toString();
}
}

434
exam-api1/src/main/java/com/yf/exam/core/utils/excel/ExportExcel.java
Unescape View File

@ -0,0 +1,434 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel;
import com.google.common.collect.Lists;
import com.yf.exam.core.utils.Reflections;
import com.yf.exam.core.utils.excel.annotation.ExcelField;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.DataFormat;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URLEncoder;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 导出Excel文件（导出"XLSX"格式，支持大数据量导出 @see org.apache.poi.ss.SpreadsheetVersion）
* 基于注解的Excel导出工具类，支持大数据量处理和样式定制
* @author jeeplus
* @version 2016-04-21
*/
public class ExportExcel {
private static Logger log = LoggerFactory.getLogger(ExportExcel.class);
/**
* 工作薄对象
* 使用SXSSFWorkbook支持大数据量导出，避免内存溢出
*/
private SXSSFWorkbook wb;
/**
* 工作表对象
* 当前操作的Sheet页
*/
private Sheet sheet;
/**
* 样式列表
* 存储预定义的单元格样式，提高性能
*/
private Map<String, CellStyle> styles;
/**
* 当前行号
* 记录当前写入的行位置
*/
private int rownum;
/**
* 注解列表（Object[]{ ExcelField, Field/Method }）
* 存储实体类的字段注解信息，用于导出映射
*/
List<Object[]> annotationList = Lists.newArrayList();
/**
* 构造函数
* @param title 表格标题，传"空值"，表示无标题
* @param cls 实体对象，通过annotation.ExportField获取标题
*/
public ExportExcel(String title, Class<?> cls){
this(title, cls, 1);
}
/**
* 构造函数
* @param title 表格标题，传"空值"，表示无标题
* @param cls 实体对象，通过annotation.ExportField获取标题
* @param type 导出类型（1:导出数据；2：导出模板）
* @param groups 导入分组
*/
public ExportExcel(String title, Class<?> cls, int type, int... groups){
// Get annotation field - 获取字段注解
Field[] fs = cls.getDeclaredFields();
for (Field f : fs){
ExcelField ef = f.getAnnotation(ExcelField.class);
// 检查注解是否存在且类型匹配（0-导入导出，1-仅导出，2-仅导入）
if (ef != null && (ef.type()==0 || ef.type()==type)){
// 分组检查 - 如果指定了分组，只处理匹配分组的字段
if (groups!=null && groups.length>0){
boolean inGroup = false;
for (int g : groups){
if (inGroup){
break;
}
for (int efg : ef.groups()){
if (g == efg){
inGroup = true;
annotationList.add(new Object[]{ef, f});
break;
}
}
}
}else{
// 未指定分组，添加所有匹配的字段
annotationList.add(new Object[]{ef, f});
}
}
}
// Get annotation method - 获取方法注解
Method[] ms = cls.getDeclaredMethods();
for (Method m : ms){
ExcelField ef = m.getAnnotation(ExcelField.class);
// 检查注解是否存在且类型匹配
if (ef != null && (ef.type()==0 || ef.type()==type)){
// 分组检查
if (groups!=null && groups.length>0){
boolean inGroup = false;
for (int g : groups){
if (inGroup){
break;
}
for (int efg : ef.groups()){
if (g == efg){
inGroup = true;
annotationList.add(new Object[]{ef, m});
break;
}
}
}
}else{
annotationList.add(new Object[]{ef, m});
}
}
}
// Field sorting - 字段排序，按照sort值升序排列
Collections.sort(annotationList, new Comparator<Object[]>() {
@Override
public int compare(Object[] o1, Object[] o2) {
return new Integer(((ExcelField)o1[0]).sort()).compareTo(
new Integer(((ExcelField)o2[0]).sort()));
}
});
// Initialize - 初始化Excel表头
List<String> headerList = Lists.newArrayList();
for (Object[] os : annotationList){
String t = ((ExcelField)os[0]).title();
// 如果是导出数据（type=1），则去掉注释部分（用**分隔）
if (type==1){
String[] ss = StringUtils.split(t, "**", 2);
if (ss.length==2){
t = ss[0];
}
}
headerList.add(t);
}
initialize(title, headerList);
}
/**
* 初始化函数
* @param title 表格标题，传"空值"，表示无标题
* @param headerList 表头列表
*/
private void initialize(String title, List<String> headerList) {
// 创建SXSSFWorkbook，设置窗口大小为500行，支持大数据量导出
this.wb = new SXSSFWorkbook(500);
this.sheet = wb.createSheet("Export");
this.styles = createStyles(wb);
// Create title - 创建标题行
if (StringUtils.isNotBlank(title)){
Row titleRow = sheet.createRow(rownum++);
titleRow.setHeightInPoints(30); // 设置行高
Cell titleCell = titleRow.createCell(0);
titleCell.setCellStyle(styles.get("title"));
titleCell.setCellValue(title);
// 合并标题单元格，跨所有列
sheet.addMergedRegion(new CellRangeAddress(titleRow.getRowNum(),
titleRow.getRowNum(), titleRow.getRowNum(), headerList.size()-1));
}
// Create header - 创建表头行
if (headerList == null){
throw new RuntimeException("headerList not null!");
}
Row headerRow = sheet.createRow(rownum++);
headerRow.setHeightInPoints(16);
for (int i = 0; i < headerList.size(); i++) {
Cell cell = headerRow.createCell(i);
cell.setCellStyle(styles.get("header"));
String[] ss = StringUtils.split(headerList.get(i), "**", 2);
if (ss.length==2){
// 标题包含批注的情况：标题**批注
cell.setCellValue(ss[0]);
// 创建批注
Comment comment = this.sheet.createDrawingPatriarch().createCellComment(
new XSSFClientAnchor(0, 0, 0, 0, (short) 3, 3, (short) 5, 6));
comment.setString(new XSSFRichTextString(ss[1]));
cell.setCellComment(comment);
}else{
// 普通标题
cell.setCellValue(headerList.get(i));
}
sheet.autoSizeColumn(i); // 自动调整列宽
}
// 进一步调整列宽，确保最小宽度为3000
for (int i = 0; i < headerList.size(); i++) {
int colWidth = sheet.getColumnWidth(i)*2;
sheet.setColumnWidth(i, colWidth < 3000 ? 3000 : colWidth);
}
log.debug("Initialize success.");
}
/**
* 创建表格样式
* @param wb 工作薄对象
* @return 样式列表
*/
private Map<String, CellStyle> createStyles(Workbook wb) {
Map<String, CellStyle> styles = new HashMap<>(16);
// Title style - 标题样式：居中、粗体、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);
// Data style - 数据样式基础：细边框、垂直居中、10号字体
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);
// Data1 style - 左对齐数据样式
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(CellStyle.ALIGN_LEFT);
styles.put("data1", style);
// Data2 style - 居中对齐数据样式
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(CellStyle.ALIGN_CENTER);
styles.put("data2", style);
// Data3 style - 右对齐数据样式
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(CellStyle.ALIGN_RIGHT);
styles.put("data3", style);
// 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 行对象
*/
public Row addRow(){
return sheet.createRow(rownum++);
}
/**
* 添加一个单元格
* @param row 添加的行
* @param column 添加列号
* @param val 添加值
* @return 单元格对象
*/
public Cell addCell(Row row, int column, Object val){
return this.addCell(row, column, val, 0, Class.class);
}
/**
* 添加一个单元格
* @param row 添加的行
* @param column 添加列号
* @param val 添加值
* @param align 对齐方式（1：靠左；2：居中；3：靠右）
* @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 {
// 其他类型通过反射调用对应的Type类的setValue方法
if (fieldType != Class.class){
cell.setCellValue((String)fieldType.getMethod("setValue", Object.class).invoke(null, val));
}else{
cell.setCellValue((String)Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(),
"fieldtype."+val.getClass().getSimpleName()+"Type")).getMethod("setValue", Object.class).invoke(null, val));
}
}
} catch (Exception ex) {
// 异常处理：记录日志并使用toString方法
log.info("Set cell value ["+row.getRowNum()+","+column+"] error: " + ex.toString());
cell.setCellValue(val.toString());
}
cell.setCellStyle(style);
return cell;
}
/**
* 添加数据（通过annotation.ExportField添加数据）
* @return list 数据列表
*/
public <E> ExportExcel setDataList(List<E> list){
for (E e : list){
int colunm = 0;
Row row = this.addRow();
StringBuilder sb = new StringBuilder();
for (Object[] os : annotationList){
ExcelField ef = (ExcelField)os[0];
Object val = null;
try{
// 如果指定了value，使用反射调用getter方法
if (StringUtils.isNotBlank(ef.value())){
val = Reflections.invokeGetter(e, ef.value());
}else{
// 根据注解对象类型调用相应方法
if (os[1] instanceof Field){
val = Reflections.invokeGetter(e, ((Field)os[1]).getName());
}else if (os[1] instanceof Method){
val = Reflections.invokeMethod(e, ((Method)os[1]).getName(), new Class[] {}, new Object[] {});
}
}
}catch(Exception ex) {
log.info(ex.toString());
val = "";
}
// 添加单元格，使用注解中定义的对齐方式和字段类型
this.addCell(row, colunm++, val, ef.align(), ef.fieldType());
sb.append(val + ", ");
}
log.debug("Write success: ["+row.getRowNum()+"] "+sb.toString());
}
return this;
}
/**
* 输出数据流
* @param os 输出数据流
*/
public ExportExcel write(OutputStream os) throws IOException{
wb.write(os);
return this;
}
/**
* 输出到客户端
* @param fileName 输出文件名
*/
public ExportExcel write(HttpServletResponse response, String fileName) throws IOException{
response.reset();
response.setHeader("Access-Control-Allow-Origin", "*");
response.setContentType("application/octet-stream; charset=utf-8");
response.addHeader("Content-Disposition", "attachment; filename="+ URLEncoder.encode(fileName, "utf-8"));
write(response.getOutputStream());
return this;
}
/**
* 清理临时文件
* 释放SXSSFWorkbook占用的临时文件资源
*/
public ExportExcel dispose(){
wb.dispose();
return this;
}
}

343
exam-api1/src/main/java/com/yf/exam/core/utils/excel/ImportExcel.java
Unescape View File

@ -0,0 +1,343 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel;
import com.google.common.collect.Lists;
import com.yf.exam.core.utils.Reflections;
import com.yf.exam.core.utils.excel.annotation.ExcelField;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
/**
* 导入Excel文件（支持"XLS"和"XLSX"格式）
* 基于注解的Excel导入工具类，支持数据校验和类型转换
* @author jeeplus
* @version 2016-03-10
*/
public class ImportExcel {
private static Logger log = LoggerFactory.getLogger(ImportExcel.class);
/**
* 工作薄对象
* 用于操作Excel文件的工作簿
*/
private Workbook wb;
/**
* 工作表对象
* 当前操作的Sheet页
*/
private Sheet sheet;
/**
* 标题行号
* 从0开始计数，用于定位数据起始位置
*/
private int headerNum;
/**
* 构造函数
* @param multipartFile 导入文件对象
* @param headerNum 标题行号，数据行号=标题行号+1
* @param sheetIndex 工作表编号
* @throws InvalidFormatException
* @throws IOException
*/
public ImportExcel(MultipartFile multipartFile, int headerNum, int sheetIndex)
throws InvalidFormatException, IOException {
this(multipartFile.getOriginalFilename(), multipartFile.getInputStream(), headerNum, sheetIndex);
}
/**
* 构造函数
* @param fileName 文件名，用于判断文件格式
* @param is 导入文件输入流
* @param headerNum 标题行号，数据行号=标题行号+1
* @param sheetIndex 工作表编号
* @throws InvalidFormatException
* @throws IOException
*/
public ImportExcel(String fileName, InputStream is, int headerNum, int sheetIndex)
throws IOException {
// 文件名校验
if (StringUtils.isBlank(fileName)){
throw new RuntimeException("导入文档为空!");
}else if(fileName.toLowerCase().endsWith("xls")){
// 处理xls格式的Excel文件（HSSFWorkbook）
this.wb = new HSSFWorkbook(is);
}else if(fileName.toLowerCase().endsWith("xlsx")){
// 处理xlsx格式的Excel文件（XSSFWorkbook）
this.wb = new XSSFWorkbook(is);
}else{
throw new RuntimeException("文档格式不正确!");
}
// 工作表存在性校验
if (this.wb.getNumberOfSheets()<sheetIndex){
throw new RuntimeException("文档中没有工作表!");
}
// 获取指定索引的工作表
this.sheet = this.wb.getSheetAt(sheetIndex);
this.headerNum = headerNum;
log.debug("Initialize success.");
}
/**
* 获取行对象
* @param rownum 行号
* @return 行对象
*/
public Row getRow(int rownum){
return this.sheet.getRow(rownum);
}
/**
* 获取数据行号
* 数据从标题行的下一行开始
* @return 数据起始行号
*/
public int getDataRowNum(){
return headerNum+1;
}
/**
* 获取最后一个数据行号
* @return 最后一个数据行号
*/
public int getLastDataRowNum(){
return this.sheet.getLastRowNum()+headerNum;
}
/**
* 获取单元格值
* @param row 获取的行
* @param column 获取单元格列号
* @return 单元格值
*/
public Object getCellValue(Row row, int column) {
Object val = "";
try {
Cell cell = row.getCell(column);
if (cell != null) {
// 根据单元格类型处理不同的数据格式
if (cell.getCellType() == Cell.CELL_TYPE_NUMERIC) {
// 当excel 中的数据为数值或日期是需要特殊处理
if (HSSFDateUtil.isCellDateFormatted(cell)) {
// 日期类型处理
double d = cell.getNumericCellValue();
Date date = HSSFDateUtil.getJavaDate(d);
SimpleDateFormat dformat = new SimpleDateFormat(
"yyyy-MM-dd");
val = dformat.format(date);
} else {
// 数值类型处理，禁用千分位分隔符
NumberFormat nf = NumberFormat.getInstance();
nf.setGroupingUsed(false);// true时的格式：1,234,567,890
val = nf.format(cell.getNumericCellValue());// 数值类型的数据为double，所以需要转换一下
}
} else if (cell.getCellType() == Cell.CELL_TYPE_STRING) {
// 字符串类型
val = cell.getStringCellValue();
} else if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) {
// 公式类型
val = cell.getCellFormula();
} else if (cell.getCellType() == Cell.CELL_TYPE_BOOLEAN) {
// 布尔类型
val = cell.getBooleanCellValue();
} else if (cell.getCellType() == Cell.CELL_TYPE_ERROR) {
// 错误类型
val = cell.getErrorCellValue();
}
}
} catch (Exception e) {
// 异常时返回空字符串
return val;
}
return val;
}
/**
* 获取导入数据列表
* @param cls 导入对象类型
* @param groups 导入分组
* @return 数据对象列表
*/
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);
// 检查注解是否存在且类型匹配（0-导入导出，2-仅导入）
if (ef != null && (ef.type()==0 || ef.type()==2)){
// 分组检查
if (groups!=null && groups.length>0){
boolean inGroup = false;
for (int g : groups){
if (inGroup){
break;
}
for (int efg : ef.groups()){
if (g == efg){
inGroup = true;
annotationList.add(new Object[]{ef, f});
break;
}
}
}
}else{
annotationList.add(new Object[]{ef, f});
}
}
}
// Get annotation method - 获取方法注解
Method[] ms = cls.getDeclaredMethods();
for (Method m : ms){
ExcelField ef = m.getAnnotation(ExcelField.class);
if (ef != null && (ef.type()==0 || ef.type()==2)){
// 分组检查
if (groups!=null && groups.length>0){
boolean inGroup = false;
for (int g : groups){
if (inGroup){
break;
}
for (int efg : ef.groups()){
if (g == efg){
inGroup = true;
annotationList.add(new Object[]{ef, m});
break;
}
}
}
}else{
annotationList.add(new Object[]{ef, m});
}
}
}
// Field sorting - 字段排序，按照sort值升序排列
Collections.sort(annotationList, new Comparator<Object[]>() {
@Override
public int compare(Object[] o1, Object[] o2) {
return new Integer(((ExcelField)o1[0]).sort()).compareTo(
new Integer(((ExcelField)o2[0]).sort()));
}
});
// Get excel data - 读取Excel数据
List<E> dataList = Lists.newArrayList();
// 从数据起始行到结束行遍历
for (int i = this.getDataRowNum(); i < this.getLastDataRowNum(); i++) {
// 创建实体对象实例
E e = (E)cls.newInstance();
int column = 0;
Row row = this.getRow(i);
StringBuilder sb = new StringBuilder();
// 遍历注解列表，处理每个字段
for (Object[] os : annotationList){
Object val = this.getCellValue(row, column++);
if (val != null){
ExcelField ef = (ExcelField)os[0];
// Get param type and type cast - 获取参数类型并进行类型转换
Class<?> valType = Class.class;
if (os[1] instanceof Field){
valType = ((Field)os[1]).getType();
}else if (os[1] instanceof Method){
Method method = ((Method)os[1]);
if ("get".equals(method.getName().substring(0, 3))){
valType = method.getReturnType();
}else if("set".equals(method.getName().substring(0, 3))){
valType = ((Method)os[1]).getParameterTypes()[0];
}
}
//log.debug("Import value type: ["+i+","+column+"] " + valType);
try {
// 类型转换处理
//如果导入的java对象，需要在这里自己进行变换。
if (valType == String.class){
// 字符串类型处理，去除数值类型的".0"后缀
String s = String.valueOf(val.toString());
if(StringUtils.endsWith(s, ".0")){
val = StringUtils.substringBefore(s, ".0");
}else{
val = String.valueOf(val.toString());
}
}else if (valType == Integer.class){
// 整型转换
val = Double.valueOf(val.toString()).intValue();
}else if (valType == Long.class){
// 长整型转换
val = Double.valueOf(val.toString()).longValue();
}else if (valType == Double.class){
// 双精度浮点型转换
val = Double.valueOf(val.toString());
}else if (valType == Float.class){
// 单精度浮点型转换
val = Float.valueOf(val.toString());
}else if (valType == Date.class){
// 日期类型转换
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
val=sdf.parse(val.toString());
}else{
// 其他自定义类型转换
if (ef.fieldType() != Class.class){
// 使用注解指定的字段类型转换器
val = ef.fieldType().getMethod("getValue", String.class).invoke(null, val.toString());
}else{
// 使用默认的类型转换器
val = Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(),
"fieldtype."+valType.getSimpleName()+"Type")).getMethod("getValue", String.class).invoke(null, val.toString());
}
}
} catch (Exception ex) {
// 类型转换异常处理
log.info("Get cell value ["+i+","+column+"] error: " + ex.toString());
val = null;
}
// set entity value - 设置实体对象值
if (os[1] instanceof Field){
// 字段赋值
Reflections.invokeSetter(e, ((Field)os[1]).getName(), val);
}else if (os[1] instanceof Method){
// 方法赋值，自动将get方法转换为set方法
String mthodName = ((Method)os[1]).getName();
if ("get".equals(mthodName.substring(0, 3))){
mthodName = "set"+StringUtils.substringAfter(mthodName, "get");
}
Reflections.invokeMethod(e, mthodName, new Class[] {valType}, new Object[] {val});
}
}
sb.append(val+", ");
}
// 将处理好的实体对象添加到结果列表
dataList.add(e);
log.debug("Read success: ["+i+"] "+sb.toString());
}
return dataList;
}
}

70
exam-api1/src/main/java/com/yf/exam/core/utils/excel/annotation/ExcelField.java
Unescape View File

@ -0,0 +1,70 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Excel注解定义
* 用于标记实体类字段与Excel列的映射关系，支持导入导出功能
* @author jeeplus
* @version 2016-03-10
*/
// 注解可以用于方法、字段和类上
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
// 注解在运行时保留，可以通过反射读取
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcelField {
/**
* 导出字段名（默认调用当前字段的"get"方法，如指定导出字段为对象，请填写"对象名.对象属性"，例："area.name"、"office.name"）
* 如果为空，则默认使用字段名作为导出字段名
*/
String value() default "";
/**
* 导出字段标题（需要添加批注请用"**"分隔，标题**批注，仅对导出模板有效）
* Excel表格中显示的列标题，支持添加批注信息
*/
String title();
/**
* 字段类型（0：导出导入；1：仅导出；2：仅导入）
* 控制字段在Excel操作中的行为：0-既导出又导入，1-仅导出，2-仅导入
*/
int type() default 0;
/**
* 导出字段对齐方式（0：自动；1：靠左；2：居中；3：靠右）
* 设置Excel单元格内容的对齐方式
*/
int align() default 0;
/**
* 导出字段字段排序（升序）
* 数值越小，在Excel中的列位置越靠前
*/
int sort() default 0;
/**
* 如果是字典类型，请设置字典的type值
* 用于字典数据的转换，将字典值转换为显示文本
*/
String dictType() default "";
/**
* 反射类型
* 字段的数据类型，用于反射操作和数据转换
*/
Class<?> fieldType() default Class.class;
/**
* 字段归属组（根据分组导出导入）
* 可以通过分组控制哪些字段参与导出导入操作
*/
int[] groups() default {};
}

77
exam-api1/src/main/java/com/yf/exam/core/utils/excel/fieldtype/ListType.java
Unescape View File

@ -0,0 +1,77 @@
/**
* Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.yf.exam.core.utils.excel.fieldtype;
import com.google.common.collect.Lists;
import com.yf.exam.core.utils.StringUtils;
import java.util.List;
/**
* 字段类型转换
* 处理List集合与字符串之间的相互转换，用于Excel导入导出
* @author jeeplus
* @version 2016-5-29
*/
public class ListType {
/**
* 获取对象值（导入）
* 将逗号分隔的字符串转换为List集合，用于Excel导入时处理多值字段
* @param val 逗号分隔的字符串，如："value1,value2,value3"
* @return List<String> 集合对象
*/
public static Object getValue(String val) {
// 创建空的ArrayList
List<String> list = Lists.newArrayList();
// 检查输入字符串不为空且不为空白
if(!StringUtils.isBlank(val)) {
// 按逗号分割字符串并遍历每个部分
for (String s : val.split(",")) {
// 将每个分割后的字符串添加到List中
list.add(s);
}
}
return list;
}
/**
* 设置对象值（导出）
* 将List集合转换为逗号分隔的字符串，用于Excel导出时显示多值字段
* @param val List<String> 集合对象
* @return 逗号分隔的字符串，如："value1,value2,value3"
*/
public static String setValue(Object val) {
// 检查输入对象不为空
if (val != null){
// 将Object强制转换为List<String>
List<String> list = (List<String>)val;
// 用于构建结果字符串的StringBuffer
StringBuffer sb = null;
// 遍历List中的每个元素
for (String item: list){
// 跳过空元素和空白字符串
if(StringUtils.isBlank(item)){
continue;
}
// 如果是第一个有效元素，初始化StringBuffer
if(sb == null){
sb = new StringBuffer(item);
}else{
// 后续元素前添加逗号分隔符
sb.append(",").append(item);
}
}
// 如果StringBuffer不为空，处理并返回结果
if(sb!=null) {
// 移除可能存在的"[]"字符并返回字符串
return sb.toString().replace("[]", "");
}
}
// 输入为空时返回空字符串
return "";
}
}

49
exam-api1/src/main/java/com/yf/exam/core/utils/file/Md5Util.java
Unescape View File

@ -0,0 +1,49 @@
package com.yf.exam.core.utils.file;
import java.security.MessageDigest;
/**
* MD5工具类
* 提供MD5加密功能，用于字符串的不可逆加密处理
* ClassName: MD5Util <br/>
* date: 2018年1月13日 下午6:54:53 <br/>
*
* @author Bool
* @version
*/
public class Md5Util {
/**
* 简单MD5
* 对输入字符串进行MD5加密，返回32位小写十六进制字符串
* @param str 需要加密的原始字符串
* @return 32位MD5加密后的十六进制字符串，加密失败返回null
*/
public static String md5(String str) {
try {
// 获取MD5加密算法实例
MessageDigest md = MessageDigest.getInstance("MD5");
// 将字符串转换为UTF-8字节数组并进行MD5加密
byte[] array = md.digest(str.getBytes("UTF-8"));
// 创建StringBuilder用于构建结果字符串
StringBuilder sb = new StringBuilder();
// 遍历加密后的字节数组
for (byte item : array) {
// 将每个字节转换为十六进制字符串
// item & 0xFF: 将字节转换为无符号整数（0-255）
// | 0x100: 确保结果是3位十六进制数（例如：0x1a2 -> 0x11a2）
// substring(1, 3): 取后2位，得到标准的2位十六进制表示
sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
}
// 返回32位小写MD5字符串
return sb.toString();
}catch(Exception e) {
// 加密过程中发生异常时返回null
return null;
}
}
}

70
exam-api1/src/main/java/com/yf/exam/core/utils/passwd/PassHandler.java
Unescape View File

@ -0,0 +1,70 @@
package com.yf.exam.core.utils.passwd;
import com.yf.exam.core.utils.file.Md5Util;
import org.apache.commons.lang3.RandomStringUtils;
/**
* 通用的密码处理类，用于生成密码和校验密码
* 提供密码加密、验证和生成功能，增强密码安全性
* ClassName: PassGenerator <br/>
* date: 2017年12月13日 下午7:13:03 <br/>
*
* @author Bool
* @version
*/
public class PassHandler {
/**
* checkPass:校验密码是否一致
* 验证用户输入的密码是否与数据库中存储的密码匹配
* @author Bool
* @param inputPass 用户传入的原始密码
* @param salt 数据库保存的密码随机码（盐值）
* @param pass 数据库保存的加密后的密码MD5
* @return boolean 密码匹配返回true，否则返回false
*/
public static boolean checkPass(String inputPass , String salt , String pass){
// 首先对用户输入的密码进行MD5加密
String pwdMd5 = Md5Util.md5(inputPass);
// 将MD5加密后的密码与盐值拼接，再次进行MD5加密，然后与数据库中的密码比较
return Md5Util.md5(pwdMd5 + salt).equals(pass);
}
/**
*
* buildPassword:用于用户注册时产生一个密码
* 生成加密密码和对应的盐值，用于新用户注册或密码修改
* @author Bool
* @param inputPass 用户输入的原始密码
* @return PassInfo 返回一个密码对象，包含盐值和加密后的密码，需要保存到数据库
*/
public static PassInfo buildPassword(String inputPass) {
//产生一个6位数的随机码作为盐值，增强密码安全性
String salt = RandomStringUtils.randomAlphabetic(6);
//双重MD5加密：先对原始密码MD5，再与盐值拼接后进行第二次MD5加密
String encryptPassword = Md5Util.md5(Md5Util.md5(inputPass)+salt);
//返回包含盐值和加密密码的对象
return new PassInfo(salt,encryptPassword);
}
/**
* main方法：测试密码生成功能
* 用于演示密码生成过程，输出生成的密码和盐值
* @param args 命令行参数
*/
public static void main(String[] args) {
// 生成测试密码"190601"的加密信息
PassInfo info = buildPassword("190601");
// 输出加密后的密码（应保存到数据库）
System.out.println(info.getPassword());
// 输出盐值（应保存到数据库）
System.out.println(info.getSalt());
}
}

71
exam-api1/src/main/java/com/yf/exam/core/utils/passwd/PassInfo.java
Unescape View File

@ -0,0 +1,71 @@
package com.yf.exam.core.utils.passwd;
/**
* 密码实体
* 用于封装密码加密后的相关信息，包括盐值和加密密码
* ClassName: PassInfo <br/>
* date: 2018年2月13日 下午7:13:50 <br/>
*
* @author Bool
* @version
*/
public class PassInfo {
/**
* 密码随机串码（盐值）
* 用于增强密码安全性的随机字符串，每个用户唯一
* 与密码拼接后进行加密，防止彩虹表攻击
*/
private String salt;
/**
* MD5后的密码
* 经过双重MD5加密（原始密码MD5 + 盐值）后的最终密码
* 存储到数据库中的加密密码
*/
private String password;
/**
* 全参数构造函数
* 用于创建包含盐值和加密密码的密码信息对象
* @param salt 密码盐值
* @param password 加密后的密码
*/
public PassInfo(String salt, String password) {
super();
this.salt = salt;
this.password = password;
}
/**
* 获取盐值
* @return 密码盐值
*/
public String getSalt() {
return salt;
}
/**
* 设置盐值
* @param salt 密码盐值
*/
public void setSalt(String salt) {
this.salt = salt;
}
/**
* 获取加密密码
* @return 加密后的密码
*/
public String getPassword() {
return password;
}
/**
* 设置加密密码
* @param password 加密后的密码
*/
public void setPassword(String password) {
this.password = password;
}
}

15
exam-api1/src/main/java/com/yf/exam/modules/Constant.java
Unescape View File

@ -0,0 +1,15 @@
package com.yf.exam.modules;
/**
* 通用常量类
* 定义系统中使用的全局常量，避免魔法值，提高代码可维护性
* @author bool
*/
public class Constant {
/**
* 会话相关常量
* 用于标识用户认证和会话管理的令牌
*/
public static final String TOKEN = "token";
}

164
exam-api1/src/main/java/com/yf/exam/modules/exam/controller/ExamController.java
Unescape View File

@ -0,0 +1,164 @@
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;
/**
* <p>
* 考试控制器
* 提供考试相关的API接口，包括考试管理、在线考试、试卷批阅等功能
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
@Api(tags={"考试"})
@RestController
@RequestMapping("/exam/api/exam/exam")
public class ExamController extends BaseController {
@Autowired
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();
}
/**
* 批量删除
* 根据ID列表批量删除考试记录
* @param reqDTO 包含要删除的考试ID列表的请求对象
* @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();
}
/**
* 查找详情
* 根据考试ID获取考试的详细信息
* @param reqDTO 包含考试ID的请求对象
* @return 考试详细信息
*/
@ApiOperation(value = "查找详情")
@RequestMapping(value = "/detail", method = { RequestMethod.POST})
public ApiRest<ExamSaveReqDTO> find(@RequestBody BaseIdReqDTO reqDTO) {
// 根据ID查询考试详情
ExamSaveReqDTO dto = baseService.findDetail(reqDTO.getId());
return super.success(dto);
}
/**
* 修改考试状态
* 批量更新考试的状态（如启用、禁用等）
* @param reqDTO 包含考试ID列表和目标状态的请求对象
* @return 操作结果
*/
@RequiresRoles("sa") // 需要超级管理员权限
@ApiOperation(value = "修改考试状态")
@RequestMapping(value = "/state", method = { RequestMethod.POST})
public ApiRest state(@RequestBody BaseStateReqDTO reqDTO) {
// 构建查询条件，匹配指定ID的考试
QueryWrapper<Exam> wrapper = new QueryWrapper<>();
wrapper.lambda().in(Exam::getId, reqDTO.getIds());
// 创建更新对象，设置新状态和更新时间
Exam exam = new Exam();
exam.setState(reqDTO.getState());
exam.setUpdateTime(new Date());
// 执行批量更新
baseService.update(exam, wrapper);
return super.success();
}
/**
* 在线考试分页查询
* 从考生视角获取可参加的考试列表（分页）
* @param reqDTO 分页查询请求参数
* @return 在线考试分页结果
*/
@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);
}
/**
* 考试管理分页查询
* 管理员视角的考试列表分页查询
* @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 待阅试卷分页结果
*/
@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);
}
}

115
exam-api1/src/main/java/com/yf/exam/modules/exam/dto/ExamDTO.java
Unescape View File

@ -0,0 +1,115 @@
package com.yf.exam.modules.exam.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 java.io.Serializable;
import java.util.Date;
/**
* <p>
* 考试数据传输类
* 考试核心数据传输对象，包含考试的基本信息和状态计算逻辑
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="考试", description="考试")
public class ExamDTO implements Serializable {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "ID", required=true)
private String id;
@ApiModelProperty(value = "考试名称", required=true)
private String title;
@ApiModelProperty(value = "考试描述", required=true)
private String content;
@ApiModelProperty(value = "1公开2部门3定员", required=true)
private Integer openType;
@ApiModelProperty(value = "考试状态", required=true)
private Integer state;
@ApiModelProperty(value = "是否限时", required=true)
private Boolean timeLimit;
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@ApiModelProperty(value = "开始时间", required=true)
private Date startTime;
@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;
/**
* 是否结束
* 动态计算考试状态，考虑时间限制和当前系统时间
* 如果考试设置了时间限制，会根据当前时间自动更新状态
* @return 计算后的考试状态
*/
public Integer getState(){
// 检查考试是否设置了时间限制
if(this.timeLimit!=null && this.timeLimit){
// 考试未开始：当前时间小于开始时间
if(System.currentTimeMillis() < startTime.getTime() ){
return ExamState.READY_START;
}
// 考试已过期：当前时间大于结束时间
if(System.currentTimeMillis() > endTime.getTime()){
return ExamState.OVERDUE;
}
// 考试进行中：当前时间在开始和结束时间之间，且考试未被禁用
if(System.currentTimeMillis() > startTime.getTime()
&& System.currentTimeMillis() < endTime.getTime()
&& !ExamState.DISABLED.equals(this.state)){
return ExamState.ENABLE;
}
}
// 如果没有时间限制或时间条件不满足，返回原始状态
return this.state;
}
}

53
exam-api1/src/main/java/com/yf/exam/modules/exam/dto/ExamDepartDTO.java
Unescape View File

@ -0,0 +1,53 @@
package com.yf.exam.modules.exam.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* <p>
* 考试部门数据传输类
* 用于表示考试与部门的关联关系，控制考试的访问权限范围
* 实现考试按部门进行权限控制的功能
* </p>
*
* @author 聪明笨狗
* @since 2020-09-03 17:24
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="考试部门", description="考试部门")
public class ExamDepartDTO implements Serializable {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* 主键ID
* 考试部门关联记录的唯一标识
*/
@ApiModelProperty(value = "ID", required=true)
private String id;
/**
* 考试ID
* 关联的考试唯一标识
*/
@ApiModelProperty(value = "考试ID", required=true)
private String examId;
/**
* 部门ID
* 关联的部门唯一标识，表示该部门可以访问对应考试
*/
@ApiModelProperty(value = "部门ID", required=true)
private String departId;
}

95
exam-api1/src/main/java/com/yf/exam/modules/exam/dto/ExamRepoDTO.java
Unescape View File

@ -0,0 +1,95 @@
package com.yf.exam.modules.exam.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* <p>
* 考试题库数据传输类
* 用于表示考试与题库的关联关系，定义考试中各题型的题目数量和分值配置
* 实现考试题目组成和评分规则的灵活配置
* </p>
*
* @author 聪明笨狗
* @since 2020-09-05 11:14
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="考试题库", description="考试题库")
public class ExamRepoDTO implements Serializable {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* 主键ID
* 考试题库关联记录的唯一标识
*/
@ApiModelProperty(value = "ID", required=true)
private String id;
/**
* 考试ID
* 关联的考试唯一标识
*/
@ApiModelProperty(value = "考试ID", required=true)
private String examId;
/**
* 题库ID
* 关联的题库唯一标识
*/
@ApiModelProperty(value = "题库ID", required=true)
private String repoId;
/**
* 单选题数量
* 从该题库中抽取的单选题数量
*/
@ApiModelProperty(value = "单选题数量", required=true)
private Integer radioCount;
/**
* 单选题分数
* 每道单选题的分值
*/
@ApiModelProperty(value = "单选题分数", required=true)
private Integer radioScore;
/**
* 多选题数量
* 从该题库中抽取的多选题数量
*/
@ApiModelProperty(value = "多选题数量", required=true)
private Integer multiCount;
/**
* 多选题分数
* 每道多选题的分值
*/
@ApiModelProperty(value = "多选题分数", required=true)
private Integer multiScore;
/**
* 判断题数量
* 从该题库中抽取的判断题数量
*/
@ApiModelProperty(value = "判断题数量", required=true)
private Integer judgeCount;
/**
* 判断题分数
* 每道判断题的分值
*/
@ApiModelProperty(value = "判断题分数", required=true)
private Integer judgeScore;
}

51
exam-api1/src/main/java/com/yf/exam/modules/exam/dto/ext/ExamRepoExtDTO.java
Unescape View File

@ -0,0 +1,51 @@
package com.yf.exam.modules.exam.dto.ext;
import com.yf.exam.modules.exam.dto.ExamRepoDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* <p>
* 考试题库数据传输类
* 扩展考试题库基础DTO，增加题目数量统计信息
* </p>
*
* @author 聪明笨狗
* @since 2020-09-05 11:14
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="考试题库扩展响应类", description="考试题库扩展响应类")
public class ExamRepoExtDTO extends ExamRepoDTO {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
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;
}

47
exam-api1/src/main/java/com/yf/exam/modules/exam/dto/request/ExamSaveReqDTO.java
Unescape View File

@ -0,0 +1,47 @@
package com.yf.exam.modules.exam.dto.request;
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 java.util.List;
/**
* <p>
* 考试保存请求类
* 用于接收考试创建或编辑时的请求数据，扩展了基础考试信息
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="考试保存请求类", description="考试保存请求类")
public class ExamSaveReqDTO extends ExamDTO {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* 题库列表
* 考试关联的题库集合，包含每个题库的题目数量统计信息
*/
@ApiModelProperty(value = "题库列表", required=true)
private List<ExamRepoExtDTO> repoList;
/**
* 考试部门列表
* 可以参加该考试的部门ID集合，用于控制考试权限范围
*/
@ApiModelProperty(value = "考试部门列表", required=true)
private List<String> departIds;
}

30
exam-api1/src/main/java/com/yf/exam/modules/exam/dto/response/ExamOnlineRespDTO.java
Unescape View File

@ -0,0 +1,30 @@
package com.yf.exam.modules.exam.dto.response;
import com.yf.exam.modules.exam.dto.ExamDTO;
import io.swagger.annotations.ApiModel;
import lombok.Data;
/**
* <p>
* 考试分页响应类
* 用于在线考试场景的分页响应数据，继承基础考试信息
* 考生视角的考试列表展示
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="在线考试分页响应类", description="在线考试分页响应类")
public class ExamOnlineRespDTO extends ExamDTO {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
}

47
exam-api1/src/main/java/com/yf/exam/modules/exam/dto/response/ExamReviewRespDTO.java
Unescape View File

@ -0,0 +1,47 @@
package com.yf.exam.modules.exam.dto.response;
import com.yf.exam.modules.exam.dto.ExamDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* <p>
* 考试分页响应类
* 用于阅卷管理场景的分页响应数据，继承基础考试信息
* 包含阅卷相关的统计信息，便于管理员进行试卷批阅管理
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="阅卷分页响应类", description="阅卷分页响应类")
public class ExamReviewRespDTO extends ExamDTO {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* 考试人数
* 参加该考试的总人数统计
*/
@ApiModelProperty(value = "考试人数", required=true)
private Integer examUser;
/**
* 待阅试卷
* 需要批阅的试卷数量，用于阅卷工作量统计
*/
@ApiModelProperty(value = "待阅试卷", required=true)
private Integer unreadPaper;
}

121
exam-api1/src/main/java/com/yf/exam/modules/exam/entity/Exam.java
Unescape View File

@ -0,0 +1,121 @@
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;
/**
* <p>
* 考试实体类
* 对应数据库表el_exam，表示考试的基本信息实体
* 使用MyBatis-Plus的ActiveRecord模式，继承Model类
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// MyBatis-Plus注解，指定对应的数据库表名
@TableName("el_exam")
public class Exam extends Model<Exam> {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* ID
* 主键字段，使用雪花算法分配ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
/**
* 考试名称
* 考试的标题名称
*/
private String title;
/**
* 考试描述
* 考试的详细描述信息
*/
private String content;
/**
* 1公开2部门3定员
* 考试开放类型：1-公开，2-部门，3-定员
*/
@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;
}

53
exam-api1/src/main/java/com/yf/exam/modules/exam/entity/ExamDepart.java
Unescape View File

@ -0,0 +1,53 @@
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;
/**
* <p>
* 考试部门实体类
* 对应数据库表el_exam_depart，表示考试与部门的关联关系
* 用于控制考试的部门访问权限，实现按部门分配考试权限
* </p>
*
* @author 聪明笨狗
* @since 2020-09-03 17:24
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// MyBatis-Plus注解，指定对应的数据库表名
@TableName("el_exam_depart")
public class ExamDepart extends Model<ExamDepart> {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* ID
* 主键字段，使用雪花算法分配ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
/**
* 考试ID
* 关联的考试唯一标识，外键关联el_exam表
*/
@TableField("exam_id")
private String examId;
/**
* 部门ID
* 关联的部门唯一标识，外键关联部门表
*/
@TableField("depart_id")
private String departId;
}

95
exam-api1/src/main/java/com/yf/exam/modules/exam/entity/ExamRepo.java
Unescape View File

@ -0,0 +1,95 @@
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;
/**
* <p>
* 考试题库实体类
* 对应数据库表el_exam_repo，表示考试与题库的关联关系
* 用于配置考试中各题型的题目数量和分值，实现灵活的考试组卷规则
* </p>
*
* @author 聪明笨狗
* @since 2020-09-05 11:14
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// MyBatis-Plus注解，指定对应的数据库表名
@TableName("el_exam_repo")
public class ExamRepo extends Model<ExamRepo> {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* ID
* 主键字段，使用雪花算法分配ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
/**
* 考试ID
* 关联的考试唯一标识，外键关联el_exam表
*/
@TableField("exam_id")
private String examId;
/**
* 题库ID
* 关联的题库唯一标识，外键关联题库表
*/
@TableField("repo_id")
private String repoId;
/**
* 单选题数量
* 从该题库中抽取的单选题数量
*/
@TableField("radio_count")
private Integer radioCount;
/**
* 单选题分数
* 每道单选题的分值
*/
@TableField("radio_score")
private Integer radioScore;
/**
* 多选题数量
* 从该题库中抽取的多选题数量
*/
@TableField("multi_count")
private Integer multiCount;
/**
* 多选题分数
* 每道多选题的分值
*/
@TableField("multi_score")
private Integer multiScore;
/**
* 判断题数量
* 从该题库中抽取的判断题数量
*/
@TableField("judge_count")
private Integer judgeCount;
/**
* 判断题分数
* 每道判断题的分值
*/
@TableField("judge_score")
private Integer judgeScore;
}

18
exam-api1/src/main/java/com/yf/exam/modules/exam/mapper/ExamDepartMapper.java
Unescape View File

@ -0,0 +1,18 @@
package com.yf.exam.modules.exam.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yf.exam.modules.exam.entity.ExamDepart;
/**
* <p>
* 考试部门Mapper
* 考试部门数据访问层接口，继承MyBatis-Plus的BaseMapper
* 提供对el_exam_depart表的CRUD操作
* </p>
*
* @author 聪明笨狗
* @since 2020-09-03 17:24
*/
public interface ExamDepartMapper extends BaseMapper<ExamDepart> {
}

50
exam-api1/src/main/java/com/yf/exam/modules/exam/mapper/ExamMapper.java
Unescape View File

@ -0,0 +1,50 @@
package com.yf.exam.modules.exam.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;
/**
* <p>
* 考试Mapper
* 考试数据访问层接口，继承MyBatis-Plus的BaseMapper
* 提供对el_exam表的CRUD操作和自定义分页查询
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
public interface ExamMapper extends BaseMapper<Exam> {
/**
* 查找分页内容
* 管理员视角的考试分页查询，用于考试管理列表
* @param page 分页参数对象
* @param query 查询条件对象
* @return 考试分页结果
*/
IPage<ExamDTO> paging(Page page, @Param("query") ExamDTO query);
/**
* 查找分页内容
* 阅卷视角的考试分页查询，用于待阅试卷列表
* @param page 分页参数对象
* @param query 查询条件对象
* @return 阅卷分页结果
*/
IPage<ExamReviewRespDTO> reviewPaging(Page page, @Param("query") ExamDTO query);
/**
* 在线考试分页响应类-考生视角
* 考生视角的在线考试分页查询，用于考生参加考试列表
* @param page 分页参数对象
* @param query 查询条件对象
* @return 在线考试分页结果
*/
IPage<ExamOnlineRespDTO> online(Page page, @Param("query") ExamDTO query);
}

29
exam-api1/src/main/java/com/yf/exam/modules/exam/mapper/ExamRepoMapper.java
Unescape View File

@ -0,0 +1,29 @@
package com.yf.exam.modules.exam.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 java.util.List;
/**
* <p>
* 考试题库Mapper
* 考试题库数据访问层接口，继承MyBatis-Plus的BaseMapper
* 提供对el_exam_repo表的CRUD操作和自定义查询
* </p>
*
* @author 聪明笨狗
* @since 2020-09-05 11:14
*/
public interface ExamRepoMapper extends BaseMapper<ExamRepo> {
/**
* 查找考试题库列表
* 根据考试ID查询关联的题库列表，包含题目数量统计信息
* @param examId 考试ID
* @return 考试题库扩展信息列表
*/
List<ExamRepoExtDTO> listByExam(@Param("examId") String examId);
}

35
exam-api1/src/main/java/com/yf/exam/modules/exam/service/ExamDepartService.java
Unescape View File

@ -0,0 +1,35 @@
package com.yf.exam.modules.exam.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yf.exam.modules.exam.entity.ExamDepart;
import java.util.List;
/**
* <p>
* 考试部门业务类
* 考试部门关联关系服务接口，定义考试与部门关联的业务操作方法
* </p>
*
* @author 聪明笨狗
* @since 2020-09-03 17:24
*/
public interface ExamDepartService extends IService<ExamDepart> {
/**
* 保存全部
* 批量保存考试与部门的关联关系，采用先删除后新增的策略
* @param examId 考试ID
* @param departs 部门ID列表
*/
void saveAll(String examId, List<String> departs);
/**
* 根据考试查找对应的部门
* 查询指定考试关联的所有部门ID列表
* @param examId 考试ID
* @return 部门ID列表
*/
List<String> listByExam(String examId);
}

43
exam-api1/src/main/java/com/yf/exam/modules/exam/service/ExamRepoService.java
Unescape View File

@ -0,0 +1,43 @@
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 java.util.List;
/**
* <p>
* 考试题库业务类
* 考试题库关联关系服务接口，定义考试与题库关联的业务操作方法
* </p>
*
* @author 聪明笨狗
* @since 2020-09-05 11:14
*/
public interface ExamRepoService extends IService<ExamRepo> {
/**
* 保存全部
* 批量保存考试与题库的关联关系，包含题目数量和分值配置
* @param examId 考试ID
* @param list 考试题库扩展信息列表
*/
void saveAll(String examId, List<ExamRepoExtDTO> list);
/**
* 查找考试题库列表
* 查询指定考试关联的所有题库信息，包含题目数量统计
* @param examId 考试ID
* @return 考试题库扩展信息列表
*/
List<ExamRepoExtDTO> listByExam(String examId);
/**
* 清理脏数据
* 清理指定考试的所有题库关联关系
* @param examId 考试ID
*/
void clear(String examId);
}

69
exam-api1/src/main/java/com/yf/exam/modules/exam/service/ExamService.java
Unescape View File

@ -0,0 +1,69 @@
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;
/**
* <p>
* 考试业务类
* 考试核心业务服务接口，定义考试相关的业务操作方法
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
public interface ExamService extends IService<Exam> {
/**
* 保存考试信息
* 创建或更新考试信息，包括基本信息、题库配置和部门权限
* @param reqDTO 考试保存请求数据传输对象
*/
void save(ExamSaveReqDTO reqDTO);
/**
* 查找考试详情
* 获取考试的完整信息，包括基本信息、部门权限和题库配置
* @param id 考试ID
* @return 考试详情响应对象
*/
ExamSaveReqDTO findDetail(String id);
/**
* 查找考试详情--简要信息
* 获取考试的基本信息，不包含关联的部门和题库信息
* @param id 考试ID
* @return 考试数据传输对象
*/
ExamDTO findById(String id);
/**
* 分页查询数据
* 管理员视角的考试分页查询，用于考试管理列表
* @param reqDTO 分页请求参数
* @return 考试分页结果
*/
IPage<ExamDTO> paging(PagingReqDTO<ExamDTO> reqDTO);
/**
* 在线考试分页响应类-考生视角
* 考生视角的在线考试分页查询，用于考生参加考试列表
* @param reqDTO 分页请求参数
* @return 在线考试分页结果
*/
IPage<ExamOnlineRespDTO> onlinePaging(PagingReqDTO<ExamDTO> reqDTO);
/**
* 待阅试卷列表
* 阅卷视角的待阅试卷分页查询，用于试卷批阅管理
* @param reqDTO 分页请求参数
* @return 待阅试卷分页结果
*/
IPage<ExamReviewRespDTO> reviewPaging(PagingReqDTO<ExamDTO> reqDTO);
}

73
exam-api1/src/main/java/com/yf/exam/modules/exam/service/impl/ExamDepartServiceImpl.java
Unescape View File

@ -0,0 +1,73 @@
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 java.util.ArrayList;
import java.util.List;
/**
* <p>
* 考试部门业务实现类
* 实现考试与部门关联关系的业务逻辑，包括批量保存和查询功能
* </p>
*
* @author 聪明笨狗
* @since 2020-09-03 17:24
*/
// Spring注解，声明为服务层组件
@Service
public class ExamDepartServiceImpl extends ServiceImpl<ExamDepartMapper, ExamDepart> implements ExamDepartService {
@Override
public void saveAll(String examId, List<String> departs) {
// 先删除该考试原有的所有部门关联
QueryWrapper<ExamDepart> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(ExamDepart::getExamId, examId);
this.remove(wrapper);
// 再增加新的部门关联
// 检查部门列表是否为空
if(CollectionUtils.isEmpty(departs)){
throw new ServiceException(1, "请至少选择选择一个部门！！");
}
// 构建要保存的考试部门关联列表
List<ExamDepart> list = new ArrayList<>();
for(String id: departs){
ExamDepart depart = new ExamDepart();
depart.setDepartId(id);
depart.setExamId(examId);
list.add(depart);
}
// 批量保存新的部门关联关系
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);
// 提取部门ID列表
List<String> ids = new ArrayList<>();
if(!CollectionUtils.isEmpty(list)){
for(ExamDepart item: list){
ids.add(item.getDepartId());
}
}
return ids;
}
}

91
exam-api1/src/main/java/com/yf/exam/modules/exam/service/impl/ExamRepoServiceImpl.java
Unescape View File

@ -0,0 +1,91 @@
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;
/**
* <p>
* 考试题库业务实现类
* 实现考试与题库关联关系的业务逻辑，包括批量保存、查询和清理功能
* </p>
*
* @author 聪明笨狗
* @since 2020-09-05 11:14
*/
// Spring注解，声明为服务层组件
@Service
public class ExamRepoServiceImpl extends ServiceImpl<ExamRepoMapper, ExamRepo> implements ExamRepoService {
/**
* 批量保存考试题库关联关系
* 采用先删除后新增的策略更新考试题库配置
* @param examId 考试ID
* @param list 考试题库扩展信息列表
*/
@Transactional(rollbackFor = Exception.class) // 事务注解，遇到任何异常都回滚
@Override
public void saveAll(String examId, List<ExamRepoExtDTO> list) {
// 先删除该考试原有的所有题库关联
QueryWrapper<ExamRepo> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(ExamRepo::getExamId, examId);
this.remove(wrapper);
// 再增加新的题库关联
// 检查题库列表是否为空
if(CollectionUtils.isEmpty(list)){
throw new ServiceException(1, "必须选择题库！");
}
// 使用BeanMapper将DTO列表转换为实体列表
List<ExamRepo> repos = BeanMapper.mapList(list, ExamRepo.class);
// 为每个实体设置考试ID和生成主键ID
for(ExamRepo item: repos){
item.setExamId(examId);
item.setId(IdWorker.getIdStr()); // 使用雪花算法生成唯一ID
}
// 批量保存新的题库关联关系
this.saveBatch(repos);
}
/**
* 根据考试ID查询关联的题库列表
* @param examId 考试ID
* @return 考试题库扩展信息列表
*/
@Override
public List<ExamRepoExtDTO> listByExam(String examId) {
// 调用Mapper层的自定义查询方法
return baseMapper.listByExam(examId);
}
/**
* 清理指定考试的题库关联关系
* @param examId 考试ID
*/
@Override
public void clear(String examId) {
// 删除该考试的所有题库关联
QueryWrapper<ExamRepo> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(ExamRepo::getExamId, examId);
this.remove(wrapper);
}
}

191
exam-api1/src/main/java/com/yf/exam/modules/exam/service/impl/ExamServiceImpl.java
Unescape View File

@ -0,0 +1,191 @@
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;
/**
* <p>
* 考试业务实现类
* 实现考试相关的核心业务逻辑，包括考试创建、编辑、查询和分页等功能
* </p>
*
* @author 聪明笨狗
* @since 2020-07-25 16:18
*/
// Spring注解，声明为服务层组件
@Service
public class ExamServiceImpl extends ServiceImpl<ExamMapper, Exam> implements ExamService {
@Autowired
private ExamRepoService examRepoService;
@Autowired
private ExamDepartService examDepartService;
@Override
public void save(ExamSaveReqDTO reqDTO) {
// ID处理：如果ID为空则生成新ID，否则使用现有ID
String id = reqDTO.getId();
if(StringUtils.isBlank(id)){
id = IdWorker.getIdStr(); // 使用雪花算法生成唯一ID
}
// 复制参数到实体对象
Exam entity = new Exam();
// 计算考试总分
this.calcScore(reqDTO);
// 复制基本数据从DTO到实体
BeanMapper.copy(reqDTO, entity);
entity.setId(id);
// 修复状态：如果考试不限时且状态为2，则重置为0
if (reqDTO.getTimeLimit()!=null
&& !reqDTO.getTimeLimit()
&& reqDTO.getState()!=null
&& reqDTO.getState() == 2) {
entity.setState(0);
} else {
entity.setState(reqDTO.getState());
}
// 保存题库组卷信息
try {
examRepoService.saveAll(id, reqDTO.getRepoList());
}catch (DuplicateKeyException e){
throw new ServiceException(1, "不能选择重复的题库！");
}
// 保存开放的部门信息（仅当开放类型为部门开放时）
if(OpenType.DEPT_OPEN.equals(reqDTO.getOpenType())){
examDepartService.saveAll(id, reqDTO.getDepartIds());
}
// 保存或更新考试实体
this.saveOrUpdate(entity);
}
@Override
public ExamSaveReqDTO findDetail(String id) {
ExamSaveReqDTO respDTO = new ExamSaveReqDTO();
// 获取考试基本信息
Exam exam = this.getById(id);
BeanMapper.copy(exam, respDTO);
// 获取考试部门关联信息
List<String> departIds = examDepartService.listByExam(id);
respDTO.setDepartIds(departIds);
// 获取题库关联信息
List<ExamRepoExtDTO> repos = examRepoService.listByExam(id);
respDTO.setRepoList(repos);
return respDTO;
}
@Override
public ExamDTO findById(String id) {
ExamDTO respDTO = new ExamDTO();
// 获取考试基本信息
Exam exam = this.getById(id);
BeanMapper.copy(exam, respDTO);
return respDTO;
}
@Override
public IPage<ExamDTO> paging(PagingReqDTO<ExamDTO> reqDTO) {
// 创建分页对象
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize());
// 转换结果：调用Mapper层分页查询
IPage<ExamDTO> pageData = baseMapper.paging(page, reqDTO.getParams());
return pageData;
}
@Override
public IPage<ExamOnlineRespDTO> onlinePaging(PagingReqDTO<ExamDTO> reqDTO) {
// 创建分页对象
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize());
// 查找分页：考生视角的在线考试列表
IPage<ExamOnlineRespDTO> pageData = baseMapper.online(page, reqDTO.getParams());
return pageData;
}
@Override
public IPage<ExamReviewRespDTO> reviewPaging(PagingReqDTO<ExamDTO> reqDTO) {
// 创建分页对象
Page page = new Page(reqDTO.getCurrent(), reqDTO.getSize());
// 查找分页：阅卷视角的待阅试卷列表
IPage<ExamReviewRespDTO> pageData = baseMapper.reviewPaging(page, reqDTO.getParams());
return pageData;
}
/**
* 计算分值
* 根据题库配置计算考试总分
* @param 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();
}
// 计算多选题总分
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();
}
}
// 设置考试总分
reqDTO.setTotalScore(objScore);
}
}

160
exam-api1/src/main/java/com/yf/exam/modules/paper/controller/PaperController.java
Unescape View File

@ -0,0 +1,160 @@
package com.yf.exam.modules.paper.controller;
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.BaseIdRespDTO;
import com.yf.exam.core.api.dto.BaseIdsReqDTO;
import com.yf.exam.core.api.dto.PagingReqDTO;
import com.yf.exam.core.utils.BeanMapper;
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;
import com.yf.exam.modules.paper.dto.request.PaperCreateReqDTO;
import com.yf.exam.modules.paper.dto.request.PaperListReqDTO;
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;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.beans.BeanUtils;
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;
/**
* <p>
* 试卷控制器
* 提供试卷相关的API接口，包括试卷创建、答题、交卷、查询等功能
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 16:33
*/
@Api(tags={"试卷"})
@RestController
@RequestMapping("/exam/api/paper/paper")
public class PaperController extends BaseController {
@Autowired
private PaperService baseService;
/**
* 分页查找
* 试卷列表分页查询，支持查询条件
* @param reqDTO 分页请求参数，包含查询条件
* @return 试卷列表分页结果
*/
@ApiOperation(value = "分页查找")
@RequestMapping(value = "/paging", method = { RequestMethod.POST})
public ApiRest<IPage<PaperListRespDTO>> paging(@RequestBody PagingReqDTO<PaperListReqDTO> reqDTO) {
//分页查询并转换
IPage<PaperListRespDTO> page = baseService.paging(reqDTO);
return super.success(page);
}
/**
* 创建试卷
* 为用户创建新的考试试卷
* @param reqDTO 创建试卷请求参数，包含考试ID
* @return 包含新创建试卷ID的响应
*/
@ApiOperation(value = "创建试卷")
@RequestMapping(value = "/create-paper", method = { RequestMethod.POST})
public ApiRest<BaseIdRespDTO> save(@RequestBody PaperCreateReqDTO reqDTO) {
//复制参数并创建试卷
String paperId = baseService.createPaper(UserUtils.getUserId(), reqDTO.getExamId());
return super.success(new BaseIdRespDTO(paperId));
}
/**
* 试卷详情
* 获取试卷的详细信息，包括考试信息和题目列表
* @param reqDTO 包含试卷ID的请求参数
* @return 试卷详情响应
*/
@ApiOperation(value = "试卷详情")
@RequestMapping(value = "/paper-detail", method = { RequestMethod.POST})
public ApiRest<ExamDetailRespDTO> paperDetail(@RequestBody BaseIdReqDTO reqDTO) {
//根据ID查询试卷详情
ExamDetailRespDTO respDTO = baseService.paperDetail(reqDTO.getId());
return super.success(respDTO);
}
/**
* 试题详情
* 获取试卷中指定试题的详细信息
* @param reqDTO 包含试卷ID和试题ID的请求参数
* @return 试题详情响应
*/
@ApiOperation(value = "试题详情")
@RequestMapping(value = "/qu-detail", method = { RequestMethod.POST})
public ApiRest<PaperQuDetailDTO> quDetail(@RequestBody PaperQuQueryDTO reqDTO) {
//根据试卷ID和试题ID查询试题详情
PaperQuDetailDTO respDTO = baseService.findQuDetail(reqDTO.getPaperId(), reqDTO.getQuId());
return super.success(respDTO);
}
/**
* 填充答案
* 保存用户对试题的答案
* @param reqDTO 包含试卷ID、试题ID和答案的请求参数
* @return 操作结果
*/
@ApiOperation(value = "填充答案")
@RequestMapping(value = "/fill-answer", method = { RequestMethod.POST})
public ApiRest<PaperQuDetailDTO> fillAnswer(@RequestBody PaperAnswerDTO reqDTO) {
//保存用户答案
baseService.fillAnswer(reqDTO);
return super.success();
}
/**
* 交卷操作
* 用户完成考试并提交试卷
* @param reqDTO 包含试卷ID的请求参数
* @return 操作结果
*/
@ApiOperation(value = "交卷操作")
@RequestMapping(value = "/hand-exam", method = { RequestMethod.POST})
public ApiRest<PaperQuDetailDTO> handleExam(@RequestBody BaseIdReqDTO reqDTO) {
//执行交卷操作
baseService.handExam(reqDTO.getId());
return super.success();
}
/**
* 试卷结果
* 获取试卷的考试结果，包括得分和答题情况
* @param reqDTO 包含试卷ID的请求参数
* @return 试卷结果响应
*/
@ApiOperation(value = "试卷结果")
@RequestMapping(value = "/paper-result", method = { RequestMethod.POST})
public ApiRest<ExamResultRespDTO> paperResult(@RequestBody BaseIdReqDTO reqDTO) {
//根据ID查询试卷结果
ExamResultRespDTO respDTO = baseService.paperResult(reqDTO.getId());
return super.success(respDTO);
}
/**
* 检测用户有没有中断的考试
* 检查当前用户是否有未完成的考试试卷
* @return 进行中的试卷信息，如果没有则返回null
*/
@ApiOperation(value = "检测进行中的考试")
@RequestMapping(value = "/check-process", method = { RequestMethod.POST})
public ApiRest<PaperDTO> checkProcess() {
//检查用户是否有未完成的考试
PaperDTO dto = baseService.checkProcess(UserUtils.getUserId());
return super.success(dto);
}
}

150
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/PaperDTO.java
Unescape View File

@ -0,0 +1,150 @@
package com.yf.exam.modules.paper.dto;
import com.yf.exam.core.annon.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 试卷请求类
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷", description="试卷")
public class PaperDTO implements Serializable {
/**
* 序列化版本UID，用于保证序列化时的版本一致性
* 在反序列化时验证序列化对象的版本是否与当前类定义兼容
*/
private static final long serialVersionUID = 1L;
/**
* 试卷唯一标识ID
* 在系统中唯一标识一份试卷
*/
@ApiModelProperty(value = "试卷ID", required=true)
private String id;
/**
* 用户ID，关联系统用户表
* 使用字典注解关联sys_user表，显示用户真实姓名
*/
@Dict(dictTable = "sys_user", dicText = "real_name", dicCode = "id")
@ApiModelProperty(value = "用户ID", required=true)
private String userId;
/**
* 部门ID，关联系统部门表
* 使用字典注解关联sys_depart表，显示部门名称
*/
@Dict(dictTable = "sys_depart", dicText = "dept_name", dicCode = "id")
@ApiModelProperty(value = "部门ID", required=true)
private String departId;
/**
* 考试规则ID，关联考试规则表
* 标识该试卷所属的考试规则
*/
@ApiModelProperty(value = "规则ID", required=true)
private String examId;
/**
* 考试标题
* 试卷的名称或标题信息
*/
@ApiModelProperty(value = "考试标题", required=true)
private String title;
/**
* 考试总时长（单位：分钟）
* 规定的考试完成时间限制
*/
@ApiModelProperty(value = "考试时长", required=true)
private Integer totalTime;
/**
* 用户实际使用时长（单位：分钟）
* 考生完成考试实际花费的时间
*/
@ApiModelProperty(value = "用户时长", required=true)
private Integer userTime;
/**
* 试卷总分
* 该试卷所有题目的总分数
*/
@ApiModelProperty(value = "试卷总分", required=true)
private Integer totalScore;
/**
* 及格分数线
* 考试通过所需的最低分数
*/
@ApiModelProperty(value = "及格分", required=true)
private Integer qualifyScore;
/**
* 客观题总分
* 选择题、判断题等客观题的总分数
*/
@ApiModelProperty(value = "客观分", required=true)
private Integer objScore;
/**
* 主观题总分
* 简答题、论述题等主观题的总分数
*/
@ApiModelProperty(value = "主观分", required=true)
private Integer subjScore;
/**
* 用户得分
* 考生在该试卷中获得的实际分数
*/
@ApiModelProperty(value = "用户得分", required=true)
private Integer userScore;
/**
* 是否包含简答题
* true表示包含简答题，false表示不包含
*/
@ApiModelProperty(value = "是否包含简答题", required=true)
private Boolean hasSaq;
/**
* 试卷状态
* 用于标识试卷的当前状态（如：未开始、进行中、已提交、已批改等）
*/
@ApiModelProperty(value = "试卷状态", required=true)
private Integer state;
/**
* 试卷创建时间
* 记录试卷的生成时间
*/
@ApiModelProperty(value = "创建时间", required=true)
private Date createTime;
/**
* 试卷最后更新时间
* 记录试卷信息的最后修改时间
*/
@ApiModelProperty(value = "更新时间", required=true)
private Date updateTime;
/**
* 考试截止时间
* 试卷提交的最后期限，可为空表示无截止时间限制
*/
@ApiModelProperty(value = "截止时间")
private Date limitTime;
}

86
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/PaperQuAnswerDTO.java
Unescape View File

@ -0,0 +1,86 @@
package com.yf.exam.modules.paper.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* <p>
* 试卷考题备选答案请求类
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")
public class PaperQuAnswerDTO implements Serializable {
/**
* 序列化版本UID，用于保证序列化时的版本一致性
* 在反序列化时验证序列化对象的版本是否与当前类定义兼容
*/
private static final long serialVersionUID = 1L;
/**
* 自增主键ID
* 唯一标识每条试卷考题备选答案记录
*/
@ApiModelProperty(value = "自增ID", required=true)
private String id;
/**
* 试卷ID
* 关联所属的试卷，标识该备选答案属于哪份试卷
*/
@ApiModelProperty(value = "试卷ID", required=true)
private String paperId;
/**
* 回答项ID
* 关联具体的答案选项，标识具体的答案内容
*/
@ApiModelProperty(value = "回答项ID", required=true)
private String answerId;
/**
* 题目ID
* 关联所属的题目，标识该备选答案属于哪道题目
*/
@ApiModelProperty(value = "题目ID", required=true)
private String quId;
/**
* 是否为正确答案
* true表示该选项是正确答案，false表示不是正确答案
* 用于客观题的标准答案判定
*/
@ApiModelProperty(value = "是否正确项", required=true)
private Boolean isRight;
/**
* 用户是否选中该选项
* true表示用户在答题时选择了该选项，false表示未选择
* 记录用户的实际答题选择
*/
@ApiModelProperty(value = "是否选中", required=true)
private Boolean checked;
/**
* 选项排序号
* 控制选项在界面上的显示顺序，数值越小显示越靠前
*/
@ApiModelProperty(value = "排序", required=true)
private Integer sort;
/**
* 选项标签
* 用于标识选项的字母标签，如A、B、C、D等
* 在界面上显示为选项的前缀标识
*/
@ApiModelProperty(value = "选项标签", required=true)
private String abc;
}

102
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/PaperQuDTO.java
Unescape View File

@ -0,0 +1,102 @@
package com.yf.exam.modules.paper.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* <p>
* 试卷考题请求类
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷考题", description="试卷考题")
public class PaperQuDTO implements Serializable {
/**
* 序列化版本UID，用于保证序列化时的版本一致性
* 在反序列化时验证序列化对象的版本是否与当前类定义兼容
*/
private static final long serialVersionUID = 1L;
/**
* 主键ID
* 唯一标识试卷中的每道题目记录
*/
@ApiModelProperty(value = "ID", required=true)
private String id;
/**
* 试卷ID
* 关联所属的试卷，标识该题目属于哪份试卷
*/
@ApiModelProperty(value = "试卷ID", required=true)
private String paperId;
/**
* 题目ID
* 关联题库中的原始题目，标识该题目的具体内容
*/
@ApiModelProperty(value = "题目ID", required=true)
private String quId;
/**
* 题目类型
* 标识题目的类型，如单选题、多选题、判断题、简答题等
* 使用数字代码表示不同的题目类型
*/
@ApiModelProperty(value = "题目类型", required=true)
private Integer quType;
/**
* 是否已答题
* true表示用户已经回答了该题目，false表示未回答
* 用于标识题目的答题状态
*/
@ApiModelProperty(value = "是否已答", required=true)
private Boolean answered;
/**
* 主观题答案内容
* 存储用户对于主观题（如简答题、论述题）的文本答案
* 对于客观题，此字段可能为空或存储其他信息
*/
@ApiModelProperty(value = "主观答案", required=true)
private String answer;
/**
* 题目在试卷中的排序号
* 控制题目在试卷中的显示顺序，数值越小显示越靠前
*/
@ApiModelProperty(value = "问题排序", required=true)
private Integer sort;
/**
* 单题分值
* 该题目在试卷中的满分分值
*/
@ApiModelProperty(value = "单题分分值", required=true)
private Integer score;
/**
* 实际得分（主要用于主观题）
* 阅卷老师给该题目评定的实际得分
* 对于客观题，系统会自动计算得分
*/
@ApiModelProperty(value = "实际得分(主观题)", required=true)
private Integer actualScore;
/**
* 是否答对（主要用于客观题）
* true表示该题目回答正确，false表示回答错误
* 对于主观题，此字段可能为空或根据得分判断
*/
@ApiModelProperty(value = "是否答对", required=true)
private Boolean isRight;
}

45
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuAnswerExtDTO.java
Unescape View File

@ -0,0 +1,45 @@
package com.yf.exam.modules.paper.dto.ext;
import com.yf.exam.modules.paper.dto.PaperQuAnswerDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* <p>
* 试卷考题备选答案请求类
* 扩展试卷考题答案基础DTO，增加试题图片和答案内容信息
* 用于前端展示试题的完整信息和备选答案
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="试卷考题备选答案", description="试卷考题备选答案")
public class PaperQuAnswerExtDTO extends PaperQuAnswerDTO {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* 试题图片
* 试题相关的图片URL，用于图文并茂的题目展示
*/
@ApiModelProperty(value = "试题图片", required=true)
private String image;
/**
* 答案内容
* 备选答案的具体文本内容
*/
@ApiModelProperty(value = "答案内容", required=true)
private String content;
}

52
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/ext/PaperQuDetailDTO.java
Unescape View File

@ -0,0 +1,52 @@
package com.yf.exam.modules.paper.dto.ext;
import com.yf.exam.modules.paper.dto.PaperQuDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* <p>
* 试卷考题请求类
* 扩展试卷考题基础DTO，增加题目内容、图片和备选答案列表
* 用于前端展示试题的完整信息和答题选项
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="试卷题目详情类", description="试卷题目详情类")
public class PaperQuDetailDTO extends PaperQuDTO {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* 图片
* 试题相关的图片URL，用于图文并茂的题目展示
*/
@ApiModelProperty(value = "图片", required=true)
private String image;
/**
* 题目内容
* 试题的正文内容，描述题目的具体问题
*/
@ApiModelProperty(value = "题目内容", required=true)
private String content;
/**
* 答案内容
* 试题的备选答案列表，包含所有可能的选项
*/
@ApiModelProperty(value = "答案内容", required=true)
List<PaperQuAnswerExtDTO> answerList;
}

35
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/request/PaperAnswerDTO.java
Unescape View File

@ -0,0 +1,35 @@
package com.yf.exam.modules.paper.dto.request;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* 试卷答题请求数据传输类
* 用于接收用户提交的试题答案信息，继承试题查询基础类
* 支持客观题答案列表和主观题答案文本两种答题方式
* @author bool
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")
public class PaperAnswerDTO extends PaperQuQueryDTO {
/**
* 回答列表
* 用于客观题（多选题等）的答案，存储用户选择的多个选项
*/
@ApiModelProperty(value = "回答列表", required=true)
private List<String> answers;
/**
* 主观答案
* 用于主观题（填空题、简答题等）的答案，存储用户输入的文本内容
*/
@ApiModelProperty(value = "主观答案", required=true)
private String answer;
}

36
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/request/PaperCreateReqDTO.java
Unescape View File

@ -0,0 +1,36 @@
package com.yf.exam.modules.paper.dto.request;
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;
/**
* 试卷创建请求数据传输类
* 用于接收创建新试卷的请求参数，包含考试ID和用户ID信息
* 用户ID通过安全上下文自动设置，不暴露给前端
* @author bool
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="试卷创建请求类", description="试卷创建请求类")
public class PaperCreateReqDTO extends BaseDTO {
/**
* 用户ID
* 使用JsonIgnore注解，在JSON序列化时忽略此字段
* 通常在后端通过安全上下文自动设置，避免前端传递
*/
@JsonIgnore
private String userId;
/**
* 考试ID
* 要创建试卷对应的考试唯一标识
*/
@ApiModelProperty(value = "考试ID", required=true)
private String examId;
}

67
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/request/PaperListReqDTO.java
Unescape View File

@ -0,0 +1,67 @@
package com.yf.exam.modules.paper.dto.request;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* <p>
* 试卷请求类
* 用于试卷列表查询的请求参数封装，支持多条件筛选
* 包含用户信息、部门信息、考试信息和试卷状态等查询条件
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="试卷", description="试卷")
public class PaperListReqDTO implements Serializable {
/**
* 序列化版本UID
* 用于保证序列化的一致性
*/
private static final long serialVersionUID = 1L;
/**
* 用户ID
* 查询指定用户的试卷记录
*/
@ApiModelProperty(value = "用户ID", required=true)
private String userId;
/**
* 部门ID
* 按部门筛选试卷，用于权限控制
*/
@ApiModelProperty(value = "部门ID", required=true)
private String departId;
/**
* 规则ID
* 查询指定考试的试卷记录
*/
@ApiModelProperty(value = "规则ID", required=true)
private String examId;
/**
* 用户昵称
* 按用户真实姓名模糊查询试卷
*/
@ApiModelProperty(value = "用户昵称", required=true)
private String realName;
/**
* 试卷状态
* 按试卷状态筛选，如进行中、已交卷、已批阅等
*/
@ApiModelProperty(value = "试卷状态", required=true)
private Integer state;
}

34
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/request/PaperQuQueryDTO.java
Unescape View File

@ -0,0 +1,34 @@
package com.yf.exam.modules.paper.dto.request;
import com.yf.exam.core.api.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* 试卷题目详情查询请求数据传输类
* 用于查询指定试卷中特定题目的详细信息
* 包含试卷ID和题目ID两个必要参数，精确定位要查询的题目
* @author bool
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="查找试卷题目详情请求类", description="查找试卷题目详情请求类")
public class PaperQuQueryDTO extends BaseDTO {
/**
* 试卷ID
* 要查询题目所属的试卷唯一标识
*/
@ApiModelProperty(value = "试卷ID", required=true)
private String paperId;
/**
* 题目ID
* 要查询的具体题目唯一标识
*/
@ApiModelProperty(value = "题目ID", required=true)
private String quId;
}

61
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/response/ExamDetailRespDTO.java
Unescape View File

@ -0,0 +1,61 @@
package com.yf.exam.modules.paper.dto.response;
import com.yf.exam.modules.paper.dto.PaperDTO;
import com.yf.exam.modules.paper.dto.PaperQuDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.Calendar;
import java.util.List;
/**
* 考试详情响应数据传输类
* 扩展试卷基础信息，包含按题型分类的题目列表和考试剩余时间计算
* 用于前端展示考试详情页面，支持按题型分组显示题目
*/
// 使用Lombok注解自动生成getter、setter等方法
@Data
// Swagger注解，用于API文档生成，定义模型名称和描述
@ApiModel(value="考试详情", description="考试详情")
public class ExamDetailRespDTO extends PaperDTO {
/**
* 单选题列表
* 试卷中所有单选题的集合
*/
@ApiModelProperty(value = "单选题列表", required=true)
private List<PaperQuDTO> radioList;
/**
* 多选题列表
* 试卷中所有多选题的集合
*/
@ApiModelProperty(value = "多选题列表", required=true)
private List<PaperQuDTO> multiList;
/**
* 判断题列表
* 试卷中所有判断题的集合
*/
@ApiModelProperty(value = "判断题", required=true)
private List<PaperQuDTO> judgeList;
/**
* 获取剩余结束秒数
* 动态计算考试剩余时间，基于试卷创建时间和总时长
* @return 距离考试结束的剩余秒数
*/
@ApiModelProperty(value = "剩余结束秒数", required=true)
public Long getLeftSeconds(){
// 计算考试结束时间：创建时间 + 总时长（分钟）
Calendar cl = Calendar.getInstance();
cl.setTime(this.getCreateTime());
cl.add(Calendar.MINUTE, getTotalTime());
// 计算剩余时间：（结束时间 - 当前时间）转换为秒
return (cl.getTimeInMillis() - System.currentTimeMillis()) / 1000;
}
}

28
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/response/ExamResultRespDTO.java
Unescape View File

@ -0,0 +1,28 @@
package com.yf.exam.modules.paper.dto.response;
import com.yf.exam.modules.paper.dto.PaperDTO;
import com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* 考试结果展示响应数据传输对象
* 用于封装考试结束后向客户端返回的详细考试结果信息
* 继承自PaperDTO，包含试卷基本信息，并扩展了题目详情列表
*/
@Data
@ApiModel(value="考试结果展示响应类", description="考试结果展示响应类")
public class ExamResultRespDTO extends PaperDTO {
/**
* 试卷中所有题目的详细信息列表
* 包含每道题目的内容、选项、用户答案、标准答案、得分等详细信息
* 该字段在考试结果展示时为必需数据
*/
@ApiModelProperty(value = "问题列表", required=true)
private List<PaperQuDetailDTO> quList;
}

35
exam-api1/src/main/java/com/yf/exam/modules/paper/dto/response/PaperListRespDTO.java
Unescape View File

@ -0,0 +1,35 @@
package com.yf.exam.modules.paper.dto.response;
import com.yf.exam.modules.paper.dto.PaperDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* <p>
* 试卷请求类
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
@Data
@ApiModel(value="试卷列表响应类", description="试卷列表响应类")
public class PaperListRespDTO extends PaperDTO {
/**
* 序列化版本UID，用于保证序列化时的版本一致性
* 在反序列化时验证序列化对象的版本是否与当前类定义兼容
*/
private static final long serialVersionUID = 1L;
/**
* 考试人员的真实姓名
* 用于在试卷列表中显示考生的真实身份信息，而非用户名或昵称
* 该字段在响应中为必需字段，不能为空
*/
@ApiModelProperty(value = "人员", required=true)
private String realName;
}

164
exam-api1/src/main/java/com/yf/exam/modules/paper/entity/Paper.java
Unescape View File

@ -0,0 +1,164 @@
package com.yf.exam.modules.paper.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;
/**
* <p>
* 试卷实体类
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
@Data
@TableName("el_paper")
public class Paper extends Model<Paper> {
/**
* 序列化版本UID，用于保证序列化时的版本一致性
* 在反序列化时验证序列化对象的版本是否与当前类定义兼容
*/
private static final long serialVersionUID = 1L;
/**
* 试卷ID
* 使用MyBatis-Plus的雪花算法分配ID，保证全局唯一性
* 对应数据库表el_paper的主键字段
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
/**
* 用户ID
* 参加考试的用户唯一标识，关联用户表
* 对应数据库表中的user_id字段
*/
@TableField("user_id")
private String userId;
/**
* 部门ID
* 用户所属的部门标识，关联部门表
* 对应数据库表中的depart_id字段
*/
@TableField("depart_id")
private String departId;
/**
* 规则ID
* 关联考试规则表，标识该试卷遵循的考试规则
* 对应数据库表中的exam_id字段
*/
@TableField("exam_id")
private String examId;
/**
* 考试标题
* 试卷的名称或标题，描述考试内容
* 直接对应数据库表中的title字段
*/
private String title;
/**
* 考试时长
* 规定的考试总时间，单位通常为分钟
* 对应数据库表中的total_time字段
*/
@TableField("total_time")
private Integer totalTime;
/**
* 用户时长
* 用户实际使用的考试时间，单位通常为分钟
* 对应数据库表中的user_time字段
*/
@TableField("user_time")
private Integer userTime;
/**
* 试卷总分
* 该试卷所有题目的总分数
* 对应数据库表中的total_score字段
*/
@TableField("total_score")
private Integer totalScore;
/**
* 及格分
* 考试通过所需的最低分数要求
* 对应数据库表中的qualify_score字段
*/
@TableField("qualify_score")
private Integer qualifyScore;
/**
* 客观分
* 试卷中客观题部分的总分数
* 对应数据库表中的obj_score字段
*/
@TableField("obj_score")
private Integer objScore;
/**
* 主观分
* 试卷中主观题部分的总分数
* 对应数据库表中的subj_score字段
*/
@TableField("subj_score")
private Integer subjScore;
/**
* 用户得分
* 用户在该试卷中获得的实际总分
* 对应数据库表中的user_score字段
*/
@TableField("user_score")
private Integer userScore;
/**
* 是否包含简答题
* true表示试卷中包含简答题，false表示不包含
* 对应数据库表中的has_saq字段
*/
@TableField("has_saq")
private Boolean hasSaq;
/**
* 试卷状态
* 标识试卷的当前状态，如未开始、进行中、已提交、已批改等
* 使用数字代码表示不同的状态
* 直接对应数据库表中的state字段
*/
private Integer state;
/**
* 创建时间
* 试卷记录的创建时间，通常为开始考试的时间
* 对应数据库表中的create_time字段
*/
@TableField("create_time")
private Date createTime;
/**
* 更新时间
* 试卷记录的最后更新时间，包括答题、提交、批改等操作
* 对应数据库表中的update_time字段
*/
@TableField("update_time")
private Date updateTime;
/**
* 截止时间
* 考试提交的截止时间，超过该时间将不能提交
* 对应数据库表中的limit_time字段
*/
@TableField("limit_time")
private Date limitTime;
}

109
exam-api1/src/main/java/com/yf/exam/modules/paper/entity/PaperQu.java
Unescape View File

@ -0,0 +1,109 @@
package com.yf.exam.modules.paper.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;
/**
* <p>
* 试卷考题实体类
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
@Data
@TableName("el_paper_qu")
public class PaperQu extends Model<PaperQu> {
/**
* 序列化版本UID，用于保证序列化时的版本一致性
* 在反序列化时验证序列化对象的版本是否与当前类定义兼容
*/
private static final long serialVersionUID = 1L;
/**
* 主键ID
* 使用MyBatis-Plus的雪花算法分配ID，保证全局唯一性
* 对应数据库表el_paper_qu的主键字段
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
/**
* 试卷ID
* 关联所属的试卷，标识该题目属于哪份试卷
* 对应数据库表中的paper_id字段
*/
@TableField("paper_id")
private String paperId;
/**
* 题目ID
* 关联题库中的原始题目，标识该题目的具体内容
* 对应数据库表中的qu_id字段
*/
@TableField("qu_id")
private String quId;
/**
* 题目类型
* 标识题目的类型，如单选题、多选题、判断题、简答题等
* 使用数字代码表示不同的题目类型
* 对应数据库表中的qu_type字段
*/
@TableField("qu_type")
private Integer quType;
/**
* 是否已答题
* true表示用户已经回答了该题目，false表示未回答
* 用于标识题目的答题状态
* 直接对应数据库表中的answered字段
*/
private Boolean answered;
/**
* 主观题答案内容
* 存储用户对于主观题（如简答题、论述题）的文本答案
* 对于客观题，此字段可能为空或存储其他信息
* 直接对应数据库表中的answer字段
*/
private String answer;
/**
* 题目在试卷中的排序号
* 控制题目在试卷中的显示顺序，数值越小显示越靠前
* 直接对应数据库表中的sort字段
*/
private Integer sort;
/**
* 单题分值
* 该题目在试卷中的满分分值
* 直接对应数据库表中的score字段
*/
private Integer score;
/**
* 实际得分（主要用于主观题）
* 阅卷老师给该题目评定的实际得分
* 对于客观题，系统会自动计算得分
* 对应数据库表中的actual_score字段
*/
@TableField("actual_score")
private Integer actualScore;
/**
* 是否答对（主要用于客观题）
* true表示该题目回答正确，false表示回答错误
* 对于主观题，此字段可能为空或根据得分判断
* 对应数据库表中的is_right字段
*/
@TableField("is_right")
private Boolean isRight;
}

86
exam-api1/src/main/java/com/yf/exam/modules/paper/entity/PaperQuAnswer.java
Unescape View File

@ -0,0 +1,86 @@
package com.yf.exam.modules.paper.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;
/**
* <p>
* 试卷考题备选答案实体类
* </p>
*
* @author 聪明笨狗
* @since 2020-05-25 17:31
*/
@Data
@TableName("el_paper_qu_answer")
public class PaperQuAnswer extends Model<PaperQuAnswer> {
/**
* 自增主键ID
* 使用MyBatis-Plus的雪花算法分配ID，保证全局唯一性
* 对应数据库表el_paper_qu_answer的主键字段
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private String id;
/**
* 试卷ID
* 关联所属的试卷，标识该备选答案属于哪份试卷
* 对应数据库表中的paper_id字段
*/
@TableField("paper_id")
private String paperId;
/**
* 回答项ID
* 关联具体的答案选项，标识具体的答案内容
* 对应数据库表中的answer_id字段
*/
@TableField("answer_id")
private String answerId;
/**
* 题目ID
* 关联所属的题目，标识该备选答案属于哪道题目
* 对应数据库表中的qu_id字段
*/
@TableField("qu_id")
private String quId;
/**
* 是否为正确答案
* true表示该选项是正确答案，false表示不是正确答案
* 用于客观题的标准答案判定
* 对应数据库表中的is_right字段
*/
@TableField("is_right")
private Boolean isRight;
/**
* 用户是否选中该选项
* true表示用户在答题时选择了该选项，false表示未选择
* 记录用户的实际答题选择
* 直接对应数据库表中的checked字段
*/
private Boolean checked;
/**
* 选项排序号
* 控制选项在界面上的显示顺序，数值越小显示越靠前
* 直接对应数据库表中的sort字段
*/
private Integer sort;
/**
* 选项标签
* 用于标识选项的字母标签，如A、B、C、D等
* 在界面上显示为选项的前缀标识
* 直接对应数据库表中的abc字段
*/
private String abc;
}

40
exam-api1/src/main/java/com/yf/exam/modules/paper/enums/ExamState.java
Unescape View File

@ -0,0 +1,40 @@
package com.yf.exam.modules.paper.enums;
/**
* 考试状态
* @author bool
* @date 2019-10-30 13:11
*/
public interface ExamState {
/**
* 考试中
* 表示考试正在进行中，考生可以正常答题
* 对应试卷的活跃状态
*/
Integer ENABLE = 0;
/**
* 待阅卷
* 表示考试已结束，但主观题部分需要人工批阅
* 适用于包含简答题、论述题等主观题的试卷
*/
Integer DISABLED = 1;
/**
* 已完成
* 表示考试已完成且所有题目都已批阅完成
* 包括客观题自动批阅和主观题人工批阅均已完成
*/
Integer READY_START = 2;
/**
* 已结束
* 表示考试已超过截止时间或已强制结束
* 考生不能再进行答题操作
*/
Integer OVERDUE = 3;
}

41
exam-api1/src/main/java/com/yf/exam/modules/paper/enums/PaperState.java
Unescape View File

@ -0,0 +1,41 @@
package com.yf.exam.modules.paper.enums;
/**
* 试卷状态
* @author bool
* @date 2019-10-30 13:11
*/
public interface PaperState {
/**
* 考试中
* 表示试卷处于正在进行考试的状态
* 考生可以正常答题，考试时间尚未结束
*/
Integer ING = 0;
/**
* 待阅卷
* 表示试卷已提交，但需要人工批阅主观题部分
* 适用于包含简答题、论述题等需要人工评分的题目
*/
Integer WAIT_OPT = 1;
/**
* 已完成
* 表示试卷已完成所有批阅流程
* 包括客观题自动批阅和主观题人工批阅均已完成
* 考生可以查看最终成绩和考试结果
*/
Integer FINISHED = 2;
/**
* 弃考
* 表示考生主动放弃考试或未在规定时间内完成考试
* 考试记录会被标记为弃考状态
*/
Integer BREAK = 3;
}

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

Write Preview
Loading…
Cancel
Save