REST service that accepts and returns object. How to write client?

If you take a little bit of time to understand the WebTarget API, as well as the different types returned from calls to 's method, you should get a better understanding of how to make calls. It may be a little confusing, as almost all the example use method chaining, as it's a very convenient way, but doing this, you miss all the actual classes involved in create and sending the request. Let break it down a bitWebTarget

WebTarget target = client.target(getBaseURI()).path("rest").path("orders");

WebTarget.path() simply returns the . Nothing interesting there.WebTarget

target.path("oneOrder").request().accept(MediaType.APPLICATION_JSON).get(String.class)

• WebTarget.request() returns Invocation.Builder
• Invocation.Builder.accept(..) returns Invocation.Builder
• Invocation.Builder.get() calls its super class's SyncInvoker.get(), which makes the actual request, and returns a type, based on the argument we provide to get(Class returnType)

What you're doing with is saying that the response stream should be deserialized into a Sting type response. This is not a problem, as JSON is inherently just a String. But if you want to unmarshal it to a POJO, then you need to have a that knows how to unmarshal JSON to your POJO type. Jackson provides a in it's jackson-jaxrs-json-provider dependencyget(String.class)MessageBodyReaderMessageBodyReader

<dependency>
  <groupId>com.fasterxml.jackson.jaxrs</groupId>
  <artifactId>jackson-jaxrs-json-provider</artifactId>
  <version>2.4.0</version>
</dependency>

Most implementations will provider a wrapper for this module, like for Jersey or for Resteasy. But they are still using the underlying .jersey-media-json-jacksonresteasy-jackson-providerjackson-jaxrs-json-provider

That being said, once you have that module on the classpath, is should be automatically registered, so the will be available. If not you can register it explicitly with the client, like . Once you have the Jackson support configured, then you can simply do something likeMessageBodyReaderclient.register(JacksonJaxbJsonProvider.class)

MyPojo myPojo = client.target(..).path(...).request().accept(..).get(MyPojo.class);

As for posting/sending data, you can again look at the different methods. For instanceInvocation.Builder

Invocation.Builder builder = target.request();

If we want to post, look at the different post methods available. We can use

• Response post(Entity<?> entity) - Our request might look something like

  Response response = builder.post(Entity.json(myPojo));
  

  You'll notice the Entity. All the methods accept an , and this is how the request will know what type the entity body should be, and the client will invoke the approriate as well as set the appropriate headerpostEntityMessageBodyWriter

• <T> T post(Entity<?> entity, Class<T> responseType) - There's another overload, where we can specify the type to unmarshal into, instead of getting back a . We could doResponse

  MyPojo myPojo = builder.post(Entity.json(myPojo), MyPojo.class)
  

Note that with , we call its method to read from the , the entity body. The advantage of this, is that the object comes with a lot of useful information we can use, like headers and such. Personally, I always get the ResponsereadEntity(Class pojoType)ResponseResponseResponse

    Response response = builder.get();
    MyPojo pojo = response.readEntity(MyPojo.class);

As an aside, for your particular code you are showing, you most likely want to make it a method. Remember is mainly for retrieving data, for updating, and for creating. That is a good rule of thumb to stick to, when first starting out. So you might change the method to@POST@GETPUTPOST

@Path("orders")
public class OrdersResource  {

    @POST
    @Produces(MediaType.APPLICATION_JSON)
    @Consumes({MediaType.APPLICATION_JSON})
    public Response createOrder(@Context UriInfo uriInfo, Order input) {
       Order order = orderService.createOrder(input);
       URI uri = uriInfo.getAbsolutePathBuilder().path(order.getId()).build();
       return Response.create(uri).entity(order).build();
    }
}

Then you can do

WebTarget target = client.target(BASE).path("orders");
Response response = target.request().accept(...).post(Entity.json(order));
Order order = response.readEntity(Order.class);

You should use POST or PUT instead GET

try this code

final Client client = new Client();
    final Order input = new Order();
    input.setId("1");
    input.setDescription("description");
    final Order output = client.resource(
"http://localhost:8080/orders/writeAndIncrementOrder").
            header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON).
            entity(input).post(Order.class);