bug fixed

src/main/java/cn/wisenergy/chnmuseum/party/common/enum/RESPONSE_CODE_ENUM.java

+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

+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

+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

+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

+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

+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

+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

 package cn.wisenergy.chnmuseum.party.common.mvc;
 
-import java.text.SimpleDateFormat;
-import java.util.Date;
-
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.core.convert.converter.Converter;
 
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
 public class StringToDateConverter implements Converter<String, Date> {
+
 	private static final String dateFormat = "yyyy-MM-dd HH:mm:ss";
 	private static final String shortDateFormat = "yyyy-MM-dd";
 

src/main/java/cn/wisenergy/chnmuseum/party/common/mvc/StringToLocalDateConverter.java

+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

+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

+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

 package cn.wisenergy.chnmuseum.party.common.util;
 
-import java.sql.Timestamp;
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.ParsePosition;
-import java.text.SimpleDateFormat;
-import java.util.*;
-import java.util.regex.Pattern;
-
+import java.time.*;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAdjusters;
+import java.util.Date;
+import java.util.Locale;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * 日期工具类 - 基于LocalDateTime
+ */
 public class DateUtil {
 
     // 格式：年－月－日 小时：分钟：秒
     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_THREE = "yyyyMMdd-HHmmss";
-
     // 格式：年－月－日
     public static final String LONG_DATE_FORMAT = "yyyy-MM-dd";
 
@@ -30,798 +30,467 @@ public class DateUtil {
     // 格式：小时：分钟：秒
     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";
 
-    private static final DateFormat df = new SimpleDateFormat(FORMAT_ONE);
-
-    // 年的加减
-    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;
+    // 格式：年-月
+    public static final String Chinese_DATE_FORMAT = "yyyy年MM月dd日 HH:mm";
 
-    static final String dayNames[] = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
+    private static final ConcurrentMap<String, DateTimeFormatter> FORMATTER_CACHE = new ConcurrentHashMap<>();
 
-    public static long dateToLong(String datetime) throws ParseException {
-        return df.parse(datetime).getTime();
-    }
+    private static final int PATTERN_CACHE_SIZE = 500;
 
     /**
-     * 获取指定年月的最大天数
+     * Date转换为格式化时间
      *
-     * @param year
-     * @param month
+     * @param date    date
+     * @param pattern 格式
      * @return
      */
-    public static int getLastDay(int year, int month) {
-        int day = 1;
-        Calendar cal = Calendar.getInstance();
-        cal.set(year, month - 1, day);
-        int last = cal.getActualMaximum(Calendar.DATE);
-        System.out.println(last);
-        return last;
+    public static String format(Date date, String pattern) {
+        return format(LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()), pattern);
     }
 
     /**
-     * 得到指定日期所在月份天数的集合
+     * localDateTime转换为格式化时间
      *
-     * @param date
+     * @param localDateTime localDateTime
+     * @param pattern       格式
      * @return
      */
-    public static int[] getMonthDays(String date) {
-        Calendar calendar = Calendar.getInstance();
-        calendar.set(Calendar.YEAR, Integer.parseInt(date.substring(0, 4)));
-        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;
-    }
-
-    /**
-     * 获取一年的所有月
-     */
-    public static int[] getMonths() {
-        int months[] = {};
-        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 format(LocalDateTime localDateTime, String pattern) {
+        DateTimeFormatter formatter = createCacheFormatter(pattern);
+        return localDateTime.format(formatter);
     }
 
     /**
-     * 根据日期 找到对应日期的 星期
-     */
-    public static String getDayOfWeekByDate(String date) {
-        String dayOfweek = "-1";
-        try {
-            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() {
-    }
-
-    /**
-     * 把符合日期格式的字符串转换为日期类型
+     * localDateTime转换为格式化时间
      *
-     * @param dateStr
+     * @param localDateTime localDateTime
      * @return
      */
-    public static Date stringtoDate(String dateStr, String format) {
-        Date d = null;
-        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;
+    public static String format(LocalDateTime localDateTime) {
+        DateTimeFormatter formatter = createCacheFormatter(FORMAT_ONE);
+        return localDateTime.format(formatter);
     }
 
     /**
-     * 把日期转换为字符串
+     * 格式化字符串转为Date
      *
-     * @param date
+     * @param time    格式化时间
+     * @param pattern 格式
      * @return
      */
-    public static String dateToString(Date date, String format) {
-        String result = "";
-        SimpleDateFormat formater = new SimpleDateFormat(format);
-        try {
-            result = formater.format(date);
-        } catch (Exception e) {
-            // log.error(e);
-        }
-        return result;
-    }
+    public static Date parseDate(String time, String pattern) {
+        return Date.from(parseLocalDateTime(time, pattern).atZone(ZoneId.systemDefault()).toInstant());
 
-    /**
-     * 获取当前时间的指定格式
-     *
-     * @param format
-     * @return
-     */
-    public static String getCurrDate(String format) {
-        return dateToString(new Date(), format);
     }
 
     /**
-     * @param dateStr
-     * @param amount
-     * @return
-     */
-    public static String dateSub(int dateKind, String dateStr, int amount) {
-        Date date = stringtoDate(dateStr, FORMAT_ONE);
-        Calendar calendar = Calendar.getInstance();
-        calendar.setTime(date);
-        calendar.add(dateKind, amount);
-        return dateToString(calendar.getTime(), FORMAT_ONE);
-    }
-
-    /**
-     * 两个日期相减
+     * 格式化字符串转为LocalDateTime
      *
-     * @param firstTime
-     * @param secTime
-     * @return 相减得到的秒数
+     * @param time    格式化时间
+     * @param pattern 格式
+     * @return
      */
-    public static long timeSub(String firstTime, String secTime) {
-        long first = stringtoDate(firstTime, FORMAT_ONE).getTime();
-        long second = stringtoDate(secTime, FORMAT_ONE).getTime();
-        return (second - first) / 1000;
+    public static LocalDateTime parseLocalDateTime(String time, String pattern) {
+        DateTimeFormatter formatter = createCacheFormatter(pattern);
+        return LocalDateTime.parse(time, formatter);
     }
 
     /**
-     * 获得某月的天数
+     * 格式化字符串转为LocalDateTime
      *
-     * @param year  int
-     * @param month int
-     * @return int
+     * @param time    格式化时间
+     * @param pattern 格式
+     * @return localDateTime
      */
-    public static int getDaysOfMonth(String year, String month) {
-        int days = 0;
-        if (month.equals("1") || month.equals("3") || month.equals("5") || month.equals("7") || month.equals("8")
-                || month.equals("10") || month.equals("12")) {
-            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;
+    public static LocalDateTime transferLocalDateTime(String time, String pattern) {
+        DateTimeFormatter formatter = createCacheFormatter(pattern);
+        return LocalDate.parse(time, formatter).atStartOfDay();
     }
 
     /**
-     * 获取某年某月的天数
-     *
-     * @param year  int
-     * @param month int 月份[1-12]
-     * @return int
+     * java.util.Date --> java.time.LocalDateTime
      */
-    public static int getDaysOfMonth(int year, int month) {
-        Calendar calendar = Calendar.getInstance();
-        calendar.set(year, month - 1, 1);
-        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
+    public static LocalDateTime UDateToLocalDateTime(Date date) {
+        Instant instant = date.toInstant();
+        ZoneId zone = ZoneId.systemDefault();
+        return LocalDateTime.ofInstant(instant, zone);
     }
 
     /**
-     * 获得当前日期
+     * 将LocalDateTime转为自定义的时间格式的字符串
      *
-     * @return int
+     * @param localDateTime
+     * @param format
+     * @return
      */
-    public static int getToday() {
-        Calendar calendar = Calendar.getInstance();
-        return calendar.get(Calendar.DATE);
+    public static String getDateTimeAsString(LocalDateTime localDateTime, String format) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
+        return localDateTime.format(formatter);
     }
 
     /**
-     * 获得当前月份
+     * 将long类型的timestamp转为LocalDateTime
      *
-     * @return int
+     * @param timestamp
+     * @return
      */
-    public static int getToMonth() {
-        Calendar calendar = Calendar.getInstance();
-        return calendar.get(Calendar.MONTH) + 1;
+    public static LocalDateTime getDateTimeOfTimestamp(long timestamp) {
+        Instant instant = Instant.ofEpochMilli(timestamp);
+        ZoneId zone = ZoneId.systemDefault();
+        return LocalDateTime.ofInstant(instant, zone);
     }
 
     /**
-     * 获得当前年份
+     * 将LocalDateTime转为long类型的timestamp
      *
-     * @return int
+     * @param localDateTime
+     * @return
      */
-    public static int getToYear() {
-        Calendar calendar = Calendar.getInstance();
-        return calendar.get(Calendar.YEAR);
+    public static long getTimestampOfDateTime(LocalDateTime localDateTime) {
+        ZoneId zone = ZoneId.systemDefault();
+        Instant instant = localDateTime.atZone(zone).toInstant();
+        return instant.toEpochMilli();
     }
 
     /**
-     * 返回日期的天
+     * 将某时间字符串转为自定义时间格式的LocalDateTime
      *
-     * @param date Date
-     * @return int
+     * @param time
+     * @param format
+     * @return
      */
-    public static int getDay(Date date) {
-        Calendar calendar = Calendar.getInstance();
-        calendar.setTime(date);
-        return calendar.get(Calendar.DATE);
+    public static LocalDateTime parseStringToDateTime(String time, String format) {
+        DateTimeFormatter df = DateTimeFormatter.ofPattern(format, Locale.getDefault());
+        return LocalDateTime.parse(time, df);
     }
 
     /**
-     * 返回日期的年
+     * 计算两个日期之间相差的时间
      *
-     * @param date Date
-     * @return int
+     * @param startDate 较小的时间
+     * @param endDate   较大的时间
+     * @return 相差结果 X天X小时X分钟X秒
      */
-    public static int getYear(Date date) {
-        Calendar calendar = Calendar.getInstance();
-        calendar.setTime(date);
-        return calendar.get(Calendar.YEAR);
+    public static String differenceTimeStr(Date startDate, Date endDate) {
+        // 计算时间差
+        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);
+            sb.append("天");
+        }
+        if (0 != hour) {
+            sb.append(hour);
+            sb.append("小时");
+        }
+        if (0 != min) {
+            sb.append(min);
+            sb.append("分");
+        }
+        sb.append(sec);
+        sb.append("秒");
+        return String.valueOf(sb);
     }
 
     /**
-     * 返回日期的月份，1-12
+     * 时间戳转时间【毫秒】
      *
-     * @param date Date
-     * @return int
+     * @param timeStamp 时间戳【毫秒】
+     * @param pattern   格式化参数
+     * @return 格式化后的时间
      */
-    public static int getMonth(Date date) {
-        Calendar calendar = Calendar.getInstance();
-        calendar.setTime(date);
-        return calendar.get(Calendar.MONTH) + 1;
+    public static String msTimeStampConvertTime(long timeStamp, String pattern) {
+        Instant instant = Instant.ofEpochMilli(timeStamp);
+        ZoneId zone = ZoneId.systemDefault();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
+        return LocalDateTime.ofInstant(instant, zone).format(formatter);
     }
 
     /**
-     * 计算两个日期相差的天数，如果date2 > date1 返回正数，否则返回负数
+     * 时间戳转时间【秒】
      *
-     * @param date1 Date
-     * @param date2 Date
-     * @return long
+     * @param timeStamp 时间戳【秒】
+     * @param pattern   格式化参数
+     * @return 格式化后的时间
      */
-    public static long dayDiff(Date date1, Date date2) {
-        return (date2.getTime() - date1.getTime()) / 86400000;
+    public static String secondsTimeStampConvertTime(long timeStamp, String pattern) {
+        Instant instant = Instant.ofEpochSecond(timeStamp);
+        ZoneId zone = ZoneId.systemDefault();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
+        return LocalDateTime.ofInstant(instant, zone).format(formatter);
     }
 
     /**
-     * 比较两个日期的年差
+     * 将某时间字符串转为自定义时间格式的LocalDate
      *
-     * @param before
-     * @param after
+     * @param time
+     * @param format
      * @return
      */
-    public static int yearDiff(String before, String after) {
-        Date beforeDay = stringtoDate(before, LONG_DATE_FORMAT);
-        Date afterDay = stringtoDate(after, LONG_DATE_FORMAT);
-        return getYear(afterDay) - getYear(beforeDay);
+    public static LocalDate parseStringToDate(String time, String format) {
+        DateTimeFormatter df = DateTimeFormatter.ofPattern(format, Locale.getDefault());
+        return LocalDate.parse(time, df);
     }
 
     /**
-     * 比较指定日期与当前日期的差
+     * 将某时间字符串转为自定义时间格式的LocalDate
      *
-     * @param after
+     * @param time
+     * @param format
      * @return
      */
-    public static int yearDiffCurr(String after) {
-        Date beforeDay = new Date();
-        Date afterDay = stringtoDate(after, LONG_DATE_FORMAT);
-        return getYear(beforeDay) - getYear(afterDay);
+    public static LocalTime parseStringToTime(String time, String format) {
+        DateTimeFormatter df = DateTimeFormatter.ofPattern(format, Locale.getDefault());
+        return LocalTime.parse(time, df);
     }
 
     /**
-     * 比较指定日期与当前日期的差
+     * 在缓存中创建DateTimeFormatter
      *
-     * @param before
+     * @param pattern 格式
      * @return
-     * @author chenyz
      */
-    public static long dayDiffCurr(String before) {
-        Date currDate = DateUtil.stringtoDate(currDay(), LONG_DATE_FORMAT);
-        Date beforeDate = stringtoDate(before, LONG_DATE_FORMAT);
-        return (currDate.getTime() - beforeDate.getTime()) / 86400000;
-
+    private static DateTimeFormatter createCacheFormatter(String pattern) {
+        if (pattern == null || pattern.length() == 0) {
+            throw new IllegalArgumentException("Invalid pattern specification");
+        }
+        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 month
+     * @param offset 0今天，1明天，-1昨天，依次类推
      * @return
-     * @author chenyz
      */
-    public static int getFirstWeekdayOfMonth(int year, int month) {
-        Calendar c = Calendar.getInstance();
-        c.setFirstDayOfWeek(Calendar.SATURDAY); // 星期天为第一天
-        c.set(year, month - 1, 1);
-        return c.get(Calendar.DAY_OF_WEEK);
+    public static LocalDateTime minuteStart(int offset) {
+        return LocalDateTime.now().plusMinutes(offset).withSecond(0).withNano(0);
     }
 
     /**
-     * 获取每月的最后一周
+     * 获取某个时间段的开始时间
      *
-     * @param year
-     * @param month
+     * @param offset 0今天，1明天，-1昨天，依次类推
      * @return
-     * @author chenyz
      */
-    public static int getLastWeekdayOfMonth(int year, int month) {
-        Calendar c = Calendar.getInstance();
-        c.setFirstDayOfWeek(Calendar.SATURDAY); // 星期天为第一天
-        c.set(year, month - 1, getDaysOfMonth(year, month));
-        return c.get(Calendar.DAY_OF_WEEK);
+    public static LocalDateTime minuteEnd(int offset) {
+        return LocalDateTime.now().plusMinutes(offset).withSecond(59).withNano(999999999);
     }
 
     /**
-     * 获得当前日期字符串，格式"yyyy-MM-dd HH:mm:ss"
+     * 获取某个时间段的开始时间
      *
+     * @param offset 0今天，1明天，-1昨天，依次类推
      * @return
      */
-    public static String getNow() {
-        Calendar today = Calendar.getInstance();
-        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";
+    public static LocalDateTime hourStart(int offset) {
+        return LocalDateTime.now().plusHours(offset).withMinute(0).withSecond(0).withNano(0);
     }
 
     /**
-     * 根据生日获取星座
+     * 获取某个时间段的结束时间
      *
-     * @param birth YYYY-mm-dd
+     * @param offset 0今天，1明天，-1昨天，依次类推
      * @return
      */
-    public static String getAstro(String birth) {
-        if (!isDate(birth)) {
-            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) + "座";
+    public static LocalDateTime hourEnd(int offset) {
+        return LocalDateTime.now().plusHours(offset).withMinute(59)
+                .withSecond(59)
+                .withNano(999999999);
     }
 
     /**
-     * 判断日期是否有效,包括闰年的情况
+     * 获取某天的开始日期
      *
-     * @param date YYYY-mm-dd
+     * @param offset 0今天，1明天，-1昨天，依次类推
      * @return
      */
-    public static boolean isDate(String date) {
-        StringBuffer reg = new StringBuffer("^((\\d{2}(([02468][048])|([13579][26]))-?((((0?");
-        reg.append("[13578])|(1[02]))-?((0?[1-9])|([1-2][0-9])|(3[01])))");
-        reg.append("|(((0?[469])|(11))-?((0?[1-9])|([1-2][0-9])|(30)))|");
-        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 months 相加(相减)的月数
-     */
-    public static Date nextMonth(Date date, int months) {
-        Calendar cal = Calendar.getInstance();
-        if (date != null) {
-            cal.setTime(date);
-        }
-        cal.add(Calendar.MONTH, months);
-        return cal.getTime();
+    public static LocalDateTime dayStart(int offset) {
+        return LocalDate.now().plusDays(offset).atStartOfDay();
     }
 
     /**
-     * 取得指定日期过 day 天后的日期 (当 day 为负数表示指日期之前);
+     * 获取日期的结束时间
      */
-    public static Date nextDay(Date date, int day) {
-        Calendar cal = Calendar.getInstance();
-        if (date != null) {
-            cal.setTime(date);
-        }
-        cal.add(Calendar.DAY_OF_YEAR, day);
-        return cal.getTime();
+    public static LocalDateTime getDayStart(int offset) {
+        return LocalDateTime.now().plusDays(offset).withHour(0)
+                .withMinute(0)
+                .withSecond(0)
+                .withNano(0);
     }
 
     /**
-     * 取得距离今天 day 日的日期
+     * 获取某天的开始日期
      *
-     * @param day
-     * @param format
+     * @param offset 0今天，1明天，-1昨天，依次类推
      * @return
-     * @author chenyz
-     */
-    public static String nextDay(int day, String format) {
-        Calendar cal = Calendar.getInstance();
-        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) {
-        Calendar cal = Calendar.getInstance();
-        if (date != null) {
-            cal.setTime(date);
-        }
-        cal.add(Calendar.WEEK_OF_MONTH, week);
-        return cal.getTime();
+    public static LocalDateTime dayEnd(int offset) {
+        return LocalDateTime.of(LocalDate.now().plusDays(offset), LocalTime.MAX);//当天零点
     }
 
     /**
-     * 获取当前的日期(yyyy-MM-dd)
+     * 获取日期的结束时间
      */
-    public static String currDay() {
-        return DateUtil.dateToString(new Date(), DateUtil.LONG_DATE_FORMAT);
+    public static LocalDateTime getDayEnd(int offset) {
+        return LocalDateTime.now().plusDays(offset).withHour(23)
+                .withMinute(59)
+                .withSecond(59)
+                .withNano(999999999);
     }
 
     /**
-     * 获取昨天的日期
+     * 获取此刻与相对当天第day天的起始时间相隔的秒数。day为0表示今天的起始时间；1明天，2后天，-1昨天，-2前天等，依次例推。
      *
+     * @param day
      * @return
      */
-    public static String befoDay() {
-        return befoDay(DateUtil.LONG_DATE_FORMAT);
+    public static int ttl(int day) {
+        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
-     * @author chenyz
      */
-    public static String befoDay(String format) {
-        return DateUtil.dateToString(DateUtil.nextDay(new Date(), -1), format);
+    public static LocalDateTime weekStart(int offset) {
+        return LocalDateTime.now().plusWeeks(offset).with(DayOfWeek.MONDAY);
     }
 
     /**
-     * 获取明天的日期
-     */
-    public static String afterDay() {
-        return DateUtil.dateToString(DateUtil.nextDay(new Date(), 1), DateUtil.LONG_DATE_FORMAT);
-    }
-
-    /**
-     * 取得当前时间距离1900/1/1的天数
+     * 获取某周的开始日期
      *
+     * @param offset 0本周，1下周，-1上周，依次类推
      * @return
      */
-    public static int getDayNum() {
-        int daynum = 0;
-        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;
+    public static LocalDateTime weekEnd(int offset) {
+        return LocalDateTime.now().plusWeeks(offset).with(DayOfWeek.SUNDAY);
     }
 
     /**
-     * getDayNum的逆方法(用于处理Excel取出的日期格式数据等)
+     * 获取某月的开始日期
      *
-     * @param day
+     * @param offset 0本月，1下个月，-1上个月，依次类推
      * @return
      */
-    public static Date getDateByNum(int day) {
-        GregorianCalendar gd = new GregorianCalendar(1900, 1, 1);
-        Date date = gd.getTime();
-        date = nextDay(date, day);
-        return date;
+    public static LocalDateTime monthStart(int offset) {
+        return LocalDateTime.now().plusMonths(offset).with(TemporalAdjusters.firstDayOfMonth()).withHour(0).withMinute(0).withSecond(0);
     }
 
     /**
-     * 获取本月第一天
+     * 获取某月的结束日期
      *
-     * @param format
+     * @param offset 0本月，1下个月，-1上个月，依次类推
      * @return
      */
-    public static String getFirstDayOfMonth(String format) {
-        Calendar cal = Calendar.getInstance();
-        cal.set(Calendar.DATE, 1);
-        return dateToString(cal.getTime(), format);
+    public static LocalDateTime monthEnd(int offset) {
+        return LocalDateTime.now().plusMonths(offset).with(TemporalAdjusters.lastDayOfMonth()).withHour(23).withMinute(59).withSecond(59).withNano(999999999);
     }
 
     /**
-     * 获取本月最后一天
+     * 获取某季度的开始日期
+     * 季度一年四季， 第一季度：2月-4月， 第二季度：5月-7月， 第三季度：8月-10月， 第四季度：11月-1月
      *
-     * @param format
+     * @param offset 0本季度，1下个季度，-1上个季度，依次类推
      * @return
      */
-    public static String getLastDayOfMonth(String format) {
-        Calendar cal = Calendar.getInstance();
-        cal.set(Calendar.DATE, 1);
-        cal.add(Calendar.MONTH, 1);
-        cal.add(Calendar.DATE, -1);
-        return dateToString(cal.getTime(), format);
-    }
-
-    public static int getWeekByDate(String day) {
-        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
-        Date date;
-        try {
-            date = format.parse(day);
-            Calendar calendar = Calendar.getInstance();
-            calendar.setFirstDayOfWeek(Calendar.MONDAY);
-            calendar.setTime(date);
-            return calendar.get(Calendar.WEEK_OF_YEAR);
-        } catch (ParseException e) {
-            e.printStackTrace();
-        }
-        return 0;
-    }
-
-    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();
+    public static LocalDate quarterStart(int offset) {
+        final LocalDate date = LocalDate.now().plusMonths(offset * 3);
+        int month = date.getMonth().getValue();//当月
+        int start = 0;
+        if (month >= 2 && month <= 4) {//第一季度
+            start = 2;
+        } else if (month >= 5 && month <= 7) {//第二季度
+            start = 5;
+        } else if (month >= 8 && month <= 10) {//第三季度
+            start = 8;
+        } else if (month >= 11) {//第四季度
+            start = 11;
+        } else {//第四季度
+            start = 11;
+            month = 13;
         }
-        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);
+        return date.plusMonths(start - month).with(TemporalAdjusters.firstDayOfMonth());
     }
 
     /**
-     * 获取过去第几天的日期
+     * 获取某年的开始日期
      *
-     * @param past
+     * @param offset 0今年，1明年，-1去年，依次类推
      * @return
      */
-    public static String getPastDate(int past) {
-        Calendar calendar = Calendar.getInstance();
-        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);
+    public static LocalDateTime yearStart(int offset) {
+        return LocalDateTime.now().plusYears(offset).with(TemporalAdjusters.firstDayOfYear());
     }
 
     /**
-     * 获取过去第几天的日期
+     * 获取某年的结束日期
      *
-     * @param past
+     * @param offset 0今年，1明年，-1去年，依次类推
      * @return
      */
-    public static String getPastDate1(int past) {
-        Calendar calendar = Calendar.getInstance();
-        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);
+    public static LocalDateTime yearEnd(int offset) {
+        return LocalDateTime.now().plusYears(offset).with(TemporalAdjusters.lastDayOfYear());
     }
 
     /**
-     * 当前日期获得本月的所有日期
+     * 计算两个时间相差天数
      *
-     * @param date
-     * @return
+     * @param day1 时间1
+     * @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;
+    public static long intervalDay(LocalDateTime day1, LocalDateTime day2) {
+        return Duration.between(day1, day2).toDays();
     }
 
     /**
-     * 取得指定日期过 day 天后的日期 (当 day 为负数表示指日期之前);
+     * 计算两个时间相差天数
      *
-     * @param millis 日期 为null时表示当天
-     * @param day    相加(相减)的月数
+     * @param day1   格式化的时间1
+     * @param day2   格式化的时间2
+     * @param format 格式化参数
+     * @return 相差天数
      */
-    public static long nextDay(Long millis, int day) {
-        Calendar cal = Calendar.getInstance();
-        if (millis != null) {
-            cal.setTimeInMillis(millis);
-        }
-        cal.add(Calendar.DAY_OF_YEAR, day);
-        return cal.getTimeInMillis();
-    }
-
-    /**
-     * 将Date日期转换为 yyyyMMdd
-     *
-     * @return 字符串 yyyyMMdd
-     */
-    public static String dateToString(Date date) {
-//		Date currentTime = new Date();
-        SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
-        String dateString = formatter.format(date);
-        return dateString;
+    public static long intervalDay(String day1, String day2, String format) {
+        return intervalDay(transferLocalDateTime(day1, format), transferLocalDateTime(day2, format));
     }
 
     /**
-     * 获取两个日期之间的日期
+     * 获取当前日期
      *
-     * @param start 开始日期
-     * @param end   结束日期
-     * @param type  日期类型
-     * @return 日期集合
+     * @param format 格式化参数
+     * @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) {
-        Calendar calendar = Calendar.getInstance();
-        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();
+    public static String getCurrentDate(String format) {
+        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(format));
     }
 }

src/main/java/cn/wisenergy/chnmuseum/party/conf/WebMvcConfig.java

 package cn.wisenergy.chnmuseum.party.conf;
 
-import javax.annotation.PostConstruct;
-import javax.annotation.Resource;
-
-import cn.wisenergy.chnmuseum.party.common.mvc.StringToDateConverter;
-import cn.wisenergy.chnmuseum.party.common.mvc.StringToIntegerConverter;
+import cn.wisenergy.chnmuseum.party.common.mvc.*;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.convert.support.GenericConversionService;
 import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
 import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
 
+import javax.annotation.PostConstruct;
+import javax.annotation.Resource;
+
 @Configuration
 public class WebMvcConfig {
 
@@ -28,6 +27,10 @@ public class WebMvcConfig {
 					.getConversionService();
 			genericConversionService.addConverter(new StringToIntegerConverter());
 			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

@@ -12,7 +12,9 @@ import org.slf4j.LoggerFactory;
 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import java.io.Serializable;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * controller 基类控制器
@@ -45,6 +47,70 @@ public class BaseController implements Serializable {
         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 过滤相关字段
      *