L'utilisation de Jackson comme client de Jersey serializer
Est-il possible d'utiliser Jackson comme le sérialiseur/marshaller pour les données JSON au lieu de JAXB lors de l'utilisation de Jersey Client de l'API?
Si oui comment le configurer?
6 réponses
OK, je l'ai trouvé, il s'avère être assez simple, après tout:
ClientConfig cc = new DefaultClientConfig();
cc.getClasses().add(JacksonJsonProvider.class);
Client clientWithJacksonSerializer = Client.create(cc);
Le JacksonJsonProvider vient du paquet jackson-jaxrs.
Vous pouvez sauter la création de la configuration externe et enregistrer le fournisseur directement:
Client client = ClientBuilder.newClient().register(JacksonJsonProvider.class)
Vous pouvez également essayer org.codehaus.jackson.jaxrs.JacksonJaxbJsonProvider (jackson-jaxrs 1.6.1).
j'ai rencontré un problème similaire, mais pour moi aucune des suggestions données ici n'a fonctionné. Ce qui a fonctionné pour moi était en dessous de morceau de code:
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Client;
...
ClientBuilder clientBuilder = ClientBuilder.newBuilder()
clientBuilder.register(JacksonFeature.class);
...
Client client = clientBuilder.build();
le changement clé a été l'utilisation de JacksonFeature.class - il s'agit de jersey-media-json-jackson-x.yy.jar
j'ai eu idée d'utiliser cette solution à partir de cet article - http://www.baeldung.com/jersey-jax-rs-client
pour jersey 2.22.2 et Jackson 2.7.2 les dépendances de gradle sont:
dependencies {
compile("com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider:2.7.2")
compile("org.glassfish.jersey.core:jersey-client:2.22.2")
}
exemple de code client:
final String name = "world";
final Client client = ClientBuilder.newClient().register(JacksonJaxbJsonProvider.class);
final WebTarget target = client.target("http://localhost:8080").path("hello").path(name);
final Message message = target.request().get(Message.class);
System.out.println(message.getWelcomeMessage()); // hello world
Solution avec JacksonJaxbJsonProvider
Commune de la manière d'utiliser Jackson avec configuration personnalisée en Jersey client était d'utiliser JacksonJaxbJsonProvider par exemple, comme ceci
JacksonJaxbJsonProvider provider = new JacksonJaxbJsonProvider();
provider.setMapper(yourObjectMapper());
Client client = ClientBuilder.newClient(new ClientConfig(provider));
malheureusement en Maillot 2.26 ils ont copié JacksonJaxbJsonProvider classe
à partir de com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider artefact (Jackson)
org.glassfish.jersey.media:jersey-media-json-jackson artefact (Jersey))
et le paquet changé
à partir de com.fasterxml.jackson.jaxrs.json
org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.
il est encore possible d'utiliser cette approche il suffit de changer JacksonJaxbJsonProvider importation.
mis à part JacksonJaxbJsonProvider maintenant internal les ristournes sur les emballages sont également
que vous devez savoir sur quelle version de Jersey votre code s'exécute ce qui pourrait être un problème lorsque différentes dépendances nécessitent différentes versions de Jersey.
meilleure solution avec ContextResolver<ObjectMapper>
meilleure possibilité de configurer Jackson à Jersey client est d'utiliser la même façon dont il est configuré à Jersey serveur pour créer ObjectMapper fournisseur comme ceci:
@Provider
@Produces(MediaType.APPLICATION_JSON)
public class ObjectMapperProvider implements ContextResolver<ObjectMapper> {
private ObjectMapper objectMapper = yourObjectMapper();
@Override
public ObjectMapper getContext(Class<?> objectType) {
return objectMapper;
}
}
et l'utiliser par exemple comme ceci:
ClientConfig clientConfig = new ClientConfig();
clientConfig.register(JacksonFeature.class); // usually auto-discovered
clientConfig.register(new ObjectMapperProvider());
Client client = ClientBuilder.newClient(clientConfig);
Si vous avez à la fois le serveur et le client que vous pouvez réutiliser ObjectMapperProvider classe.
il semble que cette approche fonctionne à partir de la version 2.9 De Jersey.