REST in an Async World

Copyright © 2017, Oracle and/or its aﬃliates. All rights reserved. |
David Delabassee
@delabassee
Oracle
REST in an Async World
Israel – July 2017

Safe Harbor Statement
The following is intended to outline our general product direcPon. It is intended for
informaPon purposes only, and may not be incorporated into any contract. It is not a
commitment to deliver any material, code, or funcPonality, and should not be relied upon
in making purchasing decisions. The development, release, and Pming of any features or
funcPonality described for Oracle’s products remains at the sole discrePon of Oracle.
4

Agenda
•  REST & JAX-RS
•  Synchronous vs. Asynchronous
•  Client-side vs. Server-side
5

Client-side REST
ConﬁdenPal – Oracle Internal/Restricted/Highly Restricted 6

JAX-RS
•  Java API for RESTful Web Services
– JAX-RS 2.0 – JSR 339 (*)
– JAX-RS 2.1 – JSR 370
•  Standard based RESTful framework
– Server-side and client-side
– Jersey, JBoss RESTEasy, Restlet, Apache CXF, Apache Wink, IBM JAX-RS, …
•  Java SE and Java EE
7

Client client = ClientBuilder.newClient();

WebTarget target = client.target("http://weath.er/api")
.queryParam("city", "Paris”);

Forecast forecast = target.request()
.get(Forecast.class);

…
client.close();

JAX-RS Client API

JAX-RS Client API
•  Client
– Client side container
– Customizable & tunable
• E.g. executorService() (new in JAX-RS 2.1!)
•  WebTarget
– Target remote URI
– Build from a client
– path() + resolveTemplates(), queryParam(), matrixParam()
javax.ws.rs.client.Client interface

9

JAX-RS Client API
•  Request invocaPon builder
– Build from a WebTarget
– acceptXXX(), cookie(), header(), cacheControl()…
– HTTP methods


10

JAX-RS Client API
•  Fluent API
– Client Builder è Client è Web Target è Request building è Response

11
List<Forecast> forecast = ClientBuilder.newClient()
.target("http://weath.er/cities")
.request()
.accept("application/json")
.header("Foo","bar")
.get(new GenericType<List<Forecast>>() {});

JAX-RS Client API
•  Synchronous invoker

•  Asynchronous invoker

12
String city = client.target("http://locati.on/api")
.queryParam("city", "Paris")
.request()
.get(String.class);
Future<String> fCity = client.target("http://locati.on/api")
.queryParam("city", "Paris")
.request()
.async()
.get(String.class);

JAX-RS Client API
Asynchronous invoca.on
13
…
.request()
.async()
.get(String.class);

String city = future.get();

JAX-RS Client API
14
…
.request()
.async()
.get(String.class);

try {

String city = future.get(4, TimeUnit.SECONDS);

} catch(TimeoutException timeout) {
…
}

JAX-RS Client API
15
Future<String> future = client.target("http://locati.on/api")
…
.request()
.async()
.get(String.class);

while (!future.isDone()) {
// response hasn't been received yet
…
}

String city = f.get();
…

// Set ClientProperties.CONNECT_TIMEOUT & READ_TIMEOUT

JAX-RS Client API
•  InvocaPonCallback Interface
– javax.ws.rs.client.InvocaPonCallback<RESPONSE>
•  Container will receive asynchronous processing events from an
invocaPon
– completed(RESPONSE response)
– failed(Throwable throwable)
16

JAX-RS Client API
17
Invoca.onCallback
…
WebTarget myResource = client.target("http://examp.le/api/read");
Future<Customer> future = myResource.request(MediaType.TEXT_PLAIN)
.async()
.get(new InvocationCallback<Customer>() {
@Override
public void completed (Customer customer) {
// do something with the given customer
}
@Override
public void failed (Throwable throwable) {
// Oops!
}
});

The Travel Service

The Travel Service - Synchronous
•  Customer details: 150 ms
•  Recommended desPnaPons: 250 ms
•  Price calculaPon for a customer and desPnaPon: 170 ms (each)
•  Weather forecast for a desPnaPon: 330 ms (each)

19
5 400 ms

The Travel Service - Asynchronous
20
730 ms

The Travel Service

The Travel Service
destination.path("recommended").request()
.header("Rx-User", "Async")
.async()
.get(new InvocationCallback<List<Destination>>() {
@Override
public void completed(final List<Destination> recommended) {
final CountDownLatch innerLatch = new CountDownLatch(recommended.size());
final Map<String, Forecast> forecasts =
Collections.synchronizedMap(new HashMap<>());
for (final Destination dest : recommended) {
forecast.resolveTemplate("dest", dest.getDestination()).request()
.async()
.get(new InvocationCallback<Forecast>() {
@Override
public void completed(final Forecast forecast) {
forecasts.put(dest.getDestination(), forecast);
innerLatch.countDown();
}

JAX-RS 2.0
@Override
public void failed(final Throwable throwable) {
innerLatch.countDown();
}
});
}
try {
if (!innerLatch.await(10, TimeUnit.SECONDS)) { // timeout }
} catch (final InterruptedException e) { // Ooops, interrupted! }

// Continue with processing…
}
@Override
public void failed(final Throwable throwable) { // Recommendation error }
});

JAX-RS 2.1
// JAX-RS 2.1
CompletionStage<Response> csResponse = ClientBuilder.newClient()
.target("http://example.com/api")
.request()
.rx()
.get();
Future<Response> fResponse = ClientBuilder.newClient()
.request()
.async()
.get();
Response response = ClientBuilder.newClient()
.request()
.get();

ComplePonStage interface
•  “A stage of a possibly asynchronous computaPon, that performs an
ac.on or computes a value”
•  “On termina.on a stage may in turn trigger other dependent stages.”
•  Stage execuPon triggered by complePon of
– “then” - a single stage
– “combine” - both of two stages
– “either” - either of two stages
25

ComplePonStage interface
•  ComputaPon takes an argument and returns a result?
– “apply” – Func.on take result of the previous stage as argument, return a result
– “accept” – Consumer only take an argument
– “run” – Runnable no argument and doesn’t return a result
•  How the execuPon of the computaPon is arranged?
– Doesn't end with “async” – execute using the stage’s default execuPon facility
– End with “async” - use the stage’s default asynchronous execuPon facility
•  …
26
hsps://docs.oracle.com/javase/8/docs/api/java/uPl/concurrent/ComplePonStage.html

JAX-RS 2.1
CompletionStage<Number> csPrice = client.target("price/{destination}")
.resolveTemplate("destination", "Paris")
.request()
.rx()
.get(Number.class);

CompletionStage<String> csForecast = client.target("forecast/{destination}")
.resolveTemplate("destination", "Paris")
.request()
.rx()
.get(String.class);

csPrice.thenCombine( csForecast, (price, forecast) -> book(price, forecast) );

Demo
The Travel Service
hsps://github.com/jersey/jersey/tree/master/examples/rx-client-webapp

JAX-RS Client API
•  REST Client Side container
•  Synchronous invoker
– Default invoker - javax.ws.rs.client.SyncInvoker
•  Asynchronous invokers
– async() invoker - javax.ws.rs.client.AsyncInvoker
•  Might block -> InvocaPonCallback
– ReacPve rx() invoker - javax.ws.rs.client.RxInvoker
•  New in JAX-RS 2.1!
•  ComplePonStage API + other ReacPve library (opt.)
29
Summary

Server-side REST

Server-side
@Path("/Item")
public class ItemResource {

@Path("{id}")
@Produces(MediaType.APPLICATION_XML)
public ItemResource getItemResource(@PathParam("id") String id) {
return ItemResource.getInstance(id);
}

@POST
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)
public Response createItem(@QueryParam("name") String name) {
//...
return Response.status(Status.OK).entity(…).build();
}
}

Server-side Async

@Path("/Async")
public class ItemResource {

@GET
public void heavyResource(@Suspended AsyncResponse ar) {

mes.execute(new Runnable() {
@Override
public void run() {
try {
// long running computation...
ar.resume(Response.ok(...).build());
} catch (InterruptedException ex) {
// Ooops!
}
}
});
...

Server-side Async
•  Provides means for asynchronous server side response processing
– Injectable via @Suspended
OR
– Resource method can return a ComplePonStage<T> instance (new in JAX-RS 2.1!)
•  Bound to the request
– Suspend
– Resume
– Conﬁgure
– Cancel
33
AsyncResponse interface

Server-side Async
34
Client Server
@Suspended
AsyncResponse.resume(…)
Long running operaPon…
Request
Response

Long running REST operaPons
è POST
... long running operaPon ...
ç ‘201 Created’ + LocaPon
35
è POST
ç ‘202 Accepted’ + Temp LocaPon

è GET Temp LocaPon
ç ‘200 OK’ (+ ETA)
…
è GET Temp LocaPon
ç ‘303 See Other’ + Final LocaPon

Server-sent Events
•  Persistent, one-way communicaPon channel
•  Text protocol, special media type "text/event-stream"
•  Server can send mulPple messages (events) to a client
•  Can contain id, name, comment retry interval
•  Supported in all modern browsers
36

JAX-RS 2.1
37
SSE
•  SseEvent
– ID, Name, Comment, …
•  OutboundSseEvent
– Server-side representaPon of a Server-sent event
– OutboundSseEvent.Builder()
•  InboundSseEvent
– Client-side representaPon of a Server-sent event

JAX-RS 2.1
38
SSE – Server side
•  SseEventSink
– Outbound Server-Sent Events stream
– SseBroadcaster
@GET
@Path ("sse")
@Produces(MediaType.SERVER_SENT_EVENTS)
public void eventStream(@Context SseEventSink eventSink, @Context SSE sse) {
...
eventSink.send( sse.newEvent("an event") );
eventSink.send( sse.newEvent("another event") );
...
eventSink.close();
}

JAX-RS 2.1
39
SSE – Client side
•  SseEventSource
– Client for processing incoming Server-Sent Events

SseEventSource es = SseEventSource.target(SSE_target)
.reconnectingEvery(5, SECONDS)
.build();
es.register(System.out::println); // InboundSseEvent consumer
es.register(...); // Throwable consumer
es.open();
...
es.close();

Wrap-up

JAX-RS
•  Java API for RESTful Web Services
– JAX-RS 2.0 – JSR 339 (*)
– JAX-RS 2.1 – JSR 370
•  Standard based RESTful framework
– Server-side and client-side
– Java SE and Java EE
– Jersey, JBoss RESTEasy, Restlet, Apache CXF, Apache Wink, IBM JAX-RS, …
41

JAX-RS – Client-side
•  REST Client Side container
•  Invokers
– Synchronous
•  javax.ws.rs.client.SyncInvoker
•  Default
– Asynchronous
•  javax.ws.rs.client.AsyncInvoker
– ReacPve
•  New in JAX-RS 2.1!
•  javax.ws.rs.client.AsyncInvoker
42

JAX-RS – Client-side
43
Sync Async RX
Performance and scalability ✗✗ ✔ ✔
Easy to develop and maintain ✔ ✗ ✔
… complex workﬂow ✗ ✗ ✔
… error handling ✗ ✗ ✔
Leverage new Java SE feature ✗ ✗ ✔

JAX-RS –ReacPve Client API
•  Java SE 8 ComplePon Stage
– As mandated by the spec.
•  Jersey
– RxJava - rx.Observable
– RxJava 2 - io.reacPvex.Flowable
– Guava - ListenableFuture
44

JAX-RS – Server-side
•  AsyncResponse
– Resume execuPon on a diﬀerent thread
– @Suspended
– Resource method returning a ComplePonStage<T> instance
•  Long running operaPon pasern
•  Server-sent Events
45

Java EE 8
46
Bean Valida.on
CDI 2.0
JSON-B 1.0
Security 1.0
Bean Valida.on
2.0
JSF 2.3
Servlet 4.0
JSON-P 1.1
JAX-RS 2.1 ReacPve client API, Server-sent events, …
HTTP/2, server push, …
Java <-> JSON binding
Updates to JSON standards, JSON Collectors, …
Async event, event priority, SE support, …
Embrace Java SE 8, new constraints
Improved CDI, WebSocket, SE 8 integraPon, …
Standardized IdenPty Store, AuthenPcaPon, Security Context

Java EE 8
•  Work in progress
– Final Release - Summer 2017 (plan)
•  Open Source Reference ImplementaPons
– hsps://github.com/jersey
– hsps://github.com/javaee
•  Stay tuned…
– hsps://blogs.oracle.com/theaquarium/

47

.‫רבה‬ ‫תודה‬

Resources
•  JAX-RS speciﬁcaPon
– hsps://github.com/jax-rs/api
•  Jersey – Asynchronous Services and Clients
– hsps://jersey.java.net/documentaPon/latest/async.html#d0e8611
– hsps://github.com/jersey/jersey/tree/master/examples/rx-client-webapp
•  ComplePonStage
– hsps://docs.oracle.com/javase/8/docs/api/java/uPl/concurrent/ComplePonStage.html
•  Java EE Tutorial
– hsps://docs.oracle.com/javaee/7/tutorial/
49

REST in an Async World

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à REST in an Async World

Similaire à REST in an Async World (20)

Plus de David Delabassee

Plus de David Delabassee (20)

Dernier

Dernier (20)

REST in an Async World