Reactive Applications in Enterprise Java

@ArneLimburg @_openknowledge #WISSENTEILEN
Reactive Applications
in Enterprise Java
@ArneLimburg
@_openknowledge

ÜBER MICH
Reactive Enterprise Java | Arne Limburg
• Enterprise Architect bei der open knowledge GmbH
• Themen
• Microservices
• Domain Driven Design
• APIs
• Architektur
• Coaching
• Technologie (JEE)
Arne Limburg

Was ist eigentlich
Reactive Programming?

Reactive Programming
in der Praxis?

Reactive Javascript
var request = new XMLHttpRequest();
request.open("POST", "/orders", true);
request.onload = function (e) {
...
};
request.send(null);
1
2
3
4

Asynchronous JAX-RS Client
ClientBuilder
.newClient ()
.target("https://...")
.request()
.async()
.get(new InvocationCallback<OrderStatus>() {
public void completed(OrderStatus response) {
…
}
public void failed(Throwable error) {
…
}
});
^

@GET @Path("/orders/{orderNo}/status")
public void waitForStatusChange(
@PathParam("orderNo") UUID orderNo,
@Suspended AsyncResponse asyncResponse) {
newClient().target("https://...payment-service...").request().async()
public void completed(PaymentStatus statusResponse) {
asyncResponse.resume(statusResponse::toPaymentStatus);
}
public void failed(Throwable error) { … }
});
}
Asynchronous JAX-RS
^

public void waitForStatusChange(
@PathParam("orderNo") UUID orderNo,
@Suspended AsyncResponse asyncResponse) {
newClient().target("https://...payment-service...").request().async()
public void completed(PaymentStatus statusResponse) { … }
public void failed(Throwable error) {
asyncResponse.resume(error);
}
});
}
Asynchronous JAX-RS

Willkommen in der Callback-Hölle

Promises in Javascript
fetch("https://...order-service...")
.then(…)
.catch(…)

Mit Java 8 – CompletableFuture
@Inject
private ManagedExecutorService executor;
@POST
public void createCustomer(final Customer customer,
@Suspended final AsyncResponse asyncResponse) {
CompletableFuture
.supplyAsync(() -> createCustomer(customer), executor)
.thenApply(customer -> buildResponse(customer))
.thenAccept(asyncResponse::resume);
}

public CompletitonStage<OrderStatus> getOrderStatus(
@PathParam("orderNo") UUID orderNo) {
return newClient()
.target("https://...payment-service...")
.request()
.rx()
.get()
.exceptionally(…)
.thenApply(OrderStatus::fromPaymentStatus);
}
Mit JAX RS 2.1 und CompletionStage

Kombination mehrerer Ergebnisse in JS
Promise.all([
fetch("https://...payment-service..."),
fetch("https://...stock-service..."),
fetch("https://...shipping-service...")
])
.then(…)
.catch(…)

Kombination mehrerer Ergebnisse
^
^
public CompletableFuture<OrderStatus> getOrderStatus(
@PathParam("orderNo") UUID orderNo) {
CompletionStage<PaymentStatus> paymentResponse
= newClient().target("https://...payment-serv...")
.rx().get(PaymentStatus.class);
CompletionStage<StockStatus> stockResponse
= newClient().target("https://...stock-service...")
.rx().get(StockStatus.class);
return paymentResponse
.thenCombine(stockResponse, (p, s) -> OrderStatus.of(…));
}
^
^

Stream-Oriented Programming
91
'[' '{' '"' '}' ',' '{' ... '}''n' 'a' 'm' 'e' '"' ':' ...
123 34 110 ...

91
'[' '{' '"' '}' ',' '{' ... '}'
[ { "name" } , { ... }
'n' 'a' 'm' 'e' '"' ':' ...
: ...
123 34 110 ...

91
'[' '{' '"' '}' ',' '{' ... '}'
[ { "name" } , { ... }
'n' 'a' 'm' 'e' '"' ':' ...
: ...
{"name": ... } {...}
Customer 1 Customer 2
123 34 110 ...

ReactiveX / Akka / Project Reactor
input
.map(Converter::toCharacter)
.buffer(Tokenizer::tokenize)
.buffer(JsonObjectCollector::collect)
.map(CustomerOrder::new);

Reactive Support in Java 9

Java 9 Flow API
public interface Flow.Publisher<T>;
public interface Flow.Subscriber<T>;
public interface Flow.Processor<T, R>;
public interface Flow.Subscription;

Java 9 Flow API
public interface Flow.Publisher<T> {
void subscribe(Flow.Subscriber<? super T> subscriber);
}

Java 9 Flow API
public interface Flow.Subscriber<T> {
void onSubscribe(Flow.Subscription subscription);
void onNext(T item);
void onError(Throwable error);
void onComplete();
}

Java 9 Flow API
public interface Flow.Subscription {
void request(long n);
void cancel();
}

Java 9 Flow API
public interface Flow.Processor<T, R>
extends Flow.Subscriber<T>, Flow.Publisher<R> {
}

Reactive mit Spring Webflux
@GetMapping("/orders/{orderNo}/status")
public Mono<OrderStatus> getStatus(@PathVariable("orderNo") number) {
return WebClient
.create("https://…payment-service…")
.get()
.accept(APPLICATION_JSON)
.retrieve()
.toMono(PaymentStatus.class)
.map(OrderStatus::fromPaymentStatus);
}

Logging & Debugging?
@GetMapping("/orders/{orderNo}/status")
public Mono<OrderStatus> getStatus(@PathVariable("orderNo") number) {
Hooks.onOperatorDebug();
return WebClient
.create("https://…payment-service…")
.get()
.accept(APPLICATION_JSON)
.retrieve()
.toMono(PaymentStatus.class)
.log()
.checkpoint() // alternative to Hooks.onOperatorDebug()
.map(OrderStatus::fromPaymentStatus);
}

Kombinierter Status mit Project Reactor
Mono<OrderStatus> orderStatus
= Mono.zip(
WebClient.create("https://…payment-service…").get()
.accept(APPLICATION_JSON).retrieve().toMono(PaymentStatus.class),
WebClient.create("https://…stock-service…").get()
.accept(APPLICATION_JSON).retrieve().toMono(StockStatus.class),
WebClient.create("https://…shipping-service…").get()
.accept(APPLICATION_JSON).retrieve().toMono(ShippingStatus.class))
.map(this::toOrderStatus);

Reactive mit Spring Webflux
@GetMapping("/orders")
public Flux<CustomerOrder> getOrders() {
return orderRepository.findAll();
}

Reactive Mongo DB mit Spring
public interface ReactiveMongoOperations {
<T> Mono<T> findOne(Query query, Class<T> entityClass);
<T> Flux<T> find(Query query, Class<T> entityClass);
<T> Mono<T> insert(T objectToSave, String collectionName);
<T> Mono<T> insert(Mono<? extends T> objectToSave);
}

Reactive Database Access mit R2DBC
Publisher<OrderItem> items = client.execute()
.sql("SELECT ITEM_ID, ITEM_NAME FROM TAB_ORDER_ITEM")
.fetch()
.all();
items.subscribe(rowProcessor);

Reactive mit Spring Data R2DBC
public class OrderService {
@Inject private OrderItemRepository repository;
@Transactional
public Flux<Order> processOrder(Order order) {
… = repository.findByOrderNumber(order.getNumber());
…
}
}
public interface OrderItemRepository extends CrudRepository<OrderItem, …> {
@Query("SELECT ITEM_ID, … FROM ORDER_ITEM WHERE ORDER_NO = :orderNo")
Flux<OrderItem> findByOrderNumber(String orderNo);
}

Reactive als Java Sprachfeature?

Async & Await in Javascript
async function fetch(url) { … }
const paymentResponse
= await fetch("https://…payment-service…");
const paymentStatus = await paymentResponse.json();
const stockResponse
= await fetch("https://…stock-service…");
const stockStatus = await stockResponse.json();

Async & Await in Javascript
const orderIds = await connection
.execute("SELECT orderId FROM CustomerOrder ");
async function execute(sql) {
return new Promise(…);
}

Blockierender Thread in Java
ResultSet result = statement
.executeQuery("SELECT orderId FROM CustomerOrder");
while (result.next()) {
…
}

Blockierender Thread in Java
ResultSet result
= statement
.executeQuery("SELECT orderId FROM CustomerOrder");
while (result.next()) {
…
}

Fazit
CompletionStage reicht meistens
Integration von Reactive Bibliotheken mit Flow
Project Loom to rule them all

FRAGEN
? ? ?

KONTAKT
ARNE LIMBURG
ENTERPRISE ARCHITECT
arne.limburg@openknowledge.de
+49 (0)441 4082 – 0
Icons in this presentation designed by “Freepik”, “Nice and Serious” and “Elegant Themes” from www.flaticon.com
OFFENKUNDIGGUT

Reactive Applications in Enterprise Java

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie Reactive Applications in Enterprise Java

Ähnlich wie Reactive Applications in Enterprise Java (20)

Mehr von OPEN KNOWLEDGE GmbH

Mehr von OPEN KNOWLEDGE GmbH (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Reactive Applications in Enterprise Java