如何管理Spring中过滤器中引发的异常?


106

我想使用通用的方式来管理5xx错误代码,特别是当整个Spring应用程序中的db关闭时。我想要一个漂亮的错误json而不是堆栈跟踪。

对于控制器,我有一个@ControllerAdvice针对不同异常的类,这也捕获了db在请求中间停止的情况。但这并不是全部。我也碰巧有一个自定义CorsFilter扩展名OncePerRequestFilter,在那里,当我打电话给doFilter我时CannotGetJdbcConnectionException,它将不受的管理@ControllerAdvice。我在网上阅读了几件事,这只会让我更加困惑。

所以我有很多问题:

  • 我是否需要实施自定义过滤器?我找到了,ExceptionTranslationFilter但这只能处理AuthenticationExceptionAccessDeniedException
  • 我想实现自己的实现HandlerExceptionResolver,但这使我感到怀疑,我没有任何自定义异常要管理,必须有比这更明显的方法。我还尝试添加一个try / catch并调用的实现HandlerExceptionResolver(应该足够好,我的例外没有什么特别的),但这在响应中不返回任何内容,我得到一个状态200和一个空主体。

有什么好办法解决这个问题吗?谢谢


我们可以重写Spring Boot的BasicErrorController。我在这里写过
Sanjay,

Answers:


83

这就是我所做的:

我在这里阅读了有关过滤器的基础知识,并且发现需要创建一个自定义过滤器,该过滤器将首先出现在过滤器链中,并且将尝试捕获所有可能在此处发生的运行时异常。然后,我需要手动创建json并将其放入响应中。

所以这是我的自定义过滤器:

public class ExceptionHandlerFilter extends OncePerRequestFilter {

    @Override
    public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try {
            filterChain.doFilter(request, response);
        } catch (RuntimeException e) {

            // custom error response class used across my project
            ErrorResponse errorResponse = new ErrorResponse(e);

            response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
            response.getWriter().write(convertObjectToJson(errorResponse));
    }
}

    public String convertObjectToJson(Object object) throws JsonProcessingException {
        if (object == null) {
            return null;
        }
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(object);
    }
}

然后我在之前将其添加到web.xml中CorsFilter。而且有效!

<filter> 
    <filter-name>exceptionHandlerFilter</filter-name> 
    <filter-class>xx.xxxxxx.xxxxx.api.controllers.filters.ExceptionHandlerFilter</filter-class> 
</filter> 


<filter-mapping> 
    <filter-name>exceptionHandlerFilter</filter-name> 
    <url-pattern>/*</url-pattern> 
</filter-mapping> 

<filter> 
    <filter-name>CorsFilter</filter-name> 
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> 
</filter> 

<filter-mapping>
    <filter-name>CorsFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

您可以发布ErrorResponse类吗?
Shiva kumar,

@Shivakumar ErrorResponse类可能是具有简单代码/消息属性的简单DTO。
ratijas

19

我想根据@kopelitsa的答案提供解决方案。主要区别在于:

  1. 通过使用重用控制器异常处理HandlerExceptionResolver
  2. 在XML配置上使用Java配置

首先,您需要确保有一个类来处理在常规RestController / Controller中发生的异常(用@RestControllerAdvice或标记的类@ControllerAdvice和和用标记的方法@ExceptionHandler)。这可以处理您在控制器中发生的异常。这是使用RestControllerAdvice的示例:

@RestControllerAdvice
public class ExceptionTranslator {

    @ExceptionHandler(RuntimeException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ErrorDTO processRuntimeException(RuntimeException e) {
        return createErrorDTO(HttpStatus.INTERNAL_SERVER_ERROR, "An internal server error occurred.", e);
    }

    private ErrorDTO createErrorDTO(HttpStatus status, String message, Exception e) {
        (...)
    }
}

要在Spring Security过滤器链中重用此行为,您需要定义一个Filter并将其挂钩到您的安全配置中。筛选器需要将异常重定向到上面定义的异常处理。这是一个例子:

@Component
public class FilterChainExceptionHandler extends OncePerRequestFilter {

    private final Logger log = LoggerFactory.getLogger(getClass());

    @Autowired
    @Qualifier("handlerExceptionResolver")
    private HandlerExceptionResolver resolver;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        try {
            filterChain.doFilter(request, response);
        } catch (Exception e) {
            log.error("Spring Security Filter Chain Exception:", e);
            resolver.resolveException(request, response, null, e);
        }
    }
}

然后需要将创建的过滤器添加到SecurityConfiguration。您需要非常早地将其挂接到链中,因为不会捕获所有先前过滤器的异常。就我而言,在之前添加它是合理的LogoutFilter。请参阅官方文档中的默认过滤器链及其顺序。这是一个例子:

@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Autowired
    private FilterChainExceptionHandler filterChainExceptionHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .addFilterBefore(filterChainExceptionHandler, LogoutFilter.class)
            (...)
    }

}

17

我自己遇到了这个问题,我执行了以下步骤来重复使用我ExceptionController注释的内容,并将@ControllerAdviseExceptions附加到已注册的过滤器中。

显然有很多处理异常的方法,但就我而言,我希望异常由我处理,ExceptionController因为我很固执,而且因为我不想复制/粘贴相同的代码(即我有一些处理/日志记录)的代码ExceptionController)。我想返回优美的JSON响应,就像不是从过滤器抛出的其余异常一样。

{
  "status": 400,
  "message": "some exception thrown when executing the request"
}

无论如何,我设法利用了我的ExceptionHandler精力,并且不得不做一些额外的事情,如下步骤所示:

脚步


  1. 您有一个自定义过滤器,该过滤器可能会抛出异常,也可能不会抛出异常
  2. 您有一个Spring控制器,使用@ControllerAdviseMyExceptionController 处理异常

样例代码

//sample Filter, to be added in web.xml
public MyFilterThatThrowException implements Filter {
   //Spring Controller annotated with @ControllerAdvise which has handlers
   //for exceptions
   private MyExceptionController myExceptionController; 

   @Override
   public void destroy() {
        // TODO Auto-generated method stub
   }

   @Override
   public void init(FilterConfig arg0) throws ServletException {
       //Manually get an instance of MyExceptionController
       ApplicationContext ctx = WebApplicationContextUtils
                  .getRequiredWebApplicationContext(arg0.getServletContext());

       //MyExceptionHanlder is now accessible because I loaded it manually
       this.myExceptionController = ctx.getBean(MyExceptionController.class); 
   }

   @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;

        try {
           //code that throws exception
        } catch(Exception ex) {
          //MyObject is whatever the output of the below method
          MyObject errorDTO = myExceptionController.handleMyException(req, ex); 

          //set the response object
          res.setStatus(errorDTO .getStatus());
          res.setContentType("application/json");

          //pass down the actual obj that exception handler normally send
          ObjectMapper mapper = new ObjectMapper();
          PrintWriter out = res.getWriter(); 
          out.print(mapper.writeValueAsString(errorDTO ));
          out.flush();

          return; 
        }

        //proceed normally otherwise
        chain.doFilter(request, response); 
     }
}

现在,示例性的Spring Controller Exception在正常情况下进行处理(即通常不在Filter级别抛出的异常,我们要用于在Filter级别抛出的异常)

//sample SpringController 
@ControllerAdvice
public class ExceptionController extends ResponseEntityExceptionHandler {

    //sample handler
    @ResponseStatus(value = HttpStatus.BAD_REQUEST)
    @ExceptionHandler(SQLException.class)
    public @ResponseBody MyObject handleSQLException(HttpServletRequest request,
            Exception ex){
        ErrorDTO response = new ErrorDTO (400, "some exception thrown when "
                + "executing the request."); 
        return response;
    }
    //other handlers
}

与希望ExceptionController用于Exceptions过滤器的人共享解决方案。


10
好吧,我们欢迎您分享自己的解决方案:)
Raf

1
如果您要避免将Controller连接到过滤器中(我假设@ Bato-BairTsyrenov指的是该控制器),则可以轻松地将创建ErrorDTO的逻辑提取到其自己的@Component类中,并在Filter和控制器。
鲁迪格·舒尔茨

1
我并不完全同意您的看法,因为在您的过滤器中注入特定的控制器不是很干净。
psv

如本文所述,answer这是方法之一!我没有声称这是最好的方法。感谢您分享您的关注@psv,我确信社区会感谢您所考虑的解决方案:)
Raf

12

因此,这是基于上述答案的结合而进行的工作...我们已经进行了GlobalExceptionHandler注释,@ControllerAdvice并且我还想找到一种方法来重用该代码来处理来自过滤器的异常。

我能找到的最简单的解决方案是不理会异常处理程序,并按如下方式实现错误控制器:

@Controller
public class ErrorControllerImpl implements ErrorController {
  @RequestMapping("/error")
  public void handleError(HttpServletRequest request) throws Throwable {
    if (request.getAttribute("javax.servlet.error.exception") != null) {
      throw (Throwable) request.getAttribute("javax.servlet.error.exception");
    }
  }
}

因此,由异常引起的任何错误都首先通过,ErrorController并通过从@Controller上下文中重新抛出它们而将其重定向到异常处理程序,而其他任何错误(不是由异常直接引起的)则通过ErrorController不做任何修改。

有什么理由为什么这实际上是个坏主意?


1
感谢您现在测试此解决方案,但就我而言,它是完美的。
Maciej '18

干净,简单的春季引导2.0+附加功能,您应该添加 @Override public String getErrorPath() { return null; }
Fma

您可以使用javax.servlet.RequestDispatcher.ERROR_EXCEPTION代替“ javax.servlet.error.exception”
马克思

9

如果需要通用方法,可以在web.xml中定义错误页面:

<error-page>
  <exception-type>java.lang.Throwable</exception-type>
  <location>/500</location>
</error-page>

并在Spring MVC中添加映射:

@Controller
public class ErrorController {

    @RequestMapping(value="/500")
    public @ResponseBody String handleException(HttpServletRequest req) {
        // you can get the exception thrown
        Throwable t = (Throwable)req.getAttribute("javax.servlet.error.exception");

        // customize response to what you want
        return "Internal server error.";
    }
}

但是在其余的api中,使用位置重定向不是一个好的解决方案。
jmattheis

@jmattheis以上不是重定向。
holmis83

没错,我看到了位置,并认为它与http位置有关。然后这就是我所需要的(:
jmattheis 16-10-12

您是否可以添加与web.xml等效的Java配置?
k-den

1
@ k-den我认为当前规范中没有等效的Java配置,但是您可以将web.xml和Java配置混合使用。
holmis83 '17

5

这是我通过覆盖默认的Spring Boot / error处理程序的解决方案

package com.mypackage;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.web.ErrorAttributes;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

/**
 * This controller is vital in order to handle exceptions thrown in Filters.
 */
@RestController
@RequestMapping("/error")
public class ErrorController implements org.springframework.boot.autoconfigure.web.ErrorController {

    private final static Logger LOGGER = LoggerFactory.getLogger(ErrorController.class);

    private final ErrorAttributes errorAttributes;

    @Autowired
    public ErrorController(ErrorAttributes errorAttributes) {
        Assert.notNull(errorAttributes, "ErrorAttributes must not be null");
        this.errorAttributes = errorAttributes;
    }

    @Override
    public String getErrorPath() {
        return "/error";
    }

    @RequestMapping
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest aRequest, HttpServletResponse response) {
        RequestAttributes requestAttributes = new ServletRequestAttributes(aRequest);
        Map<String, Object> result =     this.errorAttributes.getErrorAttributes(requestAttributes, false);

        Throwable error = this.errorAttributes.getError(requestAttributes);

        ResponseStatus annotation =     AnnotationUtils.getAnnotation(error.getClass(), ResponseStatus.class);
        HttpStatus statusCode = annotation != null ? annotation.value() : HttpStatus.INTERNAL_SERVER_ERROR;

        result.put("status", statusCode.value());
        result.put("error", statusCode.getReasonPhrase());

        LOGGER.error(result.toString());
        return new ResponseEntity<>(result, statusCode) ;
    }

}

它会影响任何自动配置吗?
SametBaskıcı18年

请注意,HandlerExceptionResolver不一定处理异常。因此它可能会跌落为HTTP200。调用它之前使用response.setStatus(..)似乎更安全。
ThomasRS

5

只是为了补充提供的其他好的答案,我最近也想在一个简单的SpringBoot应用程序中使用一个错误/异常处理组件,其中包含可能引发异常的过滤器,以及可能从控制器方法引发的其他异常。

幸运的是,似乎没有什么可以阻止您将控制器建议与Spring默认错误处理程序的替代组合在一起,以提供一致的响应有效负载,允许您共享逻辑,检查来自过滤器的异常,捕获特定的服务引发的异常等。

例如


@ControllerAdvice
@RestController
public class GlobalErrorHandler implements ErrorController {

  @ResponseStatus(HttpStatus.BAD_REQUEST)
  @ExceptionHandler(ValidationException.class)
  public Error handleValidationException(
      final ValidationException validationException) {
    return new Error("400", "Incorrect params"); // whatever
  }

  @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  @ExceptionHandler(Exception.class)
  public Error handleUnknownException(final Exception exception) {
    return new Error("500", "Unexpected error processing request");
  }

  @RequestMapping("/error")
  public ResponseEntity handleError(final HttpServletRequest request,
      final HttpServletResponse response) {

    Object exception = request.getAttribute("javax.servlet.error.exception");

    // TODO: Logic to inspect exception thrown from Filters...
    return ResponseEntity.badRequest().body(new Error(/* whatever */));
  }

  @Override
  public String getErrorPath() {
    return "/error";
  }

}

3

当您要测试应用程序的状态时,如果出现问题,请返回HTTP错误,我建议您使用过滤器。下面的过滤器处理所有HTTP请求。Spring Boot中带有javax过滤器的最短解决方案。

在执行中可以有各种条件。在我的情况下,applicationManager测试应用程序是否准备就绪。

import ...ApplicationManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class SystemIsReadyFilter implements Filter {

    @Autowired
    private ApplicationManager applicationManager;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (!applicationManager.isApplicationReady()) {
            ((HttpServletResponse) response).sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, "The service is booting.");
        } else {
            chain.doFilter(request, response);
        }
    }

    @Override
    public void destroy() {}
}

2

阅读以上答案中建议的不同方法后,我决定使用自定义过滤器来处理身份验证异常。我可以使用以下方法使用错误响应类来处理响应状态和代码。

我创建了一个自定义过滤器,并使用addFilterAfter方法修改了我的安全配置,并将其添加到CorsFilter类之后。

@Component
public class AuthFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    //Cast the servlet request and response to HttpServletRequest and HttpServletResponse
    HttpServletResponse httpServletResponse = (HttpServletResponse) response;
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;

    // Grab the exception from the request attribute
    Exception exception = (Exception) request.getAttribute("javax.servlet.error.exception");
    //Set response content type to application/json
    httpServletResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);

    //check if exception is not null and determine the instance of the exception to further manipulate the status codes and messages of your exception
    if(exception!=null && exception instanceof AuthorizationParameterNotFoundException){
        ErrorResponse errorResponse = new ErrorResponse(exception.getMessage(),"Authetication Failed!");
        httpServletResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        PrintWriter writer = httpServletResponse.getWriter();
        writer.write(convertObjectToJson(errorResponse));
        writer.flush();
        return;
    }
    // If exception instance cannot be determined, then throw a nice exception and desired response code.
    else if(exception!=null){
            ErrorResponse errorResponse = new ErrorResponse(exception.getMessage(),"Authetication Failed!");
            PrintWriter writer = httpServletResponse.getWriter();
            writer.write(convertObjectToJson(errorResponse));
            writer.flush();
            return;
        }
        else {
        // proceed with the initial request if no exception is thrown.
            chain.doFilter(httpServletRequest,httpServletResponse);
        }
    }

public String convertObjectToJson(Object object) throws JsonProcessingException {
    if (object == null) {
        return null;
    }
    ObjectMapper mapper = new ObjectMapper();
    return mapper.writeValueAsString(object);
}
}

SecurityConfig类

    @Configuration
    public class JwtSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    AuthFilter authenticationFilter;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.addFilterAfter(authenticationFilter, CorsFilter.class).csrf().disable()
                .cors(); //........
        return http;
     }
   }

ErrorResponse类

public class ErrorResponse  {
private final String message;
private final String description;

public ErrorResponse(String description, String message) {
    this.message = message;
    this.description = description;
}

public String getMessage() {
    return message;
}

public String getDescription() {
    return description;
}}

0

您可以在catch块中使用以下方法:

response.sendError(HttpStatus.UNAUTHORIZED.value(), "Invalid token")

请注意,您可以使用任何HttpStatus代码和自定义消息。


-1

这很奇怪,因为@ControllerAdvice应该可以工作,您是否捕获了正确的Exception?

@ControllerAdvice
public class GlobalDefaultExceptionHandler {

    @ResponseBody
    @ExceptionHandler(value = DataAccessException.class)
    public String defaultErrorHandler(HttpServletResponse response, DataAccessException e) throws Exception {
       response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
       //Json return
    }
}

还尝试在CorsFilter中捕获此异常并发送500错误,类似这样

@ExceptionHandler(DataAccessException.class)
@ResponseBody
public String handleDataException(DataAccessException ex, HttpServletResponse response) {
    response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
    //Json return
}

在CorsFilter中处理异常是可以的,但不是很干净。实际上,我真正需要的是处理所有过滤器的异常
kopelitsa

35
Filter可能无法捕获异常,@ControllerAdvice因为in可能无法到达DispatcherServlet
Thanh Nguyen Van

-1

您无需为此创建自定义过滤器。我们通过创建扩展ServletException的自定义异常(从声明中显示的doFilter方法抛出)解决了这一问题。然后由我们的全局错误处理程序捕获并处理这些错误。

编辑:语法


您介意共享全局错误处理程序的代码段吗?
Neeraj Vernekar

它对我不起作用。我创建了自定义异常,该异常扩展了ServletException,并在ExceptionHandler中添加了对此异常的支持,但尚未在此处拦截。
马克思
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.