Undantagshantering i ett REST API med Spring Boot är en väsentlig aspekt av utvecklingen som möjliggör effektiv hantering av fel och informerar klienter om problem som har uppstått på servern. Vi ska undersöka denna process mer ingående.

Hur hjälper det att meddela klienten om fel?

Felsystem i ett REST API hjälper till att standardisera formatet för felsvar, vilket gör det enklare för klienter att arbeta med svaren. Detta informerar dem om orsakerna till felen, vilket gör det möjligt för klienter att förstå vad som gick fel och hur de kan åtgärda problemet.

Dessutom möjliggör sådan hantering differentiering mellan olika typer av fel, såsom valideringsfel eller åtkomstproblem, vilket gör felmeddelandena mer precisa och användbara.

Implementering av undantagshantering med hjälp av annoteringar

Spring Boot tillhandahåller flera verktyg för undantagshantering. De viktigaste är anoteringarna @ControllerAdvice och @ExceptionHandler.

Anoteringen @ControllerAdvice gör det möjligt att definiera globala undantagshanterare för alla controllers i applikationen, vilket hjälper till att centralisera felhantering och undvika kodupprepning.

I en klass anotterad med @ControllerAdvice anger metoder anotterade med @ExceptionHandler vilka typer av undantag en specifik metod ska hantera. Detta förenklar felhantering och gör koden renare och mer organiserad.

GlobalExceptionHandler.java


              12345678
            
@ControllerAdvice
public class GlobalExceptionHandler {

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

I denna klass kommer metoden handleException() att anropas när ett undantag av typen ApiException uppstår i applikationen. Anoteringen @ExceptionHandler(ApiException.class) indikerar att denna metod hanterar undantag av denna specifika typ.

Skapa ett anpassat undantag

Men vad är egentligen ApiException? Det är ett anpassat undantag som är skapat specifikt för vårt API, och vi kan skapa våra egna undantag och använda dem i vårt REST API.

Du kan läsa mer om hur du skapar egna anpassade undantag här.

ApiException.java


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

Denna kod definierar klassen ApiException, som ärver från RuntimeException och innehåller ett extra fält httpStatus för att lagra HTTP-status. Klassens konstruktor tar emot ett meddelande och en HTTP-status, vilka sedan skickas till baskonstruktorn och lagras i fältet httpStatus.

Efter detta kan vi kasta ett undantag från vår applikation:

Main.java


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

Denna typ av undantag fångas av en metod handleException(ApiException ex) som är avsedd att hantera det, och inom den metoden kan vi definiera logiken för att hantera undantaget.

Logiken vi vill implementera är att fånga undantag relaterade till API:et och returnera ett strukturerat svar som innehåller felinformation tillsammans med lämplig HTTP-status.

Main.java


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

Denna kod hanterar ApiException genom att skapa en ResponseEntity med felinformation. Metoden handleException() konstruerar ett ErrorResponse-objekt med meddelandet från undantaget och sätter HTTP-status från undantagets httpStatus-fält, och returnerar detta till klienten.

Vi initierade fältet httpStatus när vi kastade undantaget i vår applikation.

ErrorResponse är en klass som används för att tillhandahålla information om felet. Den innehåller ett error-fält som visar felbeskrivningen och skapas med hjälp av anoteringarna @Data och @Builder.

ErrorResponse.java


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

@Builder-anoteringen från Lombok förenklar objektgenerering genom att implementera Builder-mönstret. Det möjliggör ett mer läsbart och underhållbart sätt att konstruera objekt, särskilt de med många parametrar. Till exempel kan du skapa en instans av ErrorResponse på detta sätt:

ErrorResponse.builder().error("ERROR").build();

Metoden builder() initierar en ny builder för klassen ErrorResponse. Metoden error("ERROR") sätter fältet error till "ERROR", och metoden build() konstruerar det slutgiltiga ErrorResponse-objektet med det angivna värdet.

Felhantering i vår applikation

Sammanfattning

Undantagshantering i ett REST API centraliserar felhantering genom att tillhandahålla ett enhetligt svarformat till klienten. Detta förenklar förståelsen och hanteringen av fel, eftersom klienter får tydliga och strukturerade meddelanden.

Användningen av @ControllerAdvice och @ExceptionHandler annoteringar möjliggör anpassning av hur olika undantag hanteras, medan anpassade undantag kan inkludera ytterligare information, såsom HTTP-status.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 5

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Awesome!

Completion rate improved to 3.45

Svep för att visa menyn

Hur hjälper det att meddela klienten om fel?

Implementering av undantagshantering med hjälp av annoteringar

Spring Boot tillhandahåller flera verktyg för undantagshantering. De viktigaste är anoteringarna @ControllerAdvice och @ExceptionHandler.

GlobalExceptionHandler.java


              12345678
            
@ControllerAdvice
public class GlobalExceptionHandler {

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

Skapa ett anpassat undantag

Du kan läsa mer om hur du skapar egna anpassade undantag här.

ApiException.java


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

Efter detta kan vi kasta ett undantag från vår applikation:

Main.java


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

Main.java


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

Vi initierade fältet httpStatus när vi kastade undantaget i vår applikation.

ErrorResponse.java


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

ErrorResponse.builder().error("ERROR").build();

Felhantering i vår applikation

Sammanfattning

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 5