Comment lever une exception de retour en JSON au Printemps de Démarrage

Supposons que vous avez une classe d'Exception personnalisée NotFoundException et sa mise en oeuvre quelque chose comme ceci:

public class NotFoundException extends Exception {

    private int errorCode;
    private String errorMessage;

    public NotFoundException(Throwable throwable) {
        super(throwable);
    }

    public NotFoundException(String msg, Throwable throwable) {
        super(msg, throwable);
    }

    public NotFoundException(String msg) {
        super(msg);
    }

    public NotFoundException(String message, int errorCode) {
        super();
        this.errorCode = errorCode;
        this.errorMessage = message;
    }


    public void setErrorCode(int errorCode) {
        this.errorCode = errorCode;
    }

    public int getErrorCode() {
        return errorCode;
    }

    public void setErrorMessage(String errorMessage) {
        this.errorMessage = errorMessage;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    @Override
    public String toString() {
        return this.errorCode + " : " + this.getErrorMessage();
    }
}

Maintenant, vous voulez lancer une exception de contrôleur. Si vous jeter une exception, alors vous devez l'attraper d'une Erreur standard de la classe de Gestionnaire, disons, par exemple, au printemps, ils fournissent @ControllerAdvice annotation à appliquer pour faire une classe Standard Gestionnaire d'Erreur. Lorsqu'il est appliqué à une classe puis ce printemps composant (je veux dire la classe que vous annoté) peut attraper l'exception générée à partir du contrôleur. Mais Nous avons besoin de carte de la classe d'exception avec une bonne méthode. Nous avons donc défini une méthode avec vos exception NotFoundException gestionnaire de quelque chose comme ci-dessous.

@ControllerAdvice
public class RestErrorHandler {

    @ExceptionHandler(NotFoundException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ResponseBody
    public Object processValidationError(NotFoundException ex) {
        String result = ex.getErrorMessage();
        System.out.println("###########"+result);
        return ex;
    }
}

Vous voulez envoyé http statut d'erreur interne du serveur(500), donc, ici, nous avons utilisé @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR). Depuis que vous avez utilisé Spring-boot, de sorte que vous n'avez pas besoin de faire une chaîne json à l'exception d'une simple annotation @ResponseBody peut le faire pour vous automatiquement.

OriginalL'auteur Ataur Rahman Munna

vous pouvez créer NotFoundException classe avec @ResponseStatus annotation comme ci-dessous:

@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
public class NotFoundException extends RuntimeException {
   public NotFoundException() {
   }

   public NotFoundException(String message) {
    super(message);
   }

}

OriginalL'auteur Hiren

C'est la façon dont je l'ai fait dans mon application:

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class ExceptionHandlingControllerAdvice {

   @ExceptionHandler(ExecutionRestrictionViolationException.class)
   public ResponseEntity<String> handleExecutionRestrictionViolationException(ExecutionRestrictionViolationException ex) {
     return response("Invalid Query", ex.getMessage(), HttpStatus.UNPROCESSABLE_ENTITY);
   }

   private static String createJson(String message, String reason) {
    return "{\"error\" : \"" + message + "\"," +
            "\"reason\" : \"" + reason  + "\"}";
   }

   private static ResponseEntity<String> response(String message,
                                               String reason,
                                               HttpStatus httpStatus) {
    String json = createJson(message, reason);
    return new ResponseEntity<>(json, httpStatus);
   }

}

Explication:

1. Vous créez un contrôleur de Conseils, de marquer avec un spécial d'annotation et de définir comme toute autre bean (dans mon cas c'était une java de configuration, mais il n'a pas vraiment d'importance)

2. Pour chaque Exception que vous souhaitez gérer comme ça - définir un gestionnaire qui va générer une réponse dans un format que vous voulez

3. Il y a une méthode statique createJson - vous pouvez utiliser un autre moyen, il ne importe pas vraiment.

Maintenant ce n'est qu'une façon de travailler (de ses plus récentes printemps de démarrage des versions) - mais il en existe d'autres:

Toutes les méthodes que j'en suis conscient (et même plus) sont répertoriés ici.

OriginalL'auteur Mark Bramnik