Spring MVC REST Remettre Bad Url (404) en retournant JSON

Je suis en train d'élaborer un REPOS de service à l'aide de spring mvc, où j'ai @RequestMapping à la classe et au niveau de la méthode.

Cette application est actuellement configuré pour renvoyer l'erreur-page jsp configuré dans web.xml.

<error-page>
    <error-code>404</error-code>
    <location>/resourceNotFound</location>
</error-page>

J'ai cependant envie de retourner sur JSON au lieu de cette page d'erreur.

Je suis capable de gérer l'exception et retour json pour les autres exceptions, par l'écriture de ce contrôleur, mais vous ne savez pas où et comment écrire la logique de retour JSON lorsque l'url n'existe pas du tout.

    @ExceptionHandler(TypeMismatchException.class)
        @ResponseStatus(value=HttpStatus.NOT_FOUND)
        @ResponseBody
        public ResponseEntity<String> handleTypeMismatchException(HttpServletRequest req, TypeMismatchException ex) {

            HttpHeaders headers = new HttpHeaders();
            headers.add("Content-Type", "application/json; charset=utf-8");
            Locale locale = LocaleContextHolder.getLocale();
            String errorMessage = messageSource.getMessage("error.patient.bad.request", null, locale);

            errorMessage += ex.getValue();
            String errorURL = req.getRequestURL().toString();

            ErrorInfo errorInfo = new ErrorInfo(errorURL, errorMessage);
            return new ResponseEntity<String>(errorInfo.toJson(), headers, HttpStatus.BAD_REQUEST);

        }

J'ai essayé @ControllerAdvice, il travaille pour un autre exception des scénarios, mais pas lors de la cartographie n'est pas disponible,

@ControllerAdvice
public class RestExceptionProcessor {

    @Autowired
    private MessageSource messageSource;

    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    @ResponseStatus(value=HttpStatus.NOT_FOUND)
    @ResponseBody
    public ResponseEntity<String> requestMethodNotSupported(HttpServletRequest req, HttpRequestMethodNotSupportedException ex) {
        Locale locale = LocaleContextHolder.getLocale();
        String errorMessage = messageSource.getMessage("error.patient.bad.id", null, locale);

        String errorURL = req.getRequestURL().toString();

        ErrorInfo errorInfo = new ErrorInfo(errorURL, errorMessage);
        return new ResponseEntity<String>(errorInfo.toJson(), HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(NoSuchRequestHandlingMethodException.class)
    @ResponseStatus(value=HttpStatus.NOT_FOUND)
    @ResponseBody
    public ResponseEntity<String> requestHandlingMethodNotSupported(HttpServletRequest req, NoSuchRequestHandlingMethodException ex) {
        Locale locale = LocaleContextHolder.getLocale();
        String errorMessage = messageSource.getMessage("error.patient.bad.id", null, locale);

        String errorURL = req.getRequestURL().toString();

        ErrorInfo errorInfo = new ErrorInfo(errorURL, errorMessage);
        return new ResponseEntity<String>(errorInfo.toJson(), HttpStatus.BAD_REQUEST);
    }


}

source d'informationauteur Himalay Majumdar

Après creuser autour DispatcherServlet et HttpServletBean.init() dans SpringFramework je vois que sa possible au Printemps 4.

org.springframework.web.servlet.DispatcherServlet

/** Throw a NoHandlerFoundException if no Handler was found to process this request? **/
private boolean throwExceptionIfNoHandlerFound = false;

protected void noHandlerFound(HttpServletRequest request, HttpServletResponse response) throws Exception {
    if (pageNotFoundLogger.isWarnEnabled()) {
        String requestUri = urlPathHelper.getRequestUri(request);
        pageNotFoundLogger.warn("No mapping found for HTTP request with URI [" + requestUri +
                "] in DispatcherServlet with name '" + getServletName() + "'");
    }
    if(throwExceptionIfNoHandlerFound) {
        ServletServerHttpRequest req = new ServletServerHttpRequest(request);
        throw new NoHandlerFoundException(req.getMethod().name(),
                req.getServletRequest().getRequestURI(),req.getHeaders());
    } else {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
    }
}

throwExceptionIfNoHandlerFound est false par défaut et on devrait permettre que, dans web.xml

<servlet>
    <servlet-name>appServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>throwExceptionIfNoHandlerFound</param-name>
            <param-value>true</param-value>
        </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
</servlet>

Et alors vous pouvez l'attraper dans une classe annotée avec @ControllerAdvice à l'aide de cette méthode.

@ExceptionHandler(NoHandlerFoundException.class)
@ResponseStatus(value=HttpStatus.NOT_FOUND)
@ResponseBody
public ResponseEntity<String> requestHandlingNoHandlerFound(HttpServletRequest req, NoHandlerFoundException ex) {
    Locale locale = LocaleContextHolder.getLocale();
    String errorMessage = messageSource.getMessage("error.bad.url", null, locale);

    String errorURL = req.getRequestURL().toString();

    ErrorInfo errorInfo = new ErrorInfo(errorURL, errorMessage);
    return new ResponseEntity<String>(errorInfo.toJson(), HttpStatus.BAD_REQUEST);
}

Qui me permet de revenir réponse JSON pour la mauvaise Url pour lesquelles aucun mappage n'existe pas, au lieu de rediriger vers une page JSP 🙂

{"message":"URL does not exist","url":"http://localhost:8080/service/patientssd"}

Si vous utilisez le Printemps de Démarrage, de définir à la FOIS de ces deux propriétés:

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

Maintenant votre @ControllerAdvice annoté classe peut gérer le "NoHandlerFoundException", comme ci-dessous.

@ControllerAdvice
@RequestMapping(produces = "application/json")
@ResponseBody
public class RestControllerAdvice {

    @ExceptionHandler(NoHandlerFoundException.class)
    public ResponseEntity<Map<String, Object>> unhandledPath(final NoHandlerFoundException e) {
        Map<String, Object> errorInfo = new LinkedHashMap<>();
        errorInfo.put("timestamp", new Date());
        errorInfo.put("httpCode", HttpStatus.NOT_FOUND.value());
        errorInfo.put("httpStatus", HttpStatus.NOT_FOUND.getReasonPhrase());
        errorInfo.put("errorMessage", e.getMessage());
        return new ResponseEntity<Map<String, Object>>(errorInfo, HttpStatus.NOT_FOUND);
    }

}

REMARQUE il n'est pas suffisant de spécifier cette propriété:

spring.mvc.throw-exception-if-no-handler-found=true

en tant que par défaut Printemps des cartes inconnues url /**, donc il n'y a vraiment jamais "aucun gestionnaire trouvé".

Pour désactiver l'inconnu mappage d'url /**, vous avez besoin

spring.resources.add-mappings=false ,

qui est pourquoi les deux propriétés, ENSEMBLE, produisent le comportement souhaité.

-1

Si vous utilisez printemps 3.2 ou version ultérieure, vous pouvez utiliser un contrôleur de conseils (@ControllerAdvice) pour traiter, entre autres choses, de la cartographie des erreurs (404). Vous pouvez trouver la documentation ici. Jetez un oeil à l'article 17.11. Vous pouvez l'utiliser, par exemple, de fournir plus de journalisation détaillée sur les raisons de votre demande de liaisons ne sont pas appariés pour l'url, ou tout simplement un retour plus précis réponse qu'un générique 404.

-2

vous pouvez le retour json dans l'emplacement ci-dessous,qui /poignée/404.

<error-page>
    <error-code>404</error-code>
    <location>/handle/404</location>
</error-page>

après vous cette config web.xml,une erreur 404 redirige /poignée/404,et vous pouvez créer un contrôleur avec cette cartographie et retourner un résultat json. par exemple.

@RestController
@RequestMapping(value = "handle")
public class HttpErrorController {
   @RequestMapping(value = "404")
   public String handle404() {
      return "404 error";
   }
}

Vous devez vous connecter pour publier un commentaire.