Les mappeurs Exception Jersey ne fonctionnent pas lorsque la désérialisation jackson échoue

Je suis à l'aide de Jersey 2.10 avec Jackson de sérialisation/désérialisation dans mon API REST.

Mon idée est de faire de mon API REST pour toujours retourner une norme JSON réponse d'erreur. Pour ce que j'ai ExceptionMapper classes construire des json réponses d'erreur pour toute exception levée dans le Maillot de l'application. J'ai aussi une jsp qui produit le même genre de réponse JSON, je me suis inscrit comme une erreur de page dans le web.xml qui couvre toutes les erreurs qui pourraient être portées devant Jersey en cours de chargement.

Mais il existe un cas qui n'est ni mon Exception des contributeurs, ni mon json production de jsp sont travail, c'est lors de l'envoi d'une mauvaise formé json à un POSTE de REPOS d'extrémité qui retourne le message suivant:

HTTP/1.1 400 Bad Request
Server: Apache-Coyote/1.1
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, POST, DELETE, PUT
Content-Type: text/plain
Content-Length: 210
Date: Tue, 24 Jun 2014 22:14:11 GMT
Connection: close

Can not deserialize instance of com.example.rest.User[] out of START_OBJECT token
 at [Source: org.glassfish.jersey.message.internal.EntityInputStream@1dcccac; line: 1, column: 1]

Comment puis-je faire de Jersey pour revenir à ma réponse d'erreur personnalisé au lieu de cela?

Mise à JOUR:

En fonction de la réponse par @Lucasz, j'ai fait plus de recherches et découvert qu'il y a deux Exception mappeurs définis dans le package com.fasterxml.jackson.jaxrs.de base (https://github.com/FasterXML/jackson-jaxrs-providers/tree/master/base/src/main/java/com/fasterxml/jackson/jaxrs/base) JsonMappingExceptionMapper et JsonParseExceptionMapper, qui semblent être à l'ombrage de mon custom mappeurs.

Comment puis-je me désinscrire de ces cartographes?

C'est de cette façon je suis actuellement en enregistrement, les cartographes:

@ApplicationPath("/")
public class MyApp extends ResourceConfig{
    public SyntheticAPIApp() {
        packages("com.example.resource", "com.example.mapper");
        register(org.glassfish.jersey.jackson.JacksonFeature.class);
    }
}

source d'informationauteur raspacorp

Je l'ai testé avec une exception mapper comme ci-dessous:

import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

import com.fasterxml.jackson.core.JsonProcessingException;

@Provider
public class JsonProcessingExceptionMapper implements ExceptionMapper<JsonProcessingException>{

        public static class Error {
            public String key;
            public String message;
        }

        @Override
        public Response toResponse(JsonProcessingException exception) {
            Error error = new Error();
            error.key = "bad-json";
            error.message = exception.getMessage();
            return Response.status(Status.BAD_REQUEST).entity(error).build();
        }
}

et cela a fonctionné.

Mise à jour: changé JsonParseException à JsonProcessingException (plus général)

Update2:
Afin d'éviter l'enregistrement de l'indésirables mappeurs de remplacer

register(org.glassfish.jersey.jackson.JacksonFeature.class);

avec

register(com.fasterxml.jackson.jaxrs.json.JacksonJaxbJsonProvider.class);

Regarder le code source de JacksonFeature et vous comprendrez ce qui se passe.

J'ai eu le même problème, et la réponse précédente m'a conduit à la solution, mais n'a pas été bifurcation pour moi actuel Jersey (2.22). Au premier abord, j'avais besoin d'utiliser la org.glassfish.jersey.spi.ExtendedExceptionMapper comme décrit dans https://jersey.java.net/documentation/latest/representations.html.

En outre, le Jersey est de vérifier qu'une exception mapper, qui est aussi proche que possible de la levée d'une exception (à partir de org.glassfish.jersey.internal.ExceptionMapperFactory):

for (final ExceptionMapperType mapperType : exceptionMapperTypes) {
        final int d = distance(type, mapperType.exceptionType);
        if (d >= 0 && d <= minDistance) {
            final ExceptionMapper<T> candidate = mapperType.mapper.getService();

            if (isPreferredCandidate(exceptionInstance, candidate, d == minDistance)) {
                mapper = candidate;
                minDistance = d;
                if (d == 0) {
                    //slight optimization: if the distance is 0, it is already the best case, so we can exit
                    return mapper;
                }
            }
        }
    }

J'avais donc besoin de carte exactement l'exception et non plus exception générale.

À la fin, mon fournisseur se présente comme suit:

@Provider
public final class JsonParseExceptionExceptionHandler implements ExtendedExceptionMapper<JsonParseException> {
    @Override
    public Response toResponse(final JsonParseException exception) {
        exception.printStackTrace();
        return Response.status(Response.Status.BAD_REQUEST).entity("JSON nicht in korrektem Format.").build();
    }

    @Override
    public boolean isMappable(final JsonParseException arg0) {
        return true;
    }
}

J'ai utilisé "jackson-jaxrs-json-fournisseur 2.8.8" et JAX-RS 2.0

Classe d'Application - vous besoin d'enregistrer votre ExceptionMapper mise en œuvre de la classe:

@ApplicationPath("pathApplication")
public class ApplicationConfiguration extends Application{


   @Override
   public Set<Class<?>> getClasses() {

      Set<Class<?>> resources = new HashSet<>();
      resources.add(YourJAXRSClass.class);
      resources.add(JsonJacksonEM.class); //ExceptionMapper class implementation
      //others resources that you need...
      return resources; 

   }


}

ExceptionMapper implémentation de la classe:

@Provider
public class JsonJacksonEM implements ExceptionMapper<JsonParseException>{


   @Override
   public Response toResponse(JsonParseException exception) {
      //you can return a Response in the way that you want!
      return Response.ok(new YourObject()).build();
   }


}

0

J'ai eu le même problème et de le résoudre en substituant l'ExceptionMapper. Parfait! Une autre petite chose que je devais faire et n'ont pas la compréhension de 100% a été comment remplacer la JacksonProvider pour ma demande (je ne sais pas si c'était lié à Jersey est la version que j'ai été aide - 2.19). Voici mon web.xml la partie qui la remplace:
```
<init-param>
    <param-name>jersey.config.server.provider.classnames</param-name>
       <param-value>
          com.fasterxml.jackson.jaxrs.json.JacksonJaxbJsonProvider
       </param-value>
</init-param>
```

Vous devez vous connecter pour publier un commentaire.