Skip to content

C
chnmuseum-party
Commit d9c5bb47 authored by liqin's avatar liqin 💬
Browse files
Options

bug fixed

parent 27336103
Show whitespace changes
Inline Side-by-side
Showing with 1170 additions and 609 deletions
src/main/java/cn/wisenergy/chnmuseum/party/common/enum/RESPONSE_CODE_ENUM.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.datastation.common.core.utils.exception;
/**
* 响应编码
*/
public enum RESPONSE_CODE_ENUM {
/* ******************** 系统异常 ********************* */
PARAM_NOT_VALID("400", "请求的参数不合法"),
RESOURCE_NOT_FOUND("404", "请求的资源不存在"),
METHOD_NOT_SUPPORTED("405", "不支持的请求方法"),
MEDIA_TYPE_NOT_ACCEPT("406", "无法接受请求中的媒体类型"),
MEDIA_TYPE_NOT_SUPPORTED("415", "不支持的媒体类型"),
SERVER_ERROR("500", "服务异常"),
/* ******************** 业务自定义异常 **************** */
REQUEST_PARAMS_ERROR("1001", "参数异常"),
GAIN_DATA_FAIL("1003", "获取数据失败"),
UPLOAD_FAILURE("1005", "上传失败"),
AZKABAN_PROJECT_REPEAT("1006", "工程名重复"),
HBASE_IOEXCEPTION("1008", "连接hbase异常"),
CREATE_FLOW_PROJECT_ERROR("1009", "业务流程名称重复"),
CREATE_FLOW_NODE_ERROR("1010", "业务节点名称重复"),
FLUME_AGENT_ERROR("1011", "agent名称重复"),
FLUME_AGENT_RUNNING("1012", "agent正在运行，不可操作"),
PARAMETER_PARSING_FAILED("1013", "参数解析失败"),
EMPTY_NODE_LIST_RUN_FAILED("1014", "节点集合为空，运行失败"),
FLOW_RESOURCE_REPEAT("1015", "目录下，有重名资源"),
FILE_SYSTEM_FILE_NOEXIST("1016", "目录不存在"),
FILE_SYSTEM_FILE_EXCEPTION("1017", "访问异常"),
EMPTY_NODE_RUN_FAILED("1018", "-节点内容为空"),
EMPTY_NODE_LIST_SAVE_FAILED("1019", "节点集合为空，保存失败"),
CANCEL_FLOW_CHAIN_FAILED("1020", "正在更新工作流程链，请稍后刷新页面"),
TEMPORARY_QUERY_NAME_REPEAT("1021", "hive查询任务重名"),
DATA_SYNC_NODE_CHECK_ERROR("1022", "数据同步节点配置错误"),
HIVE_UPLOAD_FILE_INCORRECT("1028", "文件类型不支持"),
SCHEDULE_FLOW_EXEC_REPEAT("1029", "业务流程的定时任务启动重复"),
NAME_REPEAT("1030", "名称重复"),
CODE_REPEAT("1031", "编码重复"),
MODEL_RELEASE_ERROR("1032", "已为发布状态，不能发布"),
MODEL_OFFLINE_ERROR("1033", "被占用，不能下线"),
MODEL_DELETE_ERROR("1034", "发布状态，不能删除"),
DIMENSION_TABLE_DATABASE_INFO_ERROR("1035", "维度表数据源信息是必须的"),
DIMENSION_TABLE_CREATE_TABLE_ERROR("1036", "维度表创建失败"),
FACT_ATTRIBUTES_CHECK_ERROR("1037", "事实表属性必须包含时间数据类型"),
FACT_TABLES_CREATE_TABLE_ERROR("1038", "事实表创建失败"),
FACT_TABLES_DATABASE_INFO_ERROR("1039", "事实表数据源信息是必须的"),
AGGREGATION_TABLE_DATABASE_INFO_ERROR("1040", "汇总表数据源信息是必须的"),
AGGREGATION_TABLE_CREATE_TABLE_ERROR("1041", "汇总表创建失败"),
AGGREGATION_ATTRIBUTES_CHECK_ERROR("1042", "汇总表必须配置时间周期和指标"),
MODEL_CREATE_ERROR("1043", "创建失败"),
MODEL_OFFLINE_STATUS_ERROR("1044", "当前状态为非发布状态，不允许下线"),
FIELD_NAME_ID_REPEAT_ERROR("1045", "字段名称id不允许重复"),
ASSET_LABEL_DELETE_ERROR("1046", "标签为引用状态,不能删除"),
QUALITY_JOB_NOT_EXIST("1047", "质量作业不存在"),
SYSTEM_TEMPLATE_NOT_OPERATIONAL_ERROR("1048", "系统模板不可操作"),
QUALITY_JOB_RUNNING_NOT_DELETE("1049", "质量作业正在运行，不能删除"),
QUALITY_RULE_SQL_SEMANTIC_VERIFICATION_ERROR("1050", "语义校验失败，请检查。"),
QUALITY_JOB_PERIOD_CRON_NOT_EXIST("1051", "CRON表达式不存在"),
QUALITY_JOB_RUN_TASK_NOT_FIND("1052", "找不到要停止的质量作业任务"),
OUTPUT_SHOW_WITH_SQL_NOT_MATCH_ERROR("1053", "输出结果说明与定义关系不匹配"),
LACK_A_PRIMARY_KEY_ERROR("1054", "至少包含一个主键属性"),
QUALITY_JOB_RUN_ERROR("1055", "启动质量作业失败，请检查质量作业参数..."),
ILLEGAL_OPERATION("1400", "违规操作"),
BUSINESS_OBJECT_NAME_REGEX_CHECK_ERROR("1500", "只允许除右斜杠、<、>、/外的字符"),
/* ******************** 登录权限 **************** */
USER_NAME_REPEAT("1101", "账户已存在"),
LOGIN_INCORRECT("1102", "登录异常"),
LOGIN_NOT_EXISTS("1103", "账户不存在"),
LOGIN_PWD_INCORRECT("1104", "账户或密码不正确"),
NOT_LOGIN_ERROR("1105", "重新登录"),
OLD_PASSWORD_INCORRECT("1106", "旧密码不正确"),
ACCOUNT_HAS_BEEN_DISABLED("1107", "此账号已被禁用"),
ACCOUNT_IS_LOCKED("1108", "此账号已被锁定，请稍后再试"),
ACCOUNT_AUTHENTICATION_FAILED("1109", "账号认证失败"),
UNAUTHORIZED("1110", "权限不足"),
ROLE_CODE_REPEAT("1111", "角色编码已存在"),
SYS_ROLE_DELETE_FAIL("1112", "系统角色不允许删除"),
SYS_MENU_DELETE_FAIL("1113", "还存在子菜单，不能直接删除"),
/* ******************** 操作失败 **************** */
REQUEST_FAIL("1100", "操作失败"),
/* ******************** 操作成功 **************** */
REQUEST_SUCCESS("200", "操作成功");
// 错误编码
private String code;
// 错误信息
private String msg;
// 相应编码有参构造函数
RESPONSE_CODE_ENUM(String code, String msg) {
this.code = code;
this.msg = msg;
}
/**
* 获取编码
*/
public String getCode() {
return code;
}
/**
* 设置编码
*/
public void setCode(String code) {
this.code = code;
}
/**
* 获取编码信息
*/
public String getMsg() {
return msg;
}
/**
* 设置编码信息
*/
public void setMsg(String msg) {
this.msg = msg;
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/enum/RESULT_INFO_ENUM.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.datastation.common.core.enums;
/**
* 响应结果信息枚举
*
* @author mxy
* @date 2020/3/30
*/
public enum RESULT_INFO_ENUM {
RESULT_CODE("code", "响应码key"),
RESULT_MSG("msg", "响应信息key"),
RESULT_BODY("body", "响应传输信息key");
/**
* 响应结果key
*/
private String key;
/**
* 响应结果名称
*/
private String name;
RESULT_INFO_ENUM(String key, String name) {
this.key = key;
this.name = name;
}
/**
* 获取响应结果key
*/
public String getKey() {
return key;
}
/**
* 获取响应结果name
*/
public String getName() {
return name;
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/GlobalExceptionAdvisor.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc;
import com.google.common.base.Splitter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.shiro.authz.UnauthenticatedException;
import org.apache.shiro.authz.UnauthorizedException;
import org.springframework.beans.ConversionNotSupportedException;
import org.springframework.context.support.DefaultMessageSourceResolvable;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.http.converter.HttpMessageConversionException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import java.sql.SQLIntegrityConstraintViolationException;
import java.util.List;
import java.util.stream.Collectors;
/**
* 全局异常处理
*
* @author mxy
* @date 2019/8/1
*/
@Slf4j
@RestControllerAdvice
public class GlobalExceptionAdvisor {
/**
* 捕获全局异常，处理所有不可知的异常
*
* @param exception 异常对象
*/
@ExceptionHandler(Exception.class)
public Object handleException(Exception exception) {
log.error("\r\n ************** 操作出现异常：{}", ExceptionUtils.getStackTrace(exception));
Class<?> eClass = exception.getClass();
HttpResult httpResult = new HttpResult();
if (eClass.equals(HttpRequestMethodNotSupportedException.class)) {
addResCodeToMap(RESPONSE_CODE_ENUM.METHOD_NOT_SUPPORTED, httpResult);
} else if (eClass.equals(HttpMediaTypeNotAcceptableException.class)) {
addResCodeToMap(RESPONSE_CODE_ENUM.MEDIA_TYPE_NOT_ACCEPT, httpResult);
} else if (eClass.equals(HttpMediaTypeNotSupportedException.class)) {
addResCodeToMap(RESPONSE_CODE_ENUM.MEDIA_TYPE_NOT_SUPPORTED, httpResult);
} else if (eClass.equals(ConversionNotSupportedException.class)) {
addResCodeToMap(RESPONSE_CODE_ENUM.SERVER_ERROR, httpResult);
} else if (eClass.equals(HttpMessageNotWritableException.class)) {
addResCodeToMap(RESPONSE_CODE_ENUM.SERVER_ERROR, httpResult);
} else {
addResCodeToMap(RESPONSE_CODE_ENUM.SERVER_ERROR, httpResult);
}
return httpResult;
}
@ExceptionHandler(BindException.class)
@ResponseBody
public HttpResult handle(BindException ex) {
String message = ex.getBindingResult().getAllErrors().stream().map(DefaultMessageSourceResolvable::getDefaultMessage).collect(Collectors.joining(" \n "));
// BindingResult bindingResult = ex.getBindingResult();
// StringBuilder errMsg = new StringBuilder(bindingResult.getFieldErrors().size() * 16);
// errMsg.append("Invalid request:");
// for (int i = 0; i < bindingResult.getFieldErrors().size(); i++) {
// if (i > 0) {
// errMsg.append(",");
// }
// FieldError error = bindingResult.getFieldErrors().get(i);
// errMsg.append(error.getField()).append(":").append(error.getDefaultMessage());
// }
return new HttpResult(400, message);
//throw new InterfaceException(RESPONSE_CODE_ENUM.PARAM_NOT_VALID.getCode(), errMsg.toString());
}
//处理请求参数格式错误 @RequestParam上validate失败后抛出的异常是javax.validation.ConstraintViolationException
@ExceptionHandler(ConstraintViolationException.class)
@ResponseBody
public String constraintViolationExceptionHandler(ConstraintViolationException e) {
return e.getConstraintViolations().stream().map(ConstraintViolation::getMessage).collect(Collectors.joining());
}
/**
* 处理请求参数格式错误 @RequestBody上validate失败后抛出的异常是MethodArgumentNotValidException异常。
*
* @param exception 错误信息集合
* @return 错误信息
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
public HttpResult validationBodyException(MethodArgumentNotValidException exception) {
BindingResult result = exception.getBindingResult();
String msg = null;
if (result.hasErrors()) {
List<ObjectError> errors = result.getAllErrors();
for (ObjectError objectError : errors) {
FieldError fieldError = (FieldError) objectError;
if (fieldError.getDefaultMessage() != null) {
log.info("Data check failure : object{" + fieldError.getObjectName() + "},field{" + fieldError.getField() +
"},errorMessage{" + fieldError.getDefaultMessage() + "}");
msg = fieldError.getDefaultMessage();
}
}
}
return new HttpResult(400, msg);
}
@ExceptionHandler(DataAccessException.class)
public HttpResult dataAccessException(DataAccessException exception) {
return new HttpResult(400, exception.getLocalizedMessage());
}
@ExceptionHandler(DuplicateKeyException.class)
@ResponseBody
public HttpResult duplicateKeyException(DuplicateKeyException e) {
String localizedMessage = e.getLocalizedMessage();
String message = Splitter.on(System.lineSeparator()).trimResults().splitToList(localizedMessage).get(1);
String substring = message.substring(message.indexOf("Exception:"));
if (substring.toUpperCase().contains("NAME")) {
return new HttpResult(400, "名称已存在");
} else if (substring.toUpperCase().contains("CODE")) {
return new HttpResult(400, "编码已存在");
}
return new HttpResult(400, message);
}
@ExceptionHandler(SQLIntegrityConstraintViolationException.class)
@ResponseBody
public HttpResult sqlIntegrityConstraintViolationException(SQLIntegrityConstraintViolationException e) {
String localizedMessage = e.getLocalizedMessage();
String message = Splitter.on(System.lineSeparator()).trimResults().splitToList(localizedMessage).get(1);
String substring = message.substring(message.indexOf("Exception:"));
if (substring.toUpperCase().contains("NAME")) {
return new HttpResult(400, "名称已存在");
} else if (substring.toUpperCase().contains("CODE")) {
return new HttpResult(400, "编码已存在");
}
return new HttpResult(400, message);
}
/**
* 参数类型转换错误
*
* @param exception 错误
* @return 错误信息
*/
@ExceptionHandler(HttpMessageConversionException.class)
public HttpResult httpMessageConversionException(HttpMessageConversionException exception) {
log.error(exception.getCause().getLocalizedMessage());
return new HttpResult(400, exception.getCause().getLocalizedMessage());
}
/**
* 捕获业务异常
*
* @param exception 自定义接口异常类
* @return 返回的异常信息map
*/
@ExceptionHandler(InterfaceException.class)
public HttpResult handleInterfaceException(InterfaceException exception) {
HttpResult httpResult = new HttpResult();
httpResult.setCode(Integer.parseInt(exception.getErrorCode()));
httpResult.setMsg(exception.getErrorMsg());
return httpResult;
}
/**
* 捕获Shiro无权限异常 未授权异常
*
* @param exception 无权限异常
* @return 返回的异常信息map
*/
@ExceptionHandler(UnauthorizedException.class)
public Object handleUnauthorizedException(UnauthorizedException exception) {
HttpResult httpResult = new HttpResult();
// 无权限
addResCodeToMap(RESPONSE_CODE_ENUM.UNAUTHORIZED, httpResult);
return httpResult;
}
/**
* 捕获Shiro无权限异常 未认证异常
*
* @param exception 无权限异常
* @return 返回的异常信息map
*/
@ExceptionHandler(UnauthenticatedException.class)
public Object handleUnauthenticatedException(UnauthenticatedException exception) {
HttpResult httpResult = new HttpResult();
// 无权限
addResCodeToMap(RESPONSE_CODE_ENUM.UNAUTHORIZED, httpResult);
return httpResult;
}
/**
* 添加异常信息到map中
*
* @param responseCodeEnum 错误响应编码枚举类对象
* @param httpResult 响应对象
*/
private void addResCodeToMap(RESPONSE_CODE_ENUM responseCodeEnum, HttpResult httpResult) {
httpResult.setCode(Integer.parseInt(responseCodeEnum.getCode()));
httpResult.setMsg(responseCodeEnum.getMsg());
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/HttpResult.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc;
public class HttpResult {
// 响应的状态码
private int code;
// 响应的响应信息
private String msg;
// 响应的响应体
private Object body;
public HttpResult() {
}
public HttpResult(int code, String msg) {
this.code = code;
this.msg = msg;
}
public HttpResult(int code, Object body) {
this.code = code;
this.body = body;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public Object getBody() {
return body;
}
public void setBody(Object body) {
this.body = body;
}
@Override
public String toString() {
return "{" +
"\"code\":" + code +
", \"msg\":" + "\"" + msg + "\"" +
", \"body\":" + body +
'}';
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/InterfaceException.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc;
/**
* 自定义接口异常对象
*/
public class InterfaceException extends RuntimeException {
private static final long serialVersionUID = -854533489101542484L;
// 错误编码
private String errorCode;
// 错误编码信息
private String errorMsg;
/**
* 应用接口有参构造函数
*
* @param errorCode 错误编码
* @param errorMsg 错误信息
*/
public InterfaceException(String errorCode, String errorMsg) {
super("errorCode:" + errorCode + " errorMsg:" + errorMsg);
this.errorCode = errorCode;
this.errorMsg = errorMsg;
}
/**
* 应用接口有参构造函数
*
* @param responseCode 响应编码枚举
*/
public InterfaceException(RESPONSE_CODE_ENUM responseCode) {
super("errorCode:" + responseCode.getCode() + " errorMsg:" + responseCode.getMsg());
this.errorCode = responseCode.getCode();
this.errorMsg = responseCode.getMsg();
}
/**
* 获取错误编码
*/
public String getErrorCode() {
return errorCode;
}
/**
* 设置错误编码
*/
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
/**
* 获取异常编码
*/
public String getErrorMsg() {
return errorMsg;
}
/**
* 设置异常编码
*/
public void setErrorMsg(String errorMsg) {
this.errorMsg = errorMsg;
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/RESPONSE_CODE_ENUM.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc;
/**
* 响应编码
*/
public enum RESPONSE_CODE_ENUM {
/* ******************** 系统异常 ********************* */
PARAM_NOT_VALID("400", "请求的参数不合法"),
RESOURCE_NOT_FOUND("404", "请求的资源不存在"),
METHOD_NOT_SUPPORTED("405", "不支持的请求方法"),
MEDIA_TYPE_NOT_ACCEPT("406", "无法接受请求中的媒体类型"),
MEDIA_TYPE_NOT_SUPPORTED("415", "不支持的媒体类型"),
SERVER_ERROR("500", "服务异常"),
/* ******************** 业务自定义异常 **************** */
REQUEST_PARAMS_ERROR("1001", "参数异常"),
GAIN_DATA_FAIL("1003", "获取数据失败"),
UPLOAD_FAILURE("1005", "上传失败"),
AZKABAN_PROJECT_REPEAT("1006", "工程名重复"),
HBASE_IOEXCEPTION("1008", "连接hbase异常"),
CREATE_FLOW_PROJECT_ERROR("1009", "业务流程名称重复"),
CREATE_FLOW_NODE_ERROR("1010", "业务节点名称重复"),
FLUME_AGENT_ERROR("1011", "agent名称重复"),
FLUME_AGENT_RUNNING("1012", "agent正在运行，不可操作"),
PARAMETER_PARSING_FAILED("1013", "参数解析失败"),
EMPTY_NODE_LIST_RUN_FAILED("1014", "节点集合为空，运行失败"),
FLOW_RESOURCE_REPEAT("1015", "目录下，有重名资源"),
FILE_SYSTEM_FILE_NOEXIST("1016", "目录不存在"),
FILE_SYSTEM_FILE_EXCEPTION("1017", "访问异常"),
EMPTY_NODE_RUN_FAILED("1018", "-节点内容为空"),
EMPTY_NODE_LIST_SAVE_FAILED("1019", "节点集合为空，保存失败"),
CANCEL_FLOW_CHAIN_FAILED("1020", "正在更新工作流程链，请稍后刷新页面"),
TEMPORARY_QUERY_NAME_REPEAT("1021", "hive查询任务重名"),
DATA_SYNC_NODE_CHECK_ERROR("1022", "数据同步节点配置错误"),
HIVE_UPLOAD_FILE_INCORRECT("1028", "文件类型不支持"),
SCHEDULE_FLOW_EXEC_REPEAT("1029", "业务流程的定时任务启动重复"),
NAME_REPEAT("1030", "名称重复"),
CODE_REPEAT("1031", "编码重复"),
MODEL_RELEASE_ERROR("1032", "已为发布状态，不能发布"),
MODEL_OFFLINE_ERROR("1033", "被占用，不能下线"),
MODEL_DELETE_ERROR("1034", "发布状态，不能删除"),
DIMENSION_TABLE_DATABASE_INFO_ERROR("1035", "维度表数据源信息是必须的"),
DIMENSION_TABLE_CREATE_TABLE_ERROR("1036", "维度表创建失败"),
FACT_ATTRIBUTES_CHECK_ERROR("1037", "事实表属性必须包含时间数据类型"),
FACT_TABLES_CREATE_TABLE_ERROR("1038", "事实表创建失败"),
FACT_TABLES_DATABASE_INFO_ERROR("1039", "事实表数据源信息是必须的"),
AGGREGATION_TABLE_DATABASE_INFO_ERROR("1040", "汇总表数据源信息是必须的"),
AGGREGATION_TABLE_CREATE_TABLE_ERROR("1041", "汇总表创建失败"),
AGGREGATION_ATTRIBUTES_CHECK_ERROR("1042", "汇总表必须配置时间周期和指标"),
MODEL_CREATE_ERROR("1043", "创建失败"),
MODEL_OFFLINE_STATUS_ERROR("1044", "当前状态为非发布状态，不允许下线"),
FIELD_NAME_ID_REPEAT_ERROR("1045", "字段名称id不允许重复"),
ASSET_LABEL_DELETE_ERROR("1046", "标签为引用状态,不能删除"),
QUALITY_JOB_NOT_EXIST("1047", "质量作业不存在"),
SYSTEM_TEMPLATE_NOT_OPERATIONAL_ERROR("1048", "系统模板不可操作"),
QUALITY_JOB_RUNNING_NOT_DELETE("1049", "质量作业正在运行，不能删除"),
QUALITY_RULE_SQL_SEMANTIC_VERIFICATION_ERROR("1050", "语义校验失败，请检查。"),
QUALITY_JOB_PERIOD_CRON_NOT_EXIST("1051", "CRON表达式不存在"),
QUALITY_JOB_RUN_TASK_NOT_FIND("1052", "找不到要停止的质量作业任务"),
OUTPUT_SHOW_WITH_SQL_NOT_MATCH_ERROR("1053", "输出结果说明与定义关系不匹配"),
LACK_A_PRIMARY_KEY_ERROR("1054", "至少包含一个主键属性"),
QUALITY_JOB_RUN_ERROR("1055", "启动质量作业失败，请检查质量作业参数..."),
ILLEGAL_OPERATION("1400", "违规操作"),
BUSINESS_OBJECT_NAME_REGEX_CHECK_ERROR("1500", "只允许除右斜杠、<、>、/外的字符"),
/* ******************** 登录权限 **************** */
USER_NAME_REPEAT("1101", "账户已存在"),
LOGIN_INCORRECT("1102", "登录异常"),
LOGIN_NOT_EXISTS("1103", "账户不存在"),
LOGIN_PWD_INCORRECT("1104", "账户或密码不正确"),
NOT_LOGIN_ERROR("1105", "重新登录"),
OLD_PASSWORD_INCORRECT("1106", "旧密码不正确"),
ACCOUNT_HAS_BEEN_DISABLED("1107", "此账号已被禁用"),
ACCOUNT_IS_LOCKED("1108", "此账号已被锁定，请稍后再试"),
ACCOUNT_AUTHENTICATION_FAILED("1109", "账号认证失败"),
UNAUTHORIZED("1110", "权限不足"),
ROLE_CODE_REPEAT("1111", "角色编码已存在"),
SYS_ROLE_DELETE_FAIL("1112", "系统角色不允许删除"),
SYS_MENU_DELETE_FAIL("1113", "还存在子菜单，不能直接删除"),
/* ******************** 操作失败 **************** */
REQUEST_FAIL("1100", "操作失败"),
/* ******************** 操作成功 **************** */
REQUEST_SUCCESS("200", "操作成功");
// 错误编码
private String code;
// 错误信息
private String msg;
// 相应编码有参构造函数
RESPONSE_CODE_ENUM(String code, String msg) {
this.code = code;
this.msg = msg;
}
/**
* 获取编码
*/
public String getCode() {
return code;
}
/**
* 设置编码
*/
public void setCode(String code) {
this.code = code;
}
/**
* 获取编码信息
*/
public String getMsg() {
return msg;
}
/**
* 设置编码信息
*/
public void setMsg(String msg) {
this.msg = msg;
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/RequestParamValidAspect.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc;
import cn.wisenergy.datastation.common.core.utils.exception.RESPONSE_CODE_ENUM;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.hibernate.validator.internal.engine.path.PathImpl;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.stereotype.Component;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import javax.validation.executable.ExecutableValidator;
import java.lang.reflect.Method;
import java.util.Set;
/**
* 参数校验切面
*/
@Slf4j
@Aspect
@Component
public class RequestParamValidAspect {
private final ParameterNameDiscoverer parameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
private final ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
private final ExecutableValidator validator = factory.getValidator().forExecutables();
private <T> Set<ConstraintViolation<T>> validMethodParams(T obj, Method method, Object[] params) {
return validator.validateParameters(obj, method, params);
}
@Pointcut("execution(* cn.wisenergy.chnmuseum.party.web.*.*.controller.*.*(..))")
public void controllerBefore() {
}
@Before("controllerBefore()")
public void before(JoinPoint point) {
// 获得切入方法参数
Object[] args = point.getArgs();
if (args.length == 0) {
return;
}
/**************************校验封装好的javabean**********************/
//寻找带BindingResult参数的方法，然后判断是否有error，如果有则是校验不通过
// for (Object arg : args) {
// if (arg instanceof BeanPropertyBindingResult) {
// //有校验
// BeanPropertyBindingResult result = (BeanPropertyBindingResult) arg;
// if (result.hasErrors()) {
// List<ObjectError> list = result.getAllErrors();
// for (ObjectError error : list) {
// log.info(error.getCode() + "---" + Arrays.toString(error.getArguments()) + "--" + error.getDefaultMessage());
// //返回第一条校验失败信息。也可以拼接起来返回所有的
// return error.getDefaultMessage();
// }
// }
// }
// }
/**************************校验普通参数*************************/
Object target = point.getThis();
// 获得切入的方法
Method method = ((MethodSignature) point.getSignature()).getMethod();
// 执行校验，获得校验结果
Set<ConstraintViolation<Object>> validResult = validMethodParams(target, method, args);
//如果有校验不通过的
if (!validResult.isEmpty()) {
// 获得方法的参数名称
String[] parameterNames = parameterNameDiscoverer.getParameterNames(method);
for (ConstraintViolation<Object> constraintViolation : validResult) {
// 获得校验的参数路径信息
PathImpl pathImpl = (PathImpl) constraintViolation.getPropertyPath();
// 获得校验的参数位置
int paramIndex = pathImpl.getLeafNode().getParameterIndex();
assert parameterNames != null;
// 获得校验的参数名称
String paramName = parameterNames[paramIndex];
//校验信息
log.info(paramName + ": " + constraintViolation.getMessage());
}
//返回第一条校验失败信息，也可以拼接起来返回所有的
String message = validResult.iterator().next().getMessage();
throw new InterfaceException(RESPONSE_CODE_ENUM.PARAM_NOT_VALID.getCode(), message);
}
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/StringToDateConverter.java
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc; package cn.wisenergy.chnmuseum.party.common.mvc;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.springframework.core.convert.converter.Converter; import org.springframework.core.convert.converter.Converter;
import java.text.SimpleDateFormat;
import java.util.Date;
public class StringToDateConverter implements Converter<String, Date> { public class StringToDateConverter implements Converter<String, Date> {
private static final String dateFormat = "yyyy-MM-dd HH:mm:ss"; private static final String dateFormat = "yyyy-MM-dd HH:mm:ss";
private static final String shortDateFormat = "yyyy-MM-dd"; private static final String shortDateFormat = "yyyy-MM-dd";
......
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/StringToLocalDateConverter.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc;
import cn.wisenergy.chnmuseum.party.common.util.DateUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.convert.converter.Converter;
import java.time.LocalDate;
/**
* @author Danny Lee
* @since 2019-05-31 13:39
*/
public class StringToLocalDateConverter implements Converter<String, LocalDate> {
@Override
public LocalDate convert(String source) {
if (StringUtils.isEmpty(source)) {
return null;
}
return DateUtil.parseStringToDate(source, DateUtil.LONG_DATE_FORMAT);
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/StringToLocalDateTimeConverter.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc;
import cn.wisenergy.chnmuseum.party.common.util.DateUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.convert.converter.Converter;
import java.time.LocalDateTime;
/**
* @author Danny Lee
* @since 2019-05-31 13:39
*/
public class StringToLocalDateTimeConverter implements Converter<String, LocalDateTime> {
@Override
public LocalDateTime convert(String source) {
if (StringUtils.isEmpty(source)) {
return null;
}
return DateUtil.parseStringToDateTime(source, DateUtil.FORMAT_ONE);
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/StringToLocalTimeConverter.java 0 → 100644
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.mvc;
import cn.wisenergy.chnmuseum.party.common.util.DateUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.convert.converter.Converter;
import java.time.LocalTime;
/**
* @author Danny Lee
* @since 2019-05-31 13:39
*/
public class StringToLocalTimeConverter implements Converter<String, LocalTime> {
@Override
public LocalTime convert(String source) {
if (StringUtils.isEmpty(source)) {
return null;
}
return DateUtil.parseStringToTime(source, DateUtil.SHORT_TIME_FORMAT);
}
}
src/main/java/cn/wisenergy/chnmuseum/party/common/util/DateUtil.java
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.common.util; package cn.wisenergy.chnmuseum.party.common.util;
import java.sql.Timestamp; import java.time.*;
import java.text.DateFormat; import java.time.format.DateTimeFormatter;
import java.text.ParseException; import java.time.temporal.TemporalAdjusters;
import java.text.ParsePosition; import java.util.Date;
import java.text.SimpleDateFormat; import java.util.Locale;
import java.util.*; import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern; import java.util.concurrent.ConcurrentMap;
/**
* 日期工具类 - 基于LocalDateTime
*/
public class DateUtil { public class DateUtil {
// 格式：年－月－日 小时：分钟：秒 // 格式：年－月－日 小时：分钟：秒
public static final String FORMAT_ONE = "yyyy-MM-dd HH:mm:ss"; public static final String FORMAT_ONE = "yyyy-MM-dd HH:mm:ss";
public static final String FORMAT_T = "yyyy-MM-ddTHH:mm:ss"; public static final String FORMAT_T = "yyyy-MM-dd'T'HH:mm:ss";
// 格式：年－月－日 小时：分钟 // 格式：年－月－日 小时：分钟
public static final String FORMAT_TWO = "yyyy-MM-dd HH:mm"; public static final String FORMAT_TWO = "yyyy-MM-dd HH:mm";
// 格式：年月日 小时分钟秒
public static final String FORMAT_THREE = "yyyyMMdd-HHmmss";
// 格式：年－月－日 // 格式：年－月－日
public static final String LONG_DATE_FORMAT = "yyyy-MM-dd"; public static final String LONG_DATE_FORMAT = "yyyy-MM-dd";
...@@ -30,798 +30,467 @@ public class DateUtil { ...@@ -30,798 +30,467 @@ public class DateUtil {
// 格式：小时：分钟：秒 // 格式：小时：分钟：秒
public static final String LONG_TIME_FORMAT = "HH:mm:ss"; public static final String LONG_TIME_FORMAT = "HH:mm:ss";
// 格式：小时：分钟：秒
public static final String SHORT_TIME_FORMAT = "HH:mm";
// 格式：年-月 // 格式：年-月
public static final String MONTG_DATE_FORMAT = "yyyy-MM"; public static final String MONTG_DATE_FORMAT = "yyyy-MM";
private static final DateFormat df = new SimpleDateFormat(FORMAT_ONE); // 格式：年-月
public static final String Chinese_DATE_FORMAT = "yyyy年MM月dd日 HH:mm";
// 年的加减
public static final int SUB_YEAR = Calendar.YEAR;
// 月加减
public static final int SUB_MONTH = Calendar.MONTH;
// 天的加减
public static final int SUB_DAY = Calendar.DATE;
// 小时的加减
public static final int SUB_HOUR = Calendar.HOUR;
// 分钟的加减
public static final int SUB_MINUTE = Calendar.MINUTE;
// 秒的加减
public static final int SUB_SECOND = Calendar.SECOND;
static final String dayNames[] = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"}; private static final ConcurrentMap<String, DateTimeFormatter> FORMATTER_CACHE = new ConcurrentHashMap<>();
public static long dateToLong(String datetime) throws ParseException { private static final int PATTERN_CACHE_SIZE = 500;
return df.parse(datetime).getTime();
}
/** /**
* 获取指定年月的最大天数 * Date转换为格式化时间
* *
* @param year * @param date date
* @param month * @param pattern 格式
* @return * @return
*/ */
public static int getLastDay(int year, int month) { public static String format(Date date, String pattern) {
int day = 1; return format(LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()), pattern);
Calendar cal = Calendar.getInstance();
cal.set(year, month - 1, day);
int last = cal.getActualMaximum(Calendar.DATE);
System.out.println(last);
return last;
} }
/** /**
* 得到指定日期所在月份天数的集合 * localDateTime转换为格式化时间
* *
* @param date * @param localDateTime localDateTime
* @param pattern 格式
* @return * @return
*/ */
public static int[] getMonthDays(String date) { public static String format(LocalDateTime localDateTime, String pattern) {
Calendar calendar = Calendar.getInstance(); DateTimeFormatter formatter = createCacheFormatter(pattern);
calendar.set(Calendar.YEAR, Integer.parseInt(date.substring(0, 4))); return localDateTime.format(formatter);
calendar.set(Calendar.MONTH, Integer.parseInt(date.substring(5, 7)) - 1);
int maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
int[] days = new int[maxDay];
for (int i = 1; i <= maxDay; i++) {
days[i - 1] = i;
}
return days;
} }
/** /**
* 获取一年的所有月 * localDateTime转换为格式化时间
*/ *
public static int[] getMonths() { * @param localDateTime localDateTime
int months[] = {}; * @return
for (int i = 0; i < 12; i++) {
months[i] = i + 1;
}
return months;
}
/**
* 获取当月的天数
*/
public static int getCurrentMonthDay() {
Calendar a = Calendar.getInstance();
a.set(Calendar.DATE, 1);
a.roll(Calendar.DATE, -1);
int maxDate = a.get(Calendar.DATE);
return maxDate;
}
/**
* 根据年 月 获取对应的月份 天数
*/
public static int getDaysByYearMonth(int year, int month) {
Calendar a = Calendar.getInstance();
a.set(Calendar.YEAR, year);
a.set(Calendar.MONTH, month - 1);
a.set(Calendar.DATE, 1);
a.roll(Calendar.DATE, -1);
int maxDate = a.get(Calendar.DATE);
return maxDate;
}
/**
* 根据日期 找到对应日期的 星期
*/ */
public static String getDayOfWeekByDate(String date) { public static String format(LocalDateTime localDateTime) {
String dayOfweek = "-1"; DateTimeFormatter formatter = createCacheFormatter(FORMAT_ONE);
try { return localDateTime.format(formatter);
SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
Date myDate = myFormatter.parse(date);
SimpleDateFormat formatter = new SimpleDateFormat("E");
String str = formatter.format(myDate);
dayOfweek = str;
} catch (Exception e) {
e.printStackTrace();
}
return dayOfweek;
}
public DateUtil() {
} }
/** /**
* 把符合日期格式的字符串转换为日期类型 * 格式化字符串转为Date
* *
* @param dateStr * @param time 格式化时间
* @param pattern 格式
* @return * @return
*/ */
public static Date stringtoDate(String dateStr, String format) { public static Date parseDate(String time, String pattern) {
Date d = null; return Date.from(parseLocalDateTime(time, pattern).atZone(ZoneId.systemDefault()).toInstant());
SimpleDateFormat formater = new SimpleDateFormat(format);
try {
formater.setLenient(false);
d = formater.parse(dateStr);
} catch (Exception e) {
// log.error(e);
d = null;
}
return d;
}
/**
* 把符合日期格式的字符串转换为日期类型
*/
public static Date stringtoDate(String dateStr, String format, ParsePosition pos) {
Date d = null;
SimpleDateFormat formater = new SimpleDateFormat(format);
try {
formater.setLenient(false);
d = formater.parse(dateStr, pos);
} catch (Exception e) {
d = null;
}
return d;
} }
/** /**
* 把日期转换为字符串 * 格式化字符串转为LocalDateTime
* *
* @param date * @param time 格式化时间
* @param pattern 格式
* @return * @return
*/ */
public static String dateToString(Date date, String format) { public static LocalDateTime parseLocalDateTime(String time, String pattern) {
String result = ""; DateTimeFormatter formatter = createCacheFormatter(pattern);
SimpleDateFormat formater = new SimpleDateFormat(format); return LocalDateTime.parse(time, formatter);
try {
result = formater.format(date);
} catch (Exception e) {
// log.error(e);
}
return result;
} }
/** /**
* 获取当前时间的指定格式 * 格式化字符串转为LocalDateTime
* *
* @param format * @param time 格式化时间
* @return * @param pattern 格式
* @return localDateTime
*/ */
public static String getCurrDate(String format) { public static LocalDateTime transferLocalDateTime(String time, String pattern) {
return dateToString(new Date(), format); DateTimeFormatter formatter = createCacheFormatter(pattern);
return LocalDate.parse(time, formatter).atStartOfDay();
} }
/** /**
* @param dateStr * java.util.Date --> java.time.LocalDateTime
* @param amount
* @return
*/ */
public static String dateSub(int dateKind, String dateStr, int amount) { public static LocalDateTime UDateToLocalDateTime(Date date) {
Date date = stringtoDate(dateStr, FORMAT_ONE); Instant instant = date.toInstant();
Calendar calendar = Calendar.getInstance(); ZoneId zone = ZoneId.systemDefault();
calendar.setTime(date); return LocalDateTime.ofInstant(instant, zone);
calendar.add(dateKind, amount);
return dateToString(calendar.getTime(), FORMAT_ONE);
} }
/** /**
* 两个日期相减 * 将LocalDateTime转为自定义的时间格式的字符串
* *
* @param firstTime * @param localDateTime
* @param secTime * @param format
* @return 相减得到的秒数 * @return
*/ */
public static long timeSub(String firstTime, String secTime) { public static String getDateTimeAsString(LocalDateTime localDateTime, String format) {
long first = stringtoDate(firstTime, FORMAT_ONE).getTime(); DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
long second = stringtoDate(secTime, FORMAT_ONE).getTime(); return localDateTime.format(formatter);
return (second - first) / 1000;
} }
/** /**
* 获得某月的天数 * 将long类型的timestamp转为LocalDateTime
* *
* @param year int * @param timestamp
* @param month int * @return
* @return int
*/ */
public static int getDaysOfMonth(String year, String month) { public static LocalDateTime getDateTimeOfTimestamp(long timestamp) {
int days = 0; Instant instant = Instant.ofEpochMilli(timestamp);
if (month.equals("1") || month.equals("3") || month.equals("5") || month.equals("7") || month.equals("8") ZoneId zone = ZoneId.systemDefault();
|| month.equals("10") || month.equals("12")) { return LocalDateTime.ofInstant(instant, zone);
days = 31;
} else if (month.equals("4") || month.equals("6") || month.equals("9") || month.equals("11")) {
days = 30;
} else {
if ((Integer.parseInt(year) % 4 == 0 && Integer.parseInt(year) % 100 != 0)
|| Integer.parseInt(year) % 400 == 0) {
days = 29;
} else {
days = 28;
}
}
return days;
} }
/** /**
* 获取某年某月的天数 * 将LocalDateTime转为long类型的timestamp
* *
* @param year int * @param localDateTime
* @param month int 月份[1-12] * @return
* @return int
*/ */
public static int getDaysOfMonth(int year, int month) { public static long getTimestampOfDateTime(LocalDateTime localDateTime) {
Calendar calendar = Calendar.getInstance(); ZoneId zone = ZoneId.systemDefault();
calendar.set(year, month - 1, 1); Instant instant = localDateTime.atZone(zone).toInstant();
return calendar.getActualMaximum(Calendar.DAY_OF_MONTH); return instant.toEpochMilli();
} }
/** /**
* 获得当前日期 * 将某时间字符串转为自定义时间格式的LocalDateTime
* *
* @return int * @param time
* @param format
* @return
*/ */
public static int getToday() { public static LocalDateTime parseStringToDateTime(String time, String format) {
Calendar calendar = Calendar.getInstance(); DateTimeFormatter df = DateTimeFormatter.ofPattern(format, Locale.getDefault());
return calendar.get(Calendar.DATE); return LocalDateTime.parse(time, df);
} }
/** /**
* 获得当前月份 * 计算两个日期之间相差的时间
* *
* @return int * @param startDate 较小的时间
* @param endDate 较大的时间
* @return 相差结果 X天X小时X分钟X秒
*/ */
public static int getToMonth() { public static String differenceTimeStr(Date startDate, Date endDate) {
Calendar calendar = Calendar.getInstance(); // 计算时间差
return calendar.get(Calendar.MONTH) + 1; long between = endDate.toInstant().toEpochMilli() - startDate.toInstant().toEpochMilli();
if (between < 0) {
return "-1";
} }
long day = between / (1000 * 3600 * 24); // 天
long hour = (between / (60 * 60 * 1000) - day * 24); // 小时
long min = ((between / (60 * 1000)) - day * 24 * 60 - hour * 60); // 分钟
long sec = (between / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60); // 秒
/** StringBuilder sb = new StringBuilder();
* 获得当前年份 if (0 != day) {
* sb.append(day);
* @return int sb.append("天");
*/
public static int getToYear() {
Calendar calendar = Calendar.getInstance();
return calendar.get(Calendar.YEAR);
} }
if (0 != hour) {
/** sb.append(hour);
* 返回日期的天 sb.append("小时");
*
* @param date Date
* @return int
*/
public static int getDay(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.get(Calendar.DATE);
} }
if (0 != min) {
/** sb.append(min);
* 返回日期的年 sb.append("分");
*
* @param date Date
* @return int
*/
public static int getYear(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.get(Calendar.YEAR);
} }
sb.append(sec);
/** sb.append("秒");
* 返回日期的月份，1-12 return String.valueOf(sb);
*
* @param date Date
* @return int
*/
public static int getMonth(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.get(Calendar.MONTH) + 1;
} }
/** /**
* 计算两个日期相差的天数，如果date2 > date1 返回正数，否则返回负数 * 时间戳转时间【毫秒】
* *
* @param date1 Date * @param timeStamp 时间戳【毫秒】
* @param date2 Date * @param pattern 格式化参数
* @return long * @return 格式化后的时间
*/ */
public static long dayDiff(Date date1, Date date2) { public static String msTimeStampConvertTime(long timeStamp, String pattern) {
return (date2.getTime() - date1.getTime()) / 86400000; Instant instant = Instant.ofEpochMilli(timeStamp);
ZoneId zone = ZoneId.systemDefault();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
return LocalDateTime.ofInstant(instant, zone).format(formatter);
} }
/** /**
* 比较两个日期的年差 * 时间戳转时间【秒】
* *
* @param before * @param timeStamp 时间戳【秒】
* @param after * @param pattern 格式化参数
* @return * @return 格式化后的时间
*/ */
public static int yearDiff(String before, String after) { public static String secondsTimeStampConvertTime(long timeStamp, String pattern) {
Date beforeDay = stringtoDate(before, LONG_DATE_FORMAT); Instant instant = Instant.ofEpochSecond(timeStamp);
Date afterDay = stringtoDate(after, LONG_DATE_FORMAT); ZoneId zone = ZoneId.systemDefault();
return getYear(afterDay) - getYear(beforeDay); DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
return LocalDateTime.ofInstant(instant, zone).format(formatter);
} }
/** /**
* 比较指定日期与当前日期的差 * 将某时间字符串转为自定义时间格式的LocalDate
* *
* @param after * @param time
* @param format
* @return * @return
*/ */
public static int yearDiffCurr(String after) { public static LocalDate parseStringToDate(String time, String format) {
Date beforeDay = new Date(); DateTimeFormatter df = DateTimeFormatter.ofPattern(format, Locale.getDefault());
Date afterDay = stringtoDate(after, LONG_DATE_FORMAT); return LocalDate.parse(time, df);
return getYear(beforeDay) - getYear(afterDay);
} }
/** /**
* 比较指定日期与当前日期的差 * 将某时间字符串转为自定义时间格式的LocalDate
* *
* @param before * @param time
* @param format
* @return * @return
* @author chenyz
*/ */
public static long dayDiffCurr(String before) { public static LocalTime parseStringToTime(String time, String format) {
Date currDate = DateUtil.stringtoDate(currDay(), LONG_DATE_FORMAT); DateTimeFormatter df = DateTimeFormatter.ofPattern(format, Locale.getDefault());
Date beforeDate = stringtoDate(before, LONG_DATE_FORMAT); return LocalTime.parse(time, df);
return (currDate.getTime() - beforeDate.getTime()) / 86400000;
} }
/** /**
* 获取每月的第一周 * 在缓存中创建DateTimeFormatter
* *
* @param year * @param pattern 格式
* @param month
* @return * @return
* @author chenyz
*/ */
public static int getFirstWeekdayOfMonth(int year, int month) { private static DateTimeFormatter createCacheFormatter(String pattern) {
Calendar c = Calendar.getInstance(); if (pattern == null || pattern.length() == 0) {
c.setFirstDayOfWeek(Calendar.SATURDAY); // 星期天为第一天 throw new IllegalArgumentException("Invalid pattern specification");
c.set(year, month - 1, 1); }
return c.get(Calendar.DAY_OF_WEEK); DateTimeFormatter formatter = FORMATTER_CACHE.get(pattern);
if (formatter == null) {
if (FORMATTER_CACHE.size() < PATTERN_CACHE_SIZE) {
formatter = DateTimeFormatter.ofPattern(pattern);
DateTimeFormatter oldFormatter = FORMATTER_CACHE.putIfAbsent(pattern, formatter);
if (oldFormatter != null) {
formatter = oldFormatter;
}
}
}
return formatter;
} }
/** /**
* 获取每月的最后一周 * 获取某个时间段的开始时间
* *
* @param year * @param offset 0今天，1明天，-1昨天，依次类推
* @param month
* @return * @return
* @author chenyz
*/ */
public static int getLastWeekdayOfMonth(int year, int month) { public static LocalDateTime minuteStart(int offset) {
Calendar c = Calendar.getInstance(); return LocalDateTime.now().plusMinutes(offset).withSecond(0).withNano(0);
c.setFirstDayOfWeek(Calendar.SATURDAY); // 星期天为第一天
c.set(year, month - 1, getDaysOfMonth(year, month));
return c.get(Calendar.DAY_OF_WEEK);
} }
/** /**
* 获得当前日期字符串，格式"yyyy-MM-dd HH:mm:ss" * 获取某个时间段的开始时间
* *
* @param offset 0今天，1明天，-1昨天，依次类推
* @return * @return
*/ */
public static String getNow() { public static LocalDateTime minuteEnd(int offset) {
Calendar today = Calendar.getInstance(); return LocalDateTime.now().plusMinutes(offset).withSecond(59).withNano(999999999);
return dateToString(today.getTime(), FORMAT_ONE);
}
public static String getDateTime() {
Calendar today = Calendar.getInstance();
String date = dateToString(today.getTime(), LONG_DATE_FORMAT);
String time = dateToString(today.getTime(), LONG_TIME_FORMAT);
return date + "T" + time + "Z";
} }
/** /**
* 根据生日获取星座 * 获取某个时间段的开始时间
* *
* @param birth YYYY-mm-dd * @param offset 0今天，1明天，-1昨天，依次类推
* @return * @return
*/ */
public static String getAstro(String birth) { public static LocalDateTime hourStart(int offset) {
if (!isDate(birth)) { return LocalDateTime.now().plusHours(offset).withMinute(0).withSecond(0).withNano(0);
birth = "2000" + birth;
}
if (!isDate(birth)) {
return "";
}
int month = Integer.parseInt(birth.substring(birth.indexOf("-") + 1, birth.lastIndexOf("-")));
int day = Integer.parseInt(birth.substring(birth.lastIndexOf("-") + 1));
String s = "魔羯水瓶双鱼牡羊金牛双子巨蟹狮子处女天秤天蝎射手魔羯";
int[] arr = {20, 19, 21, 21, 21, 22, 23, 23, 23, 23, 22, 22};
int start = month * 2 - (day < arr[month - 1] ? 2 : 0);
return s.substring(start, start + 2) + "座";
} }
/** /**
* 判断日期是否有效,包括闰年的情况 * 获取某个时间段的结束时间
* *
* @param date YYYY-mm-dd * @param offset 0今天，1明天，-1昨天，依次类推
* @return * @return
*/ */
public static boolean isDate(String date) { public static LocalDateTime hourEnd(int offset) {
StringBuffer reg = new StringBuffer("^((\\d{2}(([02468][048])|([13579][26]))-?((((0?"); return LocalDateTime.now().plusHours(offset).withMinute(59)
reg.append("[13578])|(1[02]))-?((0?[1-9])|([1-2][0-9])|(3[01])))"); .withSecond(59)
reg.append("|(((0?[469])|(11))-?((0?[1-9])|([1-2][0-9])|(30)))|"); .withNano(999999999);
reg.append("(0?2-?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][12");
reg.append("35679])|([13579][01345789]))-?((((0?[13578])|(1[02]))");
reg.append("-?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))");
reg.append("-?((0?[1-9])|([1-2][0-9])|(30)))|(0?2-?((0?[");
reg.append("1-9])|(1[0-9])|(2[0-8]))))))");
Pattern p = Pattern.compile(reg.toString());
return p.matcher(date).matches();
} }
/** /**
* 取得指定日期过 months 月后的日期 (当 months 为负数表示指定月之前); * 获取某天的开始日期
* *
* @param date 日期 为null时表示当天 * @param offset 0今天，1明天，-1昨天，依次类推
* @param months 相加(相减)的月数 * @return
*/ */
public static Date nextMonth(Date date, int months) { public static LocalDateTime dayStart(int offset) {
Calendar cal = Calendar.getInstance(); return LocalDate.now().plusDays(offset).atStartOfDay();
if (date != null) {
cal.setTime(date);
}
cal.add(Calendar.MONTH, months);
return cal.getTime();
} }
/** /**
* 取得指定日期过 day 天后的日期 (当 day 为负数表示指日期之前); * 获取日期的结束时间
*/ */
public static Date nextDay(Date date, int day) { public static LocalDateTime getDayStart(int offset) {
Calendar cal = Calendar.getInstance(); return LocalDateTime.now().plusDays(offset).withHour(0)
if (date != null) { .withMinute(0)
cal.setTime(date); .withSecond(0)
} .withNano(0);
cal.add(Calendar.DAY_OF_YEAR, day);
return cal.getTime();
} }
/** /**
* 取得距离今天 day 日的日期 * 获取某天的开始日期
* *
* @param day * @param offset 0今天，1明天，-1昨天，依次类推
* @param format
* @return * @return
* @author chenyz
*/ */
public static String nextDay(int day, String format) { public static LocalDateTime dayEnd(int offset) {
Calendar cal = Calendar.getInstance(); return LocalDateTime.of(LocalDate.now().plusDays(offset), LocalTime.MAX);//当天零点
cal.setTime(new Date());
cal.add(Calendar.DAY_OF_YEAR, day);
return dateToString(cal.getTime(), format);
} }
/** /**
* 取得指定日期过 day 周后的日期 (当 day 为负数表示指定月之前) * 获取日期的结束时间
*
* @param date 日期 为null时表示当天
*/ */
public static Date nextWeek(Date date, int week) { public static LocalDateTime getDayEnd(int offset) {
Calendar cal = Calendar.getInstance(); return LocalDateTime.now().plusDays(offset).withHour(23)
if (date != null) { .withMinute(59)
cal.setTime(date); .withSecond(59)
} .withNano(999999999);
cal.add(Calendar.WEEK_OF_MONTH, week);
return cal.getTime();
} }
/** /**
* 获取当前的日期(yyyy-MM-dd) * 获取此刻与相对当天第day天的起始时间相隔的秒数。day为0表示今天的起始时间；1明天，2后天，-1昨天，-2前天等，依次例推。
*/
public static String currDay() {
return DateUtil.dateToString(new Date(), DateUtil.LONG_DATE_FORMAT);
}
/**
* 获取昨天的日期
* *
* @param day
* @return * @return
*/ */
public static String befoDay() { public static int ttl(int day) {
return befoDay(DateUtil.LONG_DATE_FORMAT); LocalDateTime now = LocalDateTime.now();
LocalDateTime time = LocalDate.now().plusDays(day).atStartOfDay();
return (int) Duration.between(now, time).toMillis() / 1000;
} }
/** /**
* 根据时间类型获取昨天的日期 * 获取某周的开始日期
* *
* @param format * @param offset 0本周，1下周，-1上周，依次类推
* @return * @return
* @author chenyz
*/
public static String befoDay(String format) {
return DateUtil.dateToString(DateUtil.nextDay(new Date(), -1), format);
}
/**
* 获取明天的日期
*/ */
public static String afterDay() { public static LocalDateTime weekStart(int offset) {
return DateUtil.dateToString(DateUtil.nextDay(new Date(), 1), DateUtil.LONG_DATE_FORMAT); return LocalDateTime.now().plusWeeks(offset).with(DayOfWeek.MONDAY);
} }
/** /**
* 取得当前时间距离1900/1/1的天数 * 获取某周的开始日期
* *
* @param offset 0本周，1下周，-1上周，依次类推
* @return * @return
*/ */
public static int getDayNum() { public static LocalDateTime weekEnd(int offset) {
int daynum = 0; return LocalDateTime.now().plusWeeks(offset).with(DayOfWeek.SUNDAY);
GregorianCalendar gd = new GregorianCalendar();
Date dt = gd.getTime();
GregorianCalendar gd1 = new GregorianCalendar(1900, 1, 1);
Date dt1 = gd1.getTime();
daynum = (int) ((dt.getTime() - dt1.getTime()) / (24 * 60 * 60 * 1000));
return daynum;
} }
/** /**
* getDayNum的逆方法(用于处理Excel取出的日期格式数据等) * 获取某月的开始日期
* *
* @param day * @param offset 0本月，1下个月，-1上个月，依次类推
* @return * @return
*/ */
public static Date getDateByNum(int day) { public static LocalDateTime monthStart(int offset) {
GregorianCalendar gd = new GregorianCalendar(1900, 1, 1); return LocalDateTime.now().plusMonths(offset).with(TemporalAdjusters.firstDayOfMonth()).withHour(0).withMinute(0).withSecond(0);
Date date = gd.getTime();
date = nextDay(date, day);
return date;
} }
/** /**
* 获取本月第一天 * 获取某月的结束日期
* *
* @param format * @param offset 0本月，1下个月，-1上个月，依次类推
* @return * @return
*/ */
public static String getFirstDayOfMonth(String format) { public static LocalDateTime monthEnd(int offset) {
Calendar cal = Calendar.getInstance(); return LocalDateTime.now().plusMonths(offset).with(TemporalAdjusters.lastDayOfMonth()).withHour(23).withMinute(59).withSecond(59).withNano(999999999);
cal.set(Calendar.DATE, 1);
return dateToString(cal.getTime(), format);
} }
/** /**
* 获取本月最后一天 * 获取某季度的开始日期
* 季度一年四季， 第一季度：2月-4月， 第二季度：5月-7月， 第三季度：8月-10月， 第四季度：11月-1月
* *
* @param format * @param offset 0本季度，1下个季度，-1上个季度，依次类推
* @return * @return
*/ */
public static String getLastDayOfMonth(String format) { public static LocalDate quarterStart(int offset) {
Calendar cal = Calendar.getInstance(); final LocalDate date = LocalDate.now().plusMonths(offset * 3);
cal.set(Calendar.DATE, 1); int month = date.getMonth().getValue();//当月
cal.add(Calendar.MONTH, 1); int start = 0;
cal.add(Calendar.DATE, -1); if (month >= 2 && month <= 4) {//第一季度
return dateToString(cal.getTime(), format); start = 2;
} } else if (month >= 5 && month <= 7) {//第二季度
start = 5;
public static int getWeekByDate(String day) { } else if (month >= 8 && month <= 10) {//第三季度
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); start = 8;
Date date; } else if (month >= 11) {//第四季度
try { start = 11;
date = format.parse(day); } else {//第四季度
Calendar calendar = Calendar.getInstance(); start = 11;
calendar.setFirstDayOfWeek(Calendar.MONDAY); month = 13;
calendar.setTime(date);
return calendar.get(Calendar.WEEK_OF_YEAR);
} catch (ParseException e) {
e.printStackTrace();
} }
return 0; return date.plusMonths(start - month).with(TemporalAdjusters.firstDayOfMonth());
}
public static String getDate(String day) {
SimpleDateFormat format = new SimpleDateFormat("yyyy/MM/dd");
SimpleDateFormat format1 = new SimpleDateFormat(FORMAT_ONE);
Date date;
try {
date = format.parse(day);
return format1.format(date);
} catch (ParseException e) {
e.printStackTrace();
}
return day;
}
public static String getDate1(String day) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat format1 = new SimpleDateFormat(LONG_DATE_FORMAT);
Date date;
try {
date = format.parse(day);
return format1.format(date);
} catch (ParseException e) {
e.printStackTrace();
}
return day;
}
public static String getDate2(String day) {
SimpleDateFormat format = new SimpleDateFormat("yyyy/MM/dd");
SimpleDateFormat format1 = new SimpleDateFormat(FORMAT_ONE);
Date date;
try {
date = format.parse(day);
return format1.format(date);
} catch (ParseException e) {
e.printStackTrace();
}
return day;
}
public static String getDateOfMaxDay(String day) {
SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy");
SimpleDateFormat format1 = new SimpleDateFormat(LONG_DATE_FORMAT);
Date date;
try {
date = format.parse(day);
return format1.format(date) + " 23:59:59";
} catch (ParseException e) {
e.printStackTrace();
}
return day;
}
static SimpleDateFormat format = new SimpleDateFormat(LONG_DATE_FORMAT);
public static String getCurrentDate() {
return format.format(new Date()) + " 23:59:59";
}
public static String getFullDate(Timestamp day) {
return format.format(day);
} }
/** /**
* 获取过去第几天的日期 * 获取某年的开始日期
* *
* @param past * @param offset 0今年，1明年，-1去年，依次类推
* @return * @return
*/ */
public static String getPastDate(int past) { public static LocalDateTime yearStart(int offset) {
Calendar calendar = Calendar.getInstance(); return LocalDateTime.now().plusYears(offset).with(TemporalAdjusters.firstDayOfYear());
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - past);
Date today = calendar.getTime();
SimpleDateFormat format = new SimpleDateFormat(LONG_DATE_FORMAT);
return format.format(today);
} }
/** /**
* 获取过去第几天的日期 * 获取某年的结束日期
* *
* @param past * @param offset 0今年，1明年，-1去年，依次类推
* @return * @return
*/ */
public static String getPastDate1(int past) { public static LocalDateTime yearEnd(int offset) {
Calendar calendar = Calendar.getInstance(); return LocalDateTime.now().plusYears(offset).with(TemporalAdjusters.lastDayOfYear());
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - past);
Date today = calendar.getTime();
SimpleDateFormat format = new SimpleDateFormat(FORMAT_ONE);
return format.format(today);
} }
/** /**
* 当前日期获得本月的所有日期 * 计算两个时间相差天数
* *
* @param date * @param day1 时间1
* @return * @param day2 时间2
*/ * @return 相差天数
public static List<String> getAllTheDateOftheMonth(Date date) {
List<String> list = new ArrayList<String>();
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.set(Calendar.DATE, 1);
int month = cal.get(Calendar.MONTH);
while (cal.get(Calendar.MONTH) == month) {
list.add(df.format(cal.getTime()));
cal.add(Calendar.DATE, 1);
}
return list;
}
/**
* 取得指定日期过 day 天后的日期 (当 day 为负数表示指日期之前);
*
* @param millis 日期 为null时表示当天
* @param day 相加(相减)的月数
*/ */
public static long nextDay(Long millis, int day) { public static long intervalDay(LocalDateTime day1, LocalDateTime day2) {
Calendar cal = Calendar.getInstance(); return Duration.between(day1, day2).toDays();
if (millis != null) {
cal.setTimeInMillis(millis);
}
cal.add(Calendar.DAY_OF_YEAR, day);
return cal.getTimeInMillis();
} }
/** /**
* 将Date日期转换为 yyyyMMdd * 计算两个时间相差天数
* *
* @return 字符串 yyyyMMdd * @param day1 格式化的时间1
* @param day2 格式化的时间2
* @param format 格式化参数
* @return 相差天数
*/ */
public static String dateToString(Date date) { public static long intervalDay(String day1, String day2, String format) {
// Date currentTime = new Date(); return intervalDay(transferLocalDateTime(day1, format), transferLocalDateTime(day2, format));
SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
String dateString = formatter.format(date);
return dateString;
} }
/** /**
* 获取两个日期之间的日期 * 获取当前日期
* *
* @param start 开始日期 * @param format 格式化参数
* @param end 结束日期 * @return 格式化后的日期
* @param type 日期类型
* @return 日期集合
*/
public static List<Date> getBetweenDates(Date start, Date end, String type) {
List<Date> result = new ArrayList<Date>();
Calendar tempStart = Calendar.getInstance();
tempStart.setTime(start);
Calendar tempEnd = Calendar.getInstance();
tempEnd.setTime(end);
if ("year".equals(type)) {
tempEnd.add(Calendar.YEAR, 1);
} else if ("month".equals(type)) {
tempEnd.add(Calendar.MONTH, 1);
} else if ("day".equals(type)) {
tempEnd.add(Calendar.DAY_OF_YEAR, 1);
}
while (tempStart.before(tempEnd)) {
result.add(tempStart.getTime());
if ("year".equals(type)) {
tempStart.add(Calendar.YEAR, 1);
} else if ("month".equals(type)) {
tempStart.add(Calendar.MONTH, 1);
} else if ("day".equals(type)) {
tempStart.add(Calendar.DAY_OF_YEAR, 1);
}
}
return result;
}
/**
* @param date
* @param number 想要获取的日期与传入日期的差值 比如想要获取传入日期前四天的日期 day=-4即可
* @param type
* @return
*/ */
public static Date getSomeDay(Date date, int number, String type) { public static String getCurrentDate(String format) {
Calendar calendar = Calendar.getInstance(); return LocalDateTime.now().format(DateTimeFormatter.ofPattern(format));
calendar.setTime(date);
if ("year".equals(type)) {
calendar.add(Calendar.YEAR, number);
} else if ("month".equals(type)) {
calendar.add(Calendar.MONTH, number);
} else if ("day".equals(type)) {
calendar.add(Calendar.DATE, number);
}
return calendar.getTime();
} }
} }
src/main/java/cn/wisenergy/chnmuseum/party/conf/WebMvcConfig.java
View file @ d9c5bb47
package cn.wisenergy.chnmuseum.party.conf; package cn.wisenergy.chnmuseum.party.conf;
import javax.annotation.PostConstruct; import cn.wisenergy.chnmuseum.party.common.mvc.*;
import javax.annotation.Resource;
import cn.wisenergy.chnmuseum.party.common.mvc.StringToDateConverter;
import cn.wisenergy.chnmuseum.party.common.mvc.StringToIntegerConverter;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.support.GenericConversionService; import org.springframework.core.convert.support.GenericConversionService;
import org.springframework.web.bind.support.ConfigurableWebBindingInitializer; import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter; import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
@Configuration @Configuration
public class WebMvcConfig { public class WebMvcConfig {
...@@ -28,6 +27,10 @@ public class WebMvcConfig { ...@@ -28,6 +27,10 @@ public class WebMvcConfig {
.getConversionService(); .getConversionService();
genericConversionService.addConverter(new StringToIntegerConverter()); genericConversionService.addConverter(new StringToIntegerConverter());
genericConversionService.addConverter(new StringToDateConverter()); genericConversionService.addConverter(new StringToDateConverter());
genericConversionService.addConverter(new StringToLocalDateTimeConverter());
genericConversionService.addConverter(new StringToLocalDateConverter());
genericConversionService.addConverter(new StringToLocalTimeConverter());
} }
} }
......
src/main/java/cn/wisenergy/chnmuseum/party/web/controller/base/BaseController.java
View file @ d9c5bb47
...@@ -12,7 +12,9 @@ import org.slf4j.LoggerFactory; ...@@ -12,7 +12,9 @@ import org.slf4j.LoggerFactory;
import javax.annotation.Resource; import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.io.Serializable; import java.io.Serializable;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map;
/** /**
* controller 基类控制器 * controller 基类控制器
...@@ -45,6 +47,70 @@ public class BaseController implements Serializable { ...@@ -45,6 +47,70 @@ public class BaseController implements Serializable {
return new Page<>(_index, _size); return new Page<>(_index, _size);
} }
/**
* 添加数据到结果对象中
*
* @param obj 封装接口集合参数
* @return map
*/
protected Map<String, Object> getResult(Object obj) {
Map<String, Object> map = new HashMap<>();
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_CODE.getKey(), cn.wisenergy.datastation.common.core.utils.exception.RESPONSE_CODE_ENUM.REQUEST_SUCCESS.getCode());
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_BODY.getKey(), obj);
return map;
}
/**
* 返回成功
*
* @return map
*/
protected Map<String, Object> getSuccessResult() {
Map<String, Object> map = new HashMap<>();
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_CODE.getKey(), cn.wisenergy.datastation.common.core.utils.exception.RESPONSE_CODE_ENUM.REQUEST_SUCCESS.getCode());
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_MSG.getKey(), cn.wisenergy.datastation.common.core.utils.exception.RESPONSE_CODE_ENUM.REQUEST_SUCCESS.getMsg());
return map;
}
/**
* 返回失败
*
* @param code 状态码
* @param msg 失败原因
* @return map
*/
protected Map<String, Object> getFailResult(String code, String msg) {
Map<String, Object> map = new HashMap<>();
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_CODE.getKey(), code);
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_MSG.getKey(), msg);
return map;
}
/**
* 返回失败
*
* @param responseCodeEnum 特定状态码
* @return map
*/
protected Map<String, Object> getFailResult(cn.wisenergy.datastation.common.core.utils.exception.RESPONSE_CODE_ENUM responseCodeEnum) {
Map<String, Object> map = new HashMap<>();
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_CODE.getKey(), responseCodeEnum.getCode());
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_MSG.getKey(), responseCodeEnum.getMsg());
return map;
}
/**
* 返回失败
*
* @return map
*/
protected Map<String, Object> getFailResult() {
Map<String, Object> map = new HashMap<>();
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_CODE.getKey(), cn.wisenergy.datastation.common.core.utils.exception.RESPONSE_CODE_ENUM.SERVER_ERROR.getCode());
map.put(cn.wisenergy.datastation.common.core.enums.RESULT_INFO_ENUM.RESULT_MSG.getKey(), cn.wisenergy.datastation.common.core.utils.exception.RESPONSE_CODE_ENUM.SERVER_ERROR.getMsg());
return map;
}
/** /**
* JSON 过滤相关字段 * JSON 过滤相关字段
* *
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment