Aperçu

J'ai essayé de personnaliser la réponse au moment de l'erreur avec Spring Boot, je la décrirai donc ici comme un mémorandum. Cette fois, j'aimerais personnaliser la partie du corps de la réponse comme suit.

Changer avant

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

Après le changement

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

Conditions préalables

environnement

SpringBoot 2.1.3
Java 1.8.0_181

Flux de processus

Les quatre personnages suivants sont à peu près les personnages cette fois.

--Classe de contrôleur qui accepte les demandes

Classe d'exception d'origine --Classe pour corps de réponse --Class pour attraper l'exception unique qui s'est produite

De plus, le déroulement général du processus à mettre en œuvre désormais est le suivant.

Explicitement «throw» du contrôleur avec votre propre exception définie en même temps que la requête
(Créez une classe qui gère l'exception) Attrapez l'exception `throwʻed avec la classe handle
Renvoie un corps de réponse personnalisé

Après cela, nous mettrons en œuvre le traitement ci-dessus. (Bien que la commande ne soit pas en ordre ...)

la mise en oeuvre

Définition de la classe de mappage

Ici, nous définissons la classe de mappage pour le corps de la réponse.

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

Définition de la classe d'exception unique

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

Définition du contrôleur

`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("Message détaillé");
        throw new MyException("MyException s'est produite", errorDetail);
    }
}

Définition de la classe du gestionnaire d'exceptions

C'est la partie la plus importante. Il y a quatre points.

Ajoutez l'annotation @ RestControllerAdvice à la classe de descripteurs
Hériter de la classe ResponseEntityExceptionHandler
Ajoutez l'annotation @ ExceptionHandler et spécifiez la classe d'exception définie de manière unique à compléter.
Passez l'instance de la classe définie pour le corps de la réponse au deuxième paramètre de la méthode super.handleExceptionInternal (à part, les arguments de cette méthode sont dans l'ordre suivant).

Classe d'exception cible --Corps de réponse
entête
Statut de réponse
demande

Et enfin, il renvoie ResponseEntity.

`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 {
    //Attraper MyException lancée par le contrôleur
    @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);
    }

    //Créer la partie du corps de la réponse
    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;
    }
}

En passant, la méthode handleExceptionInternal de la classe parent ResponseEntityExceptionHandler ressemble à ceci: La partie qui passe l'instance pour la réponse d'erreur est @Nullable Object body, donc si vous ne la passez pas correctement, la partie du corps ne sera pas affichée.

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

résultat

{
  "timestamp": "2019-03-18T10:11:13.795+09:00",
  "status": 400,
  "error": "Bad Request",
  "message": "MyException s'est produite",
  "path": "/exceptionhandle/test",
  "errorDetail": {
    "detailMessage": "Message détaillé"
  }
}

Article associé

Personnaliser la réponse d'erreur de l'API REST avec Spring Boot (Partie 2)

Article de référence

Cette fois, j'ai fait référence à l'article suivant lors de la rédaction de l'article.

Personnalisez la réponse d'erreur de l'API REST créée par Spring Boot Gestion des erreurs avec Spring Boot Gestion des exceptions avec @ RestController de Spring Boot

[JAVA] Personnalisez la réponse aux erreurs de l'API REST avec Spring Boot (Partie 1)