Überblick

Ich habe versucht, die Antwort zum Zeitpunkt des Fehlers mit Spring Boot anzupassen, daher werde ich sie hier als Memorandum beschreiben. Dieses Mal möchte ich den Körperteil der Antwort wie folgt anpassen.

Vorher ändern

{
  "timestamp": "2019-03-14T15:07:50.631+0000",
  "status": 500,
  "error": "Internal Server Error",
  "message": "MyException ist aufgetreten",
  "path": "/××××/××××"
}

Nach der veränderung

{
  "timestamp": "2019-03-14T15:07:50.631+0000",
  "status": 500,
  "error": "Internal Server Error",
  "message": "MyException ist aufgetreten",
  "path": "/××××/××××",
  "errorDetail": {
    "detailMessage": "××××××××××××"
  }
}

Voraussetzungen

Umgebung

SpringBoot 2.1.3
Java 1.8.0_181

Prozessablauf

Die folgenden vier Zeichen sind diesmal ungefähr die Zeichen.

Controller-Klasse, die Anforderungen akzeptiert
Ursprüngliche Ausnahmeklasse
Klasse für Antwortkörper --Klasse, um die aufgetretene eindeutige Ausnahme abzufangen

Darüber hinaus ist der allgemeine Ablauf des von nun an zu implementierenden Prozesses wie folgt.

Explizites "Werfen" vom Controller mit Ihrer eigenen definierten Ausnahme zur gleichen Zeit wie die Anforderung
(Erstellen Sie eine Klasse, die die Ausnahme behandelt.) Fangen Sie die ausgelöste Ausnahme mit der Handle-Klasse ab
Gibt einen benutzerdefinierten Antworttext zurück

Danach werden wir die obige Verarbeitung implementieren. (Obwohl die Bestellung nicht in Ordnung ist ...)

Implementierung

Zuordnung der Klassendefinition

Hier definieren wir die Mapping-Klasse für den Antworttext.

`ErrorResponseBody.java`


package com.example.demo.errorResponse;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Setter;

import java.time.ZonedDateTime;

@Setter
public class ErrorResponseBody {

        @JsonProperty("timestamp")
        private ZonedDateTime exceptionOccurrenceTime;
        @JsonProperty("status")
        private int status;
        @JsonProperty("error")
        private String error;
        @JsonProperty("message")
        private String message;
        @JsonProperty("path")
        private String path;
        @JsonProperty("errorDetail")
        private ErrorDetail errorDetail;
}

`ErrorDetail.java`


package com.example.demo.errorResponse;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Setter;

@Setter
public class ErrorDetail {
    @JsonProperty("detailMessage")
    String detailMessage;
}

Definition der eindeutigen Ausnahmeklasse

`MyException.java`


package com.example.demo.errorResponse;

import lombok.Getter;

@Getter
public class MyException extends RuntimeException {

    private ErrorDetail errorDetails;

    public MyException(String message, ErrorDetail errorDetails) {
        super(message);
        this.errorDetails = errorDetails;
    }
}

Controller-Definition

`HelloController.java`


package com.example.demo.errorResponse;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/exceptionhandle")
public class HelloController {

    @RequestMapping("/test")
    public String get() {
        ErrorDetail errorDetail = new ErrorDetail();
        errorDetail.setDetailMessage("Detaillierte Nachricht");
        throw new MyException("MyException ist aufgetreten", errorDetail);
    }
}

Ausnahmehandler-Klassendefinition

Dies ist der wichtigste Teil. Es gibt vier Punkte.

Fügen Sie der Handle-Klasse die Annotation @ RestControllerAdvice hinzu
Erben Sie die Klasse ResponseEntityExceptionHandler
Fügen Sie die Annotation @ ExceptionHandler hinzu und geben Sie die eindeutig definierte Ausnahmeklasse an, die ergänzt werden soll.
Übergeben Sie die Instanz der für den Antworttext definierten Klasse an den zweiten Parameter der Methode "super.handleExceptionInternal" (abgesehen davon sind die Argumente dieser Methode in der folgenden Reihenfolge).

Zielausnahmeklasse
Antwortkörper
Header
Antwortstatus
Anfrage

Und schließlich wird "ResponseEntity" zurückgegeben.

`HelloExceptionHandler.java`


package com.example.demo.errorResponse;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import java.time.ZonedDateTime;

@RestControllerAdvice
public class HelloExceptionHandler extends ResponseEntityExceptionHandler {
    //Catch MyException vom Controller ausgelöst
    @ExceptionHandler(MyException.class)
    public ResponseEntity<Object> handleMyException(MyException exception, WebRequest request) {
        HttpHeaders headers = new HttpHeaders();

        return super.handleExceptionInternal(exception,
                createErrorResponseBody(exception, request),
                headers,
                HttpStatus.BAD_REQUEST,
                request);
    }

    //Erstellen Sie den Hauptteil der Antwort
    private ErrorResponseBody createErrorResponseBody(MyException exception, WebRequest request) {

        ErrorResponseBody errorResponseBody = new ErrorResponseBody();
        int responseCode = HttpStatus.BAD_REQUEST.value();
        String responseErrorMessage = HttpStatus.BAD_REQUEST.getReasonPhrase();
        String uri = ((ServletWebRequest) request).getRequest().getRequestURI();

        errorResponseBody.setExceptionOccurrenceTime(ZonedDateTime.now());
        errorResponseBody.setStatus(responseCode);
        errorResponseBody.setError(responseErrorMessage);
        errorResponseBody.setMessage(exception.getMessage());
        errorResponseBody.setPath(uri);
        errorResponseBody.setErrorDetail(exception.getErrorDetails());

        return errorResponseBody;
    }
}

Abgesehen davon sieht die handleExceptionInternal -Methode der übergeordneten Klasse ResponseEntityExceptionHandler wie folgt aus: Der Teil, der die Instanz für die Fehlerantwort übergibt, ist "@Nullable Object body". Wenn Sie ihn also nicht ordnungsgemäß übergeben, wird der Körperteil nicht angezeigt.

`ResponseEntityExceptionHandler.java`


	/**
	 * A single place to customize the response body of all Exception types.
	 * <p>The default implementation sets the {@link WebUtils#ERROR_EXCEPTION_ATTRIBUTE}
	 * request attribute and creates a {@link ResponseEntity} from the given
	 * body, headers, and status.
	 * @param ex the exception
	 * @param body the body for the response
	 * @param headers the headers for the response
	 * @param status the response status
	 * @param request the current request
	 */
	protected ResponseEntity<Object> handleExceptionInternal(
			Exception ex, @Nullable Object body, HttpHeaders headers, HttpStatus status, WebRequest request) {

		if (HttpStatus.INTERNAL_SERVER_ERROR.equals(status)) {
			request.setAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE, ex, WebRequest.SCOPE_REQUEST);
		}
		return new ResponseEntity<>(body, headers, status);
	}

Ergebnis

{
  "timestamp": "2019-03-18T10:11:13.795+09:00",
  "status": 400,
  "error": "Bad Request",
  "message": "MyException ist aufgetreten",
  "path": "/exceptionhandle/test",
  "errorDetail": {
    "detailMessage": "Detaillierte Nachricht"
  }
}

In Verbindung stehender Artikel

Anpassen der REST-API-Fehlerantwort mit Spring Boot (Teil 2)

Referenzartikel

Dieses Mal habe ich beim Schreiben des Artikels auf den folgenden Artikel verwiesen.

Passen Sie die Fehlerantwort der von Spring Boot erstellten REST-API an Fehlerbehandlung mit Spring Boot Ausnahmen mit @ RestController von Spring Boot behandeln

[JAVA] Passen Sie die Antwort auf REST-API-Fehler mit Spring Boot an (Teil 1).