全局拦截校验处理,可用于全新啊校验

public class JwtFeignRequestInterceptor implements RequestInterceptor {
    private static final Logger logger = LogManager.getLogger(JwtFeignRequestInterceptor.class);
    @Autowired(
        required = false
    )
    private HttpServletRequest request;

    public JwtFeignRequestInterceptor() {
    }

    public void apply(RequestTemplate requestTemplate) {
            try {
           
            } catch (IllegalStateException var4) {
                logger.error(var4);
                logger.info("未获取到jwt信息，无法进行身份认证，如果当前接口调用不需要身份认证则可以忽略该信息。");
            }
        }
        if (jwtHeader != null) {
            requestTemplate.header("Authorization", new String[]{jwtHeader});
        }

    }
}

@Bean
public FilterRegistrationBean angularJsGzipRequestFilter() {
    FilterRegistrationBean registration = new FilterRegistrationBean(new JSRequestFilter(), new ServletRegistrationBean[0]);
    registration.setName("JSRequestFilter");
    registration.addUrlPatterns(new String[]{"*.js"});
    return registration;
}

@Autowired
private  org.springframework.core.env.Environment

this.environment.getProperty("fastdfs.tracker_servers");

environment;

全局错误拦截

@org.springframework.web.bind.annotation.RestControllerAdvice

@ConditionalOnClass(name = {"com.netflix.hystrix.exception.HystrixBadRequestException"})

public class GlobalThrowableAdviceHandler {
    private static final Logger log = LoggerFactory.getLogger(GlobalThrowableAdviceHandler.class);

    public GlobalThrowableAdviceHandler() {
    }

    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler({Throwable.class})
    public ErrorInfo defaultErrorHandler(HttpServletRequest req, HttpServletResponse resp, Throwable e) {
  
        resp.setContentType("application/json");
        resp.setCharacterEncoding("UTF-8");
        ErrorInfo r = ErrorInfo.initErrorInfo(req, e);
        return r;
    }

    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler({BizException.class})
    public ErrorInfo defaultErrorHandler(HttpServletRequest req, HttpServletResponse resp, BizException e) {
        ErrorInfo r = ErrorInfo.initErrorInfo(req, e);
        resp.setContentType("application/json");
        resp.setCharacterEncoding("UTF-8");
        return r;
    }

    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler({MethodArgumentNotValidException.class})
    public ErrorInfo defaultErrorHandler(HttpServletRequest req, HttpServletResponse resp, MethodArgumentNotValidException e) {
        resp.setContentType("application/json");
        resp.setCharacterEncoding("UTF-8");
        ErrorInfo r = ErrorInfo.initErrorInfo(req, e);
        List<String> strErrorMessage = new ArrayList();
        e.getBindingResult().getAllErrors().stream().forEach((error) -> {
            strErrorMessage.add(error.getDefaultMessage());
        });
        r.setMessage(strErrorMessage);
        r.setBizError(true);
        return r;
    }
}

@Bean
@ConditionalOnMissingBean(name = {"baseAuthOrgService"})



优秀类

@RestControllerAdvice
public class DacExceptionHandler {

  private static final Logger log = LoggerFactory.getLogger(DacExceptionHandler.class);

  @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
  public RetDTO<String> handleHttpRequestMethodNotSupportedException(
      HttpRequestMethodNotSupportedException exception, HttpServletResponse httpServletResponse) {
    log.error("请求方法错误：", exception);
    httpServletResponse.setStatus(ResultCode.METHOD_NOT_ALLOWED.getCode());
    return RetDTO.failedResult(
        ResultCode.METHOD_NOT_ALLOWED.getCode(),
        "method: "
            + exception.getMethod()
            + ", "
            + "allow method: "
            + Arrays.toString(exception.getSupportedMethods()));
  }

  @ExceptionHandler({LimitException.class})
  public RetDTO<String> handleLimitException(
      LimitException exception, HttpServletResponse httpServletResponse) {
    log.error("方法被限流：", exception);
    httpServletResponse.setStatus(ResultCode.METHOD_NOT_ALLOWED.getCode());
    return RetDTO.failedResult(exception.getErrorCode(), exception.getErrorMessage());
  }

  @ExceptionHandler({BaseBizException.class})
  public RetDTO<String> handleBaseBizException(BaseBizException exception) {
    log.error("业务异常：", exception);
    return RetDTO.failedResult(exception.getErrorCode(), exception.getErrorMessage());
  }

  @ExceptionHandler({RemoteException.class})
  public RetDTO<String> handleBaseBizException(RemoteException exception) {
    log.error("远程调用异常：", exception);
    return RetDTO.failedResult(exception.getErrorCode(), exception.getErrorMsg());
  }

  @ExceptionHandler({MethodArgumentTypeMismatchException.class})
  public RetDTO<String> handleMethodArgumentTypeMismatchException(
      MethodArgumentTypeMismatchException exception, HttpServletResponse httpServletResponse) {
    log.error("请求参数验证错误：", exception);
    httpServletResponse.setStatus(ResultCode.PARAM_INVALID.getCode());
    return RetDTO.failedResult(
        ResultCode.PARAM_INVALID.getCode(),
        exception.getParameter().getParameterName() + ":" + exception.getValue());
  }

  @ExceptionHandler({BindException.class})
  public RetDTO<String> handleBindException(
      BindException exception, HttpServletResponse httpServletResponse) {
    log.error("请求方法错误：", exception);
    httpServletResponse.setStatus(ResultCode.PARAM_INVALID.getCode());
    StringBuilder sb = new StringBuilder();
    for (ObjectError error : exception.getAllErrors()) {
      sb.append(error.getDefaultMessage()).append("\n");
    }
    return RetDTO.failedResult(ResultCode.PARAM_INVALID.getCode(), sb.toString());
  }

  @ExceptionHandler({MethodArgumentNotValidException.class})
  public RetDTO<String> handleBindException(
      MethodArgumentNotValidException exception, HttpServletResponse httpServletResponse) {
    final BindingResult result = exception.getBindingResult();
    final List<FieldError> allErrors = result.getFieldErrors();
    StringBuilder sb = new StringBuilder();
    for (FieldError errorMessage : allErrors) {
      sb.append(errorMessage.getField())
          .append(": ")
          .append(errorMessage.getDefaultMessage())
          .append(", ");
    }
    log.error("请求参数验证错误：", exception);
    httpServletResponse.setStatus(ResultCode.PARAM_INVALID.getCode());
    return RetDTO.failedResult(ResultCode.PARAM_INVALID.getCode(), sb.toString());
  }

  @ExceptionHandler({HttpMediaTypeNotSupportedException.class})
  public RetDTO<String> handleMediaTypeNotSupportedException(
      HttpMediaTypeNotSupportedException exception, HttpServletResponse httpServletResponse) {
    log.error("请求类型不支持", exception);
    httpServletResponse.setStatus(ResultCode.MEDIA_TYPE_UNSUPPORTED.getCode());
    return RetDTO.failedResult(ResultCode.MEDIA_TYPE_UNSUPPORTED);
  }

  @ExceptionHandler({HttpMediaTypeNotAcceptableException.class})
  public RetDTO<String> handleHttpMediaTypeNotAcceptableException(
      HttpMediaTypeNotAcceptableException exception, HttpServletResponse httpServletResponse) {
    log.error("请求类型不支持", exception);
    httpServletResponse.setStatus(ResultCode.MEDIA_TYPE_NOT_ACCEPTABLE.getCode());
    return RetDTO.failedResult(ResultCode.MEDIA_TYPE_NOT_ACCEPTABLE);
  }

  @ExceptionHandler({ConversionNotSupportedException.class})
  public RetDTO<String> handleConversionNotSupportedException(
      ConversionNotSupportedException exception, HttpServletResponse httpServletResponse) {
    log.error("请求未找到合适转换器", exception);
    httpServletResponse.setStatus(ResultCode.CONVERSION_UNSUPPORTED.getCode());
    return RetDTO.failedResult(ResultCode.CONVERSION_UNSUPPORTED);
  }

  @ExceptionHandler({NoHandlerFoundException.class})
  public RetDTO<String> handleNoHandlerFoundException(
      NoHandlerFoundException exception, HttpServletResponse httpServletResponse) {
    log.error("请求路由未找到", exception);
    httpServletResponse.setStatus(ResultCode.PATH_NOT_FOUND.getCode());
    return RetDTO.failedResult(ResultCode.PATH_NOT_FOUND);
  }

  @ExceptionHandler({HttpMessageNotReadableException.class})
  public RetDTO<String> handleHttpMessageNotReadableException(
      HttpMessageNotReadableException exception, HttpServletResponse httpServletResponse) {
    log.error(" HTTP的信息无法被正确读取，可能并不是HTTP协议，或者使用了错误的流输入", exception);
    httpServletResponse.setStatus(ResultCode.MESSAGE_UNREADABLE.getCode());
    return RetDTO.failedResult(ResultCode.MESSAGE_UNREADABLE);
  }

  @ExceptionHandler({HttpMessageNotWritableException.class})
  public RetDTO<String> handleHttpMessageNotWritableException(
      HttpMessageNotWritableException exception, HttpServletResponse httpServletResponse) {
    log.error(" HTTP的信息无法被正确读取，可能并不是HTTP协议，或者使用了错误的流输入", exception);
    httpServletResponse.setStatus(ResultCode.MESSAGE_UNWRITABLE.getCode());
    return RetDTO.failedResult(ResultCode.MESSAGE_UNWRITABLE);
  }

  @ExceptionHandler({MessageException.class})
  public RetDTO<String> handleValueObjectException(
      MessageException exception, HttpServletResponse httpServletResponse) {
    log.error("ValueObject请求参数验证错误：", exception);
    httpServletResponse.setStatus(ResultCode.PARAM_INVALID.getCode());
    return RetDTO.failedResult(ResultCode.PARAM_INVALID.getCode(), exception.getMessage());
  }

  @ExceptionHandler(Exception.class)
  public RetDTO<String> handleException(
      Exception exception, HttpServletResponse httpServletResponse) {
    log.error("系统异常:", exception);
    httpServletResponse.setStatus(ResultCode.UNKNOWN.getCode());
    return RetDTO.failedResult(ResultCode.UNKNOWN);
  }
}