Wie verwalte ich Ausnahmen, die im Frühjahr in Filtern ausgelöst werden?

Ich möchte eine generische Methode zum Verwalten von 5xx-Fehlercodes verwenden. Sagen wir speziell den Fall, dass die Datenbank in meiner gesamten Frühjahrsanwendung nicht verfügbar ist. Ich möchte einen hübschen Fehler json anstelle eines Stack-Trace.

Für die Controller habe ich eine @ControllerAdviceKlasse für die verschiedenen Ausnahmen und dies fängt auch den Fall ein, dass die Datenbank mitten in der Anfrage stoppt. Aber das ist nicht alles. Ich habe auch zufällig eine benutzerdefinierte CorsFilterErweiterung OncePerRequestFilterund dort, wenn ich doFilteranrufe, bekomme ich die CannotGetJdbcConnectionExceptionund es wird nicht von der verwaltet @ControllerAdvice. Ich habe online einige Dinge gelesen, die mich nur verwirrter gemacht haben.

Ich habe also viele Fragen:

• Muss ich einen benutzerdefinierten Filter implementieren? Ich fand das ExceptionTranslationFilteraber das handhabt nur AuthenticationExceptionoder AccessDeniedException.
• Ich dachte daran, meine eigenen zu implementieren HandlerExceptionResolver , aber das ließ mich zweifeln, ich habe keine benutzerdefinierte Ausnahme zu verwalten, es muss einen offensichtlicheren Weg als diesen geben. Ich habe auch versucht, einen try / catch hinzuzufügen und eine Implementierung von aufzurufen HandlerExceptionResolver(sollte gut genug sein, meine Ausnahme ist nichts Besonderes), aber dies gibt nichts in der Antwort zurück, ich erhalte einen Status 200 und einen leeren Körper.

Gibt es eine gute Möglichkeit, damit umzugehen? Vielen Dank

Das habe ich also getan:

Ich lese die Grundlagen über Filter hier und ich herausgefunden, dass ich einen benutzerdefinierten Filter erstellen , die zuerst in der Filterkette sein wird und versuchen Fang haben alle Laufzeitausnahmen zu fangen , die dort auftreten könnten. Dann muss ich den JSON manuell erstellen und in die Antwort einfügen.

Also hier ist mein benutzerdefinierter Filter:

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);
    }
}

Und dann habe ich es in der web.xml vor dem hinzugefügt CorsFilter. Und es funktioniert!

<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>

Ich wollte eine Lösung anbieten, die auf der Antwort von @kopelitsa basiert . Die Hauptunterschiede sind:

1. Wiederverwendung der Controller-Ausnahmebehandlung mithilfe von HandlerExceptionResolver.
2. Verwenden der Java-Konfiguration über die XML-Konfiguration

Zunächst müssen Sie sicherstellen, dass Sie über eine Klasse verfügen, die Ausnahmen behandelt, die in einem regulären RestController / Controller auftreten (eine Klasse, die mit @RestControllerAdviceoder @ControllerAdviceund Methoden mit Anmerkungen versehen ist @ExceptionHandler). Dies behandelt Ihre Ausnahmen, die in einem Controller auftreten. Hier ist ein Beispiel mit dem 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) {
        (...)
    }
}

Um dieses Verhalten in der Spring Security-Filterkette wiederzuverwenden, müssen Sie einen Filter definieren und in Ihre Sicherheitskonfiguration einbinden. Der Filter muss die Ausnahme zur oben definierten Ausnahmebehandlung umleiten. Hier ist ein Beispiel:

@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);
        }
    }
}

Der erstellte Filter muss dann zur SecurityConfiguration hinzugefügt werden. Sie müssen es sehr früh in die Kette einhängen, da nicht alle Ausnahmen des vorhergehenden Filters abgefangen werden. In meinem Fall war es vernünftig, es vor dem hinzuzufügen LogoutFilter. Die Standardfilterkette und ihre Reihenfolge finden Sie in den offiziellen Dokumenten . Hier ist ein Beispiel:

@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Autowired
    private FilterChainExceptionHandler filterChainExceptionHandler;

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

}

Ich bin selbst auf dieses Problem gestoßen und habe die folgenden Schritte ausgeführt, um mein ExceptionControllermit Anmerkungen versehenes Problem @ControllerAdvisefür Exceptionsdie Verwendung in einem registrierten Filter wiederzuverwenden .

Es gibt offensichtlich viele Möglichkeiten, Ausnahmen zu behandeln, aber in meinem Fall wollte ich, dass die Ausnahme von meinem behandelt wird, ExceptionControllerweil ich hartnäckig bin und auch nicht den gleichen Code kopieren / einfügen möchte (dh ich habe etwas Verarbeitung / Protokollierung Code in ExceptionController). Ich möchte die schöne JSONAntwort zurückgeben, genau wie die restlichen Ausnahmen, die nicht von einem Filter ausgelöst wurden.

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

Wie auch immer, ich habe es geschafft, meine zu nutzen, ExceptionHandlerund ich musste ein bisschen mehr tun, wie unten in Schritten gezeigt:

Schritte

1. Sie haben einen benutzerdefinierten Filter, der möglicherweise eine Ausnahme auslöst oder nicht
2. Sie haben einen Spring-Controller, der Ausnahmen mit @ControllerAdviseMyExceptionController behandelt

Beispielcode

//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); 
     }
}

Und jetzt der Beispiel-Spring-Controller, der Exceptionin normalen Fällen behandelt wird (dh Ausnahmen, die normalerweise nicht in der Filterebene ausgelöst werden, die wir für Ausnahmen verwenden möchten, die in einem Filter ausgelöst werden).

//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
}

Teilen Sie die Lösung mit denen, die sie ExceptionControllerfür Exceptionseinen Filter verwenden möchten .

Also, hier ist, was ich basierend auf einer Zusammenführung der obigen Antworten getan habe ... Wir hatten bereits eine GlobalExceptionHandlerAnnotation mit @ControllerAdviceund ich wollte auch einen Weg finden, diesen Code wiederzuverwenden, um Ausnahmen zu behandeln, die von Filtern stammen.

Die einfachste Lösung, die ich finden konnte, bestand darin, den Ausnahmebehandler in Ruhe zu lassen und einen Fehlercontroller wie folgt zu implementieren:

@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");
    }
  }
}

Fehler, die durch Ausnahmen verursacht werden, werden zuerst durchlaufen ErrorControllerund durch erneutes Auslösen aus einem @ControllerKontext an den Ausnahmebehandler weitergeleitet , während andere Fehler (die nicht direkt durch eine Ausnahme verursacht werden) ErrorControllerohne Änderung durchlaufen werden.

Gibt es Gründe, warum dies eigentlich eine schlechte Idee ist?

Wenn Sie einen generischen Weg wünschen, können Sie eine Fehlerseite in web.xml definieren:

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

Und fügen Sie Mapping in Spring MVC hinzu:

@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.";
    }
}

Dies ist meine Lösung, indem der Standard-Spring-Boot- / Fehlerhandler überschrieben wird

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) ;
    }

}

Nur um die anderen guten Antworten zu ergänzen, da ich kürzlich eine einzelne Fehler- / Ausnahmebehandlungskomponente in einer einfachen SpringBoot-App haben wollte, die Filter enthält, die Ausnahmen auslösen können, wobei andere Ausnahmen möglicherweise von Controller-Methoden ausgelöst werden.

Glücklicherweise scheint es nichts zu geben, das Sie daran hindert, Ihre Controller-Hinweise mit einer Überschreibung des Standard-Fehlerbehandlungsprogramms von Spring zu kombinieren, um konsistente Antwortnutzdaten bereitzustellen, Logik gemeinsam zu nutzen, Ausnahmen von Filtern zu überprüfen, bestimmte vom Dienst ausgelöste Ausnahmen abzufangen usw.

Z.B

@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";
  }

}

Wenn Sie einen Anwendungsstatus testen möchten und im Falle eines Problems einen HTTP-Fehler zurückgeben möchten, würde ich einen Filter vorschlagen. Der folgende Filter verarbeitet alle HTTP-Anforderungen. Die kürzeste Lösung in Spring Boot mit einem Javax-Filter.

In der Implementierung können verschiedene Bedingungen sein. In meinem Fall testet der applicationManager, ob die Anwendung bereit ist.

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() {}
}

Nachdem ich die in den obigen Antworten vorgeschlagenen Methoden durchgelesen hatte, entschied ich mich, die Authentifizierungsausnahmen mithilfe eines benutzerdefinierten Filters zu behandeln. Ich konnte den Antwortstatus und die Codes mithilfe einer Fehlerantwortklasse mit der folgenden Methode verarbeiten.

Ich habe einen benutzerdefinierten Filter erstellt und meine Sicherheitskonfiguration mithilfe der addFilterAfter-Methode geändert und nach der CorsFilter-Klasse hinzugefügt.

@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-Klasse

    @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-Klasse

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;
}}

Sie können die folgende Methode im catch-Block verwenden:

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

Beachten Sie, dass Sie einen beliebigen HttpStatus-Code und eine benutzerdefinierte Nachricht verwenden können.

Es ist seltsam, weil @ControllerAdvice funktionieren sollte. Fangen Sie die richtige Ausnahme?

@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
    }
}

Versuchen Sie auch, diese Ausnahme in CorsFilter abzufangen und 500 Fehler zu senden

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

Sie müssen hierfür keinen benutzerdefinierten Filter erstellen. Wir haben dieses Problem gelöst, indem wir benutzerdefinierte Ausnahmen erstellt haben, die die ServletException erweitern (die von der in der Deklaration gezeigten doFilter-Methode ausgelöst wird). Diese werden dann von unserem globalen Fehlerbehandler abgefangen und verarbeitet.

bearbeiten: Grammatik