Printemps de Démarrage RESTE du service de la gestion des exceptions

Nouvelle réponse (2016-04-20)

À L'Aide De Spring Boot 1.3.1.COMMUNIQUÉ de

Nouvelle Étape 1 - C'est facile et moins intrusif pour ajouter les propriétés suivantes pour l'application.propriétés:

spring.mvc.throw-exception-if-no-handler-found=true
spring.resources.add-mappings=false

Beaucoup plus facile que de modifier les existants DispatcherServlet instance (ci-dessous)! - JO"

Si vous travaillez avec un plein Reposant Application, il est très important de désactiver le mappage automatique des ressources statiques, car si vous utilisez le Printemps de Démarrage de la configuration par défaut pour la manipulation des ressources statiques, alors la ressource gestionnaire sera en charge de la demande (c'est décrétée et associée à /** ce qui signifie qu'il ramasse toutes les demandes qui n'ont pas été traitées par un autre gestionnaire de l'application) de sorte que le répartiteur de la servlet n'obtiendrez pas une chance de lancer une exception.

---

Nouvelle Réponse (2015-12-04)

À L'Aide De Spring Boot 1.2.7.COMMUNIQUÉ de

Nouvelle Étape 1 - je l'ai trouvé beaucoup moins intrusive possible de régler les "throExceptionIfNoHandlerFound" pavillon. Remplacer la DispatcherServlet remplacement de code ci-dessous (Étape 1) avec-le dans votre demande d'initialisation de la classe:

@ComponentScan()
@EnableAutoConfiguration
public class MyApplication extends SpringBootServletInitializer {
    private static Logger LOG = LoggerFactory.getLogger(MyApplication.class);
    public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(MyApplication.class, args);
        DispatcherServlet dispatcherServlet = (DispatcherServlet)ctx.getBean("dispatcherServlet");
        dispatcherServlet.setThrowExceptionIfNoHandlerFound(true);
    }

Dans ce cas, nous allons le paramétrage de l'indicateur sur la DispatcherServlet, qui préserve toutes les auto-configuration par le Printemps de Démarrage cadre.

Une chose que j'ai trouvé: le @EnableWebMvc annotation est mortelle pour le Printemps de Démarrage. Oui, cette annotation permet des choses comme être capable d'attraper tous le contrôleur des exceptions décrites ci-dessous, mais il tue aussi BEAUCOUP de l'aide de la configuration automatique qui Ressort d'Amorçage fournissent normalement. Utiliser cette annotation avec une extrême prudence lorsque vous utilisez le Printemps de Démarrage.

---

Réponse Originale À Cette Question:

Après beaucoup plus de recherche et de suivi sur les solutions posté ici (merci pour l'aide!) et pas de petite quantité de suivi à l'exécution dans le Ressort de code, j'ai enfin trouvé une configuration qui va gérer toutes les Exceptions (pas des Erreurs, mais lisez la suite), y compris une erreur 404.

Étape 1 - dire SpringBoot d'arrêter l'utilisation de MVC pour le "gestionnaire n'est pas trouvé" des situations. Nous voulons Printemps pour lancer une exception au lieu de renvoyer au client une vue rediriger vers "/erreur". Pour ce faire, vous devez avoir une entrée dans l'une de vos classes de configuration:

//NEW CODE ABOVE REPLACES THIS! (2015-12-04)
@Configuration
public class MyAppConfig {
    @Bean  //Magic entry 
    public DispatcherServlet dispatcherServlet() {
        DispatcherServlet ds = new DispatcherServlet();
        ds.setThrowExceptionIfNoHandlerFound(true);
        return ds;
    }
}

L'inconvénient de cette est qu'il remplace la valeur par défaut répartiteur de la servlet. Cela n'a pas été un problème pour nous encore, sans effets secondaires ou les problèmes d'exécution qui se montre. Si vous allez faire autre chose avec le répartiteur de servlet pour d'autres raisons, c'est l'endroit pour le faire.

Étape 2 - Maintenant que le printemps de démarrage va lever une exception si aucun gestionnaire n'est trouvé, cette exception peut être manipulé avec tous les autres dans un cadre unifié gestionnaire d'exception:

@EnableWebMvc
@ControllerAdvice
public class ServiceExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(Throwable.class)
    @ResponseBody
    ResponseEntity<Object> handleControllerException(HttpServletRequest req, Throwable ex) {
        ErrorResponse errorResponse = new ErrorResponse(ex);
        if(ex instanceof ServiceException) {
            errorResponse.setDetails(((ServiceException)ex).getDetails());
        }
        if(ex instanceof ServiceHttpException) {
            return new ResponseEntity<Object>(errorResponse,((ServiceHttpException)ex).getStatus());
        } else {
            return new ResponseEntity<Object>(errorResponse,HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @Override
    protected ResponseEntity<Object> handleNoHandlerFoundException(NoHandlerFoundException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
        Map<String,String> responseBody = new HashMap<>();
        responseBody.put("path",request.getContextPath());
        responseBody.put("message","The URL you have reached is not in service at this time (404).");
        return new ResponseEntity<Object>(responseBody,HttpStatus.NOT_FOUND);
    }
    ...
}

Gardez à l'esprit que je pense que le "@EnableWebMvc" annotation est importante ici. Il semble que rien de tout cela fonctionne sans elle. Et votre Printemps de démarrage app maintenant attraper toutes les exceptions, y compris une erreur 404 dans le gestionnaire de classe et vous pouvez faire ce que vous s'il vous plaît.

Un dernier point - il ne semble pas être un moyen d'obtenir ce pour attraper jeté des Erreurs. J'ai une idée loufoque de l'utilisation d'aspects pour détecter les erreurs et de les transformer en des Exceptions que le code ci-dessus peut ensuite traiter avec, mais je n'ai pas encore eu le temps de réellement essayer la mise en œuvre de cette. Espérons que cela aide quelqu'un.

Les commentaires/corrections/améliorations seront appréciées.

Je pense que ResponseEntityExceptionHandler répond à vos exigences. Un exemple de morceau de code pour HTTP 400:

@ControllerAdvice
public class MyExceptionHandler extends ResponseEntityExceptionHandler {

  @ResponseStatus(value = HttpStatus.BAD_REQUEST)
  @ExceptionHandler({HttpMessageNotReadableException.class, MethodArgumentNotValidException.class,
      HttpRequestMethodNotSupportedException.class})
  public ResponseEntity<Object> badRequest(HttpServletRequest req, Exception exception) {
    //...
  }
}

Vous pouvez le vérifier post

Ce à propos de ce code ? J'utilise un repli de la demande de cartographie d'attraper les erreurs 404.

@Controller
@ControllerAdvice
public class ExceptionHandlerController {

    @ExceptionHandler(Exception.class)
    public ModelAndView exceptionHandler(HttpServletRequest request, HttpServletResponse response, Exception ex) {
        //If exception has a ResponseStatus annotation then use its response code
        ResponseStatus responseStatusAnnotation = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);

        return buildModelAndViewErrorPage(request, response, ex, responseStatusAnnotation != null ? responseStatusAnnotation.value() : HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @RequestMapping("*")
    public ModelAndView fallbackHandler(HttpServletRequest request, HttpServletResponse response) throws Exception {
        return buildModelAndViewErrorPage(request, response, null, HttpStatus.NOT_FOUND);
    }

    private ModelAndView buildModelAndViewErrorPage(HttpServletRequest request, HttpServletResponse response, Exception ex, HttpStatus httpStatus) {
        response.setStatus(httpStatus.value());

        ModelAndView mav = new ModelAndView("error.html");
        if (ex != null) {
            mav.addObject("title", ex);
        }
        mav.addObject("content", request.getRequestURL());
        return mav;
    }

}

@RestControllerAdvice est une nouvelle fonctionnalité du Framework Spring 4.3 gérer Exception avec RestfulApi par une préoccupation horizontale solution:

 package com.khan.vaquar.exception;
import javax.servlet.http.HttpServletRequest;
import org.owasp.esapi.errors.IntrusionException;
import org.owasp.esapi.errors.ValidationException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.NoHandlerFoundException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.khan.vaquar.domain.ErrorResponse;
/**
* Handles exceptions raised through requests to spring controllers.
**/
@RestControllerAdvice
public class RestExceptionHandler {
private static final String TOKEN_ID = "tokenId";
private static final Logger log = LoggerFactory.getLogger(RestExceptionHandler.class);
/**
* Handles InstructionExceptions from the rest controller.
* 
* @param e IntrusionException
* @return error response POJO
*/
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(value = IntrusionException.class)
public ErrorResponse handleIntrusionException(HttpServletRequest request, IntrusionException e) {       
log.warn(e.getLogMessage(), e);
return this.handleValidationException(request, new ValidationException(e.getUserMessage(), e.getLogMessage()));
}
/**
* Handles ValidationExceptions from the rest controller.
* 
* @param e ValidationException
* @return error response POJO
*/
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(value = ValidationException.class)
public ErrorResponse handleValidationException(HttpServletRequest request, ValidationException e) {     
String tokenId = request.getParameter(TOKEN_ID);
log.info(e.getMessage(), e);
if (e.getUserMessage().contains("Token ID")) {
tokenId = "<OMITTED>";
}
return new ErrorResponse(   tokenId,
HttpStatus.BAD_REQUEST.value(), 
e.getClass().getSimpleName(),
e.getUserMessage());
}
/**
* Handles JsonProcessingExceptions from the rest controller.
* 
* @param e JsonProcessingException
* @return error response POJO
*/
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(value = JsonProcessingException.class)
public ErrorResponse handleJsonProcessingException(HttpServletRequest request, JsonProcessingException e) {     
String tokenId = request.getParameter(TOKEN_ID);
log.info(e.getMessage(), e);
return new ErrorResponse(   tokenId,
HttpStatus.BAD_REQUEST.value(), 
e.getClass().getSimpleName(),
e.getOriginalMessage());
}
/**
* Handles IllegalArgumentExceptions from the rest controller.
* 
* @param e IllegalArgumentException
* @return error response POJO
*/
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(value = IllegalArgumentException.class)
public ErrorResponse handleIllegalArgumentException(HttpServletRequest request, IllegalArgumentException e) {
String tokenId = request.getParameter(TOKEN_ID);
log.info(e.getMessage(), e);
return new ErrorResponse(   tokenId,
HttpStatus.BAD_REQUEST.value(), 
e.getClass().getSimpleName(), 
e.getMessage());
}
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(value = UnsupportedOperationException.class)
public ErrorResponse handleUnsupportedOperationException(HttpServletRequest request, UnsupportedOperationException e) {
String tokenId = request.getParameter(TOKEN_ID);
log.info(e.getMessage(), e);
return new ErrorResponse(   tokenId,
HttpStatus.BAD_REQUEST.value(), 
e.getClass().getSimpleName(), 
e.getMessage());
}
/**
* Handles MissingServletRequestParameterExceptions from the rest controller.
* 
* @param e MissingServletRequestParameterException
* @return error response POJO
*/
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(value = MissingServletRequestParameterException.class)
public ErrorResponse handleMissingServletRequestParameterException( HttpServletRequest request, 
MissingServletRequestParameterException e) {
String tokenId = request.getParameter(TOKEN_ID);
log.info(e.getMessage(), e);
return new ErrorResponse(   tokenId,
HttpStatus.BAD_REQUEST.value(), 
e.getClass().getSimpleName(), 
e.getMessage());
}
/**
* Handles NoHandlerFoundExceptions from the rest controller.
* 
* @param e NoHandlerFoundException
* @return error response POJO
*/
@ResponseStatus(HttpStatus.NOT_FOUND)
@ExceptionHandler(value = NoHandlerFoundException.class)
public ErrorResponse handleNoHandlerFoundException(HttpServletRequest request, NoHandlerFoundException e) {
String tokenId = request.getParameter(TOKEN_ID);
log.info(e.getMessage(), e);
return new ErrorResponse(   tokenId,
HttpStatus.NOT_FOUND.value(), 
e.getClass().getSimpleName(), 
"The resource " + e.getRequestURL() + " is unavailable");
}
/**
* Handles all remaining exceptions from the rest controller.
* 
* This acts as a catch-all for any exceptions not handled by previous exception handlers.
* 
* @param e Exception
* @return error response POJO
*/
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ExceptionHandler(value = Exception.class)
public ErrorResponse handleException(HttpServletRequest request, Exception e) {
String tokenId = request.getParameter(TOKEN_ID);
log.error(e.getMessage(), e);
return new ErrorResponse(   tokenId,
HttpStatus.INTERNAL_SERVER_ERROR.value(), 
e.getClass().getSimpleName(), 
"An internal error occurred");
}   
}

Solution avec
dispatcherServlet.setThrowExceptionIfNoHandlerFound(true); et
@EnableWebMvc
@ControllerAdvice
a fonctionné pour moi avec Spring Boot 1.3.1, tout n'a pas été de travailler sur 1.2.7