Ausnahmebehandlung

Ausnahmebehandlung in einer REST API mit Spring Boot ist ein entscheidender Aspekt der Entwicklung, der eine effektive Verwaltung von Fehlern ermöglicht und Kunden über Probleme informiert, die auf dem Server aufgetreten sind. Lassen Sie uns diesen Prozess im Detail untersuchen.

Wie hilft es, den Kunden über Fehler zu informieren?

Fehlerbehandlung in einer REST API hilft, das Format der Fehlermeldungen zu standardisieren, was es Kunden erleichtert, mit den Antworten zu arbeiten. Dies wiederum informiert sie über die Gründe für Fehler, sodass Kunden verstehen können, was schiefgelaufen ist und wie sie das Problem beheben können.

Darüber hinaus ermöglicht eine solche Behandlung die Unterscheidung zwischen Fehlertypen, wie Validierungsfehler oder Zugriffsprobleme, wodurch die Fehlermeldungen genauer und nützlicher werden.

Implementierung der Ausnahmebehandlung mit Anmerkungen

Spring Boot bietet mehrere Werkzeuge für die Fehlerbehandlung. Die wichtigsten sind die Annotationen @ControllerAdvice und @ExceptionHandler.

Die Annotation @ControllerAdvice ermöglicht es Ihnen, globale Ausnahme-Handler für alle Controller in der Anwendung zu definieren, was hilft, die Fehlerbehandlung zu zentralisieren und Code-Duplikation zu vermeiden.

Innerhalb einer mit @ControllerAdvice annotierten Klasse geben mit @ExceptionHandler annotierte Methoden an, welche Arten von Ausnahmen eine bestimmte Methode behandeln soll. Dies vereinfacht das Fehlermanagement und macht den Code sauberer und organisierter.

GlobalExceptionHandler


              12345678
            
@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ApiException.class)
    public ResponseEntity<?> handleException(ApiException ex) {
         // error handling
    }
}

Innerhalb dieser Klasse wird die Methode handleException() aufgerufen, wenn eine Ausnahme vom Typ ApiException in der Anwendung auftritt. Die Annotation @ExceptionHandler(ApiException.class) zeigt an, dass diese Methode Ausnahmen dieses spezifischen Typs behandelt.

Erstellen einer benutzerdefinierten Ausnahme

Aber was genau ist die ApiException? Es ist eine benutzerdefinierte Ausnahme, die speziell für unsere API erstellt wurde, und wir können unsere eigenen Ausnahmen erstellen und sie in unserer REST-API verwenden.

Sie können mehr über das Erstellen Ihrer eigenen benutzerdefinierten Ausnahmen hier erfahren.

ApiException


              12345678910111213141516
            
public class ApiException extends RuntimeException {

    // HTTP status code associated with this exception
    private final HttpStatus httpStatus;

    // Constructor to initialize the exception with a message and an HTTP status
    public ApiException(String message, HttpStatus httpStatus) {
        super(message);
        this.httpStatus = httpStatus;
    }

    // Getter method to retrieve the HTTP status
    public HttpStatus getHttpStatus() {
        return httpStatus;
    }
}

Dieser Code definiert die ApiException Klasse, die erweitert RuntimeException und enthält ein zusätzliches Feld httpStatus zum Speichern des HTTP-Status. Der Konstruktor der Klasse nimmt eine Nachricht und einen HTTP-Status, die dann an den Basiskonstruktor übergeben und im httpStatus Feld gespeichert werden.

Danach können wir eine Ausnahme aus unserer Anwendung werfen:

Main


              1234567891011
            
public BookResponseDTO updateBook(String id, BookRequestDTO book) {
    Book modelBook = MapperBook.dtoRequestToModel(book);
    Book repositoryBook = bookRepository.updateBook(id, modelBook);

    // If the book was not found in the repository, throw an ApiException with a NOT_FOUND status
    if (repositoryBook == null) {
        throw new ApiException("Not found book by id: " + id, HttpStatus.NOT_FOUND);
    }

    return MapperBook.modelToResponseDto(repositoryBook);
}

Diese Art von Ausnahme wird von einer Methode handleException(ApiException ex) abgefangen, die dafür entwickelt wurde, und innerhalb dieser Methode können wir die Logik zur Verwaltung der Ausnahme definieren.

Die Logik, die wir implementieren möchten, besteht darin, Ausnahmen im Zusammenhang mit der API abzufangen und eine strukturierte Antwort mit Fehlerinformationen zusammen mit dem entsprechenden HTTP-Status zurückzugeben.

Main


              123456789
            
@ExceptionHandler(ApiException.class)
public ResponseEntity<?> handleException(ApiException ex) {
    return new ResponseEntity<>(ErrorResponse
            .builder()
            .error(ex.getMessage())
            .build(),
            ex.getHttpStatus()
    );
}

Dieser Code behandelt die ApiException, indem er ein ResponseEntity mit Fehlerinformationen erstellt. Die handleException()-Methode konstruiert ein ErrorResponse-Objekt mit der Nachricht aus der Ausnahme und setzt den HTTP-Status aus dem httpStatus-Feld der Ausnahme und gibt dies an den Client zurück.

Wir haben das httpStatus-Feld initialisiert, als wir die Ausnahme in unserer Anwendung ausgelöst haben.

ErrorResponse ist eine Klasse, die verwendet wird, um Informationen über den Fehler bereitzustellen. Es enthält ein error-Feld, das die Fehlerbeschreibung anzeigt und mit den Annotationen @Data und @Builder erstellt wird.

ErrorResponse


              12345
            
@Data
@Builder
public class ErrorResponse {
  private String error;
}

Die @Builder Annotation von Lombok vereinfacht die Objekterstellung durch die Implementierung des Builder-Musters. Sie ermöglicht eine lesbarere und wartbarere Weise, Objekte zu konstruieren, insbesondere solche mit vielen Parametern. Zum Beispiel können Sie eine ErrorResponse-Instanz so erstellen:

Die builder() Methode initialisiert einen neuen Builder für die ErrorResponse Klasse. Die error("ERROR") Methode setzt das error Feld auf "ERROR", und die build() Methode konstruiert das endgültige ErrorResponse Objekt mit dem angegebenen Wert.

Fehlerbehandlung in unserer Anwendung

Zusammenfassung

Fehlerbehandlung in einer REST-API zentralisiert das Fehlermanagement, indem sie ein konsistentes Antwortformat für den Client bereitstellt. Dies vereinfacht das Verständnis und die Handhabung von Fehlern, da Clients klare und strukturierte Nachrichten erhalten.

Die Verwendung von @ControllerAdvice und @ExceptionHandler Annotations ermöglicht die Anpassung, wie verschiedene Ausnahmen behandelt werden, während benutzerdefinierte Ausnahmen zusätzliche Informationen wie den HTTP-Status enthalten können.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 5