Utilizzando Jackson come Jersey cliente serializzatore
Domanda
E 'possibile utilizzare Jackson come il serializzatore / marshaller per JSON dati invece di JAXB quando si utilizza Jersey client API?
Se è così come configurarlo?
Soluzione
OK, l'ho trovato fuori, si scopre di essere abbastanza semplice, dopo tutto:
ClientConfig cc = new DefaultClientConfig();
cc.getClasses().add(JacksonJsonProvider.class);
Client clientWithJacksonSerializer = Client.create(cc);
Il JacksonJsonProvider viene dal pacchetto di Jackson-jaxrs.
Altri suggerimenti
È possibile saltare la creazione di configurazione esterna e registrare il provider direttamente:
Client client = ClientBuilder.newClient().register(JacksonJsonProvider.class)
Soluzione con JacksonJaxbJsonProvider
modo comune come utilizzare Jackson con configurazione personalizzata client Jersey era quello di utilizzare JacksonJaxbJsonProvider
per esempio come questo
JacksonJaxbJsonProvider provider = new JacksonJaxbJsonProvider();
provider.setMapper(yourObjectMapper());
Client client = ClientBuilder.newClient(new ClientConfig(provider));
Purtroppo in Jersey 2.26 hanno copiato classe JacksonJaxbJsonProvider
da artefatto com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider
(Jackson)
a org.glassfish.jersey.media:jersey-media-json-jackson
artefatto (Jersey)
e pacchetto cambiato
da com.fasterxml.jackson.jaxrs.json
a org.glassfish.jersey.jackson.internal.jackson.jaxrs.json
.
E 'ancora possibile utilizzare questo approccio è solo bisogno di cambiare l'importazione JacksonJaxbJsonProvider
.
Oltre ad essere JacksonJaxbJsonProvider
adesso internal
pacchetto inconveniente è anche
che si deve sapere su quale versione Jersey il codice viene eseguito, che potrebbe essere un problema quando diverse dipendenze richiedono versioni Jersey differenti.
Una migliore soluzione con ContextResolver<ObjectMapper>
Una migliore possibilità come configurare Jackson a Jersey client è quello di utilizzare allo stesso modo di come è configurato in Jersey server , che è quello di creare fornitore ObjectMapper
in questo modo:
@Provider
@Produces(MediaType.APPLICATION_JSON)
public class ObjectMapperProvider implements ContextResolver<ObjectMapper> {
private ObjectMapper objectMapper = yourObjectMapper();
@Override
public ObjectMapper getContext(Class<?> objectType) {
return objectMapper;
}
}
e utilizzarlo per esempio come questo:
ClientConfig clientConfig = new ClientConfig();
clientConfig.register(JacksonFeature.class); // usually auto-discovered
clientConfig.register(new ObjectMapperProvider());
Client client = ClientBuilder.newClient(clientConfig);
Se si dispone sia il server e il client è possibile riutilizzare classe ObjectMapperProvider
.
Sembra che questo approccio funziona da Jersey versione 2.9.
Si potrebbe anche voler provare org.codehaus.jackson.jaxrs.JacksonJaxbJsonProvider (jackson-jaxrs 1.6.1)
.
Mi sono imbattuto in problema simile, ma per me nessuno dei suggerimenti qui riportati lavorato. Che cosa ha funzionato per me è stato al di sotto pezzo di codice:
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Client;
...
ClientBuilder clientBuilder = ClientBuilder.newBuilder()
clientBuilder.register(JacksonFeature.class);
...
Client client = clientBuilder.build();
Il cambiamento principale è stato l'utilizzo di JacksonFeature.class
- proviene da jersey-media-json-jackson-x.yy.jar
ho avuto indizio per utilizzare questa soluzione da questo articolo - http: // www. baeldung.com/jersey-jax-rs-client
Per la Jersey 2.22.2 e Jackson 2.7.2 le dipendenze Gradle sono:
dependencies {
compile("com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider:2.7.2")
compile("org.glassfish.jersey.core:jersey-client:2.22.2")
}
codice del client di esempio è il seguente:
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