RxJava from the trenches

mindloops
RXJAVA: FROM THE TRENCHES
PETER HENDRIKS
@PETERHENDRIKS80
PETER@MINDLOOPS.NL

Agenda
• Intro
• Why we want RxJava
• RxJava in Practice
• Future / conclusion

What is ReactiveX?
“A library for composing asynchronous
and event-based programs by using observable
sequences” - Erik Meijer

What is RxJava?
• Port of ReactiveX C# framework to Java
• Open source, lead by Netﬂix
• 1.0.0 release november 2014, 2.0.0 last week :)
• ReactiveX is currently available in 14 programming languages

RxJava Survival Guide
// In your own code, convert results in a fluent way... 
Observable<String> descriptionObservable = eventObservable.map(event -> event.getDescription());
// e.g. Database, services, keyboard, messaging etc. 
MyEventProducer eventProducer = new MyEventProducer();
// use some custom adapter code to adapt to an RxJava "Observable" 
Observable<MyEvent> eventObservable = eventProducer.toObservable();
// ... And compose with other Observables 
Observable<Success> storeObservable = eventObservable.flatMap(event -> storeEvent(event)); 
 
private Observable<Success> storeEvent(MyEvent event) { 
// stores the event asynchronously... 
}
// Start flowing by subscribing and do something with final results
storeObservable.subscribe(myEvent -> {/* do something */}, error -> LOG.error("Oops", error));

Case: Sanoma Learning
• Web e-learning platform
• Many users
• Co-development: multiple
agile product teams

Case: Sanoma Learning
• AngularJS, Java 8, Vert.x,
MongoDB, AWS S3, Redis
• Suite of micro-services 
 
 
 
Microservices met Vert.x
- Tim van Eindhoven, Zaal 4, 11:30

Why we want RxJava
• Avoid “callback hell”
• Out of the box support
• Streaming performance beneﬁts

Simplicity of the POJAM
• A simple, blocking Plain Old JAva Method
• Predictable execution ﬂow
• Fully built-in result and error handling
• Easy to compose
public List<QuestionView> listQuestions(String studentId, String segmentId) { 
List<Question> questions = contentService.findBySegmentId(segmentId); 
 
List<QuestionView> result = new ArrayList<>(); 
for(Question question : questions) { 
Progress progress = progressService.findByQuestionId(studentId, question.getId()); 
result.add(new QuestionView(question, progress)); 
} 
return result; 
}

Vert.x callback example
MessageConsumer<String> consumer = eventBus.consumer("news.uk.sport"); 
consumer.handler(message -> { 
try { 
System.out.println("I have received a message: " + message.body()); 
message.reply("how interesting!"); 
} catch (Exception e) { 
message.fail(500, e.getMessage()); 
} 
}); 
 
sendNewsMessage("Yay! Someone kicked a ball across a patch of grass", ar -> { 
if (ar.succeeded()) { 
System.out.println("Received reply: " + ar.result().body()); 
} else { 
ar.cause().printStackTrace(); 
} 
});
private void sendNewsMessage(String message, Handler<AsyncResult<Message<Object>>> replyHandler) { 
eventBus.send("news.uk.sport", message, replyHandler); 
}

Callback hell
void listQuestions(String studentId, String segmentId, Handler<AsyncResult<List<QuestionView>>> resultHandler) { 
findBySegmentId(segmentId, ar -> { 
List<QuestionView> result = new ArrayList<>(); 
List<Question> questions = ar.result().body(); 
findByQuestionId(studentId, question.getId(), progressAr -> { 
Progress progress = progressAr.result().body(); 
questions.remove(question); 
if (questions.isEmpty()) { 
resultHandler.handle(Future.<List<QuestionView>>succeededFuture(result)); 
} 
} else { 
resultHandler.handle(Future.<List<QuestionView>>failedFuture(ar.cause())); 
} 
}); 
} 
} else { 
resultHandler.handle(Future.<List<QuestionView>>failedFuture(progressAr.cause())); 
} 
} ); 
} 
 
private void findBySegmentId(String segmentId, Handler<AsyncResult<Message<List<Question>>>> handler) {} 
 
private void findByQuestionId(String studentId, String questionId, Handler<AsyncResult<Message<Progress>>> handler) {}

Solution: RxJava as “Promise API”
public Observable<QuestionView> listQuestions(String studentId, String segmentId) { 
return contentService.findBySegmentId(segmentId) 
.concatMap(question -> progressService.findByQuestionId(studentId, question.getId()) 
.map(progress -> new QuestionView(question, progress))); 
}

RxJava: one Promise API to rule them all
• We want to use one promise API
everywhere to ﬁx callback hell
• RxJava is directly supported in Vert.x and
the MongoDB Java driver

Typical request processing overhead
Thread
Request
Response (List)
Domain data
(List)
public List<QuestionView> listQuestions(String studentId, String segmentId) { 
List<Question> questions = contentService.findBySegmentId(segmentId); 
 
List<Question> result = new ArrayList<>(); 
Progress progress =
progressService.findByQuestionId(studentId, question.getId()); 
} 
return result; 
}

Streaming == less intermediate data needed
public Observable<QuestionView> listQuestions(String studentId, String
segmentId) { 
.flatMap(question ->
progressService.findByQuestionId(studentId, question.getId()) 
}
Thread
Request
Response (List)
Domain data
(element)

“Simple” promises vs RxJava
CompletableFuture Observable
What emits 1 event or 1 error emit 0 or more events and/or 1 error
When
Immediately scheduled for
execution
already executing, or only after
subscription
Where
Event can be read at any time
after completion
Event is available once

Learn to stream ﬁrst!
• RxJava will force you to do it
• It helps to be comfortable with Java 8 Stream API ﬁrst
• Java 8 Stream API still very useful for POJAM code
public Observable<QuestionView> listQuestions(String studentId, String segmentId) { 
.flatMap(question -> progressService.findByQuestionId(studentId, question.getId()) 
}

Hot vs Cold Observables
// HOT 
MyEventProducer eventProducer = new MyEventProducer(); 
// some other code... 
Observable<MyEvent> hotObservable = Observable.create(subscriber -> { 
// Listen to producer here. 
}); 
hotObservable.subscribe(myEvent -> {/* do something with event */});
// COLD 
Observable<MyEvent> coldObservable = Observable.create(subscriber -> { 
MyEventProducer eventProducer = new MyEventProducer(); 
// Listen to producer here. 
}); 
// some other code... 
coldObservable.subscribe(myEvent -> {/* do something with event */});

Examples of hot and cold
// HOT example 
HttpServer server = vertx.createHttpServer(); 
Observable<HttpServerRequest> requests = server.requestStream().toObservable(); 
// some other code 
requests.subscribe(request -> System.out.println(request.absoluteURI()));
//COLD example 
MongoClient mongoClient = MongoClients.create(); 
MongoCollection<Document> questionCollection =
mongoClient.getDatabase("contents").getCollection("questions"); 
Observable<Document> allQuestions = questionCollection.find().toObservable(); 
// some other code 
allQuestions.subscribe(question -> System.out.println(question));

Always end with subscribe somewhere
// wrong way to check value
@Test 
public void storeAnswerStoresAnswer() { 
Observable<QuestionView> questionView = answerController.storeAnswer("1", "test"); 
 
questionView.map(view -> assertThat(view, is(testView))); 
}
// use test subscriber to test observables in isolation
@Test 
public void storeAnswerStoresAnswer() { 
Observable<QuestionView> questionView = answerController.storeAnswer("1", "test"); 
 
TestSubscriber<QuestionView> ts = new TestSubscriber<>(); 
questionView.subscribe(ts); 
ts.awaitTerminalEvent(); 
ts.assertNoErrors(); 
ts.assertValue(testValue); 
}

0 or more events dilemma
// POJAM 
public QuestionView storeAnswer(String questionId, String textValue) { 
Question question = contentService.findByQuestionId(questionId); 
if (question == null) { 
throw new IllegalStateException("question not found"); 
} 
Answer answer = validateAnswer(question, textValue); 
progressService.store(questionId, answer); 
return new QuestionView(question, answer); 
}
// RxJava wrong 
public Observable<QuestionView> storeAnswer(String questionId, String textValue) { 
return contentService.findByQuestionId(questionId) 
.flatMap(question -> { 
return progressService.store(questionId, answer) 
.map(x -> new QuestionView(question, answer)); 
}); 
}
// RxJava with switch 
public Observable<QuestionView> storeAnswer(String questionId, String textValue) { 
.switchIfEmpty(Observable.defer(() -> 
Observable.error(new IllegalStateException("question not found")))) 
.flatMap(question -> { 
return progressService.store(questionId, answer) 
.map(x -> new QuestionView(question, answer)); 
}); 
}

Mapping “always empty” results
public Observable<Void> storeResult(String answer) { 
System.out.println("Do some async operation without result."); 
return Observable.empty(); 
} 
 
public Observable<String> processRequest(String answer) { 
// This does not work right 
return storeResult(answer) 
.map(x -> "success!"); 
}
public interface MongoCollection<TDocument> { 
/** 
* @return an Observable with a single element indicating when the operation has completed
or with either a com.mongodb.DuplicateKeyException or com.mongodb.MongoException 
*/ 
Observable<Success> insertOne(TDocument document); 
} 
// Return non-null event to be compatible with RxJava 2.x 
public enum Success { 
SUCCESS 
}
Will change in RxJava 2.x
Better distinction between 0, 1,
optional and multiple results

Make it easy to do the right thing

Only use RxJava when needed
• POJAM code still the best for a lot of your code
• Use RxJava only for async composition/streaming
public boolean isAnswerCorrect(Question question, String answer) { 
// some complicated synchronised checking logic here 
return true; 
} 
 
public Observable<String> processRequest(String questionId, String answer) { 
.map(question -> isAnswerCorrect(question, answer)) 
.map(result -> result ? "Good job!" : "Better luck next time!"); 
}

Separate subscribe code
• Separate and reuse subscribe code from observable chains
// BAD: subscription mixed with observable code 
public void processRequest(HttpServerRequest request, String questionId, String answer) { 
contentService.findByQuestionId(questionId) 
.map(result -> result ? "Good job!" : "Better luck next time!") 
.subscribe(result -> request.response().end(result)); 
}
// GOOD: simple observable code, easy to test and cannot forget to subscribe 
public Observable<String> processRequest(String questionId, String answer) { 
.map(result -> result ? "Good job!" : "Better luck next time!"); 
}

Async code and crappy stack traces
public static void main(String[] args) { 
Observable.empty() 
.observeOn(Schedulers.io()) 
.toBlocking() 
.first(); 
}
Exception in thread "main" java.util.NoSuchElementException: Sequence contains no elements 
at rx.internal.operators.OperatorSingle$ParentSubscriber.onCompleted(OperatorSingle.java:131) 
at rx.internal.operators.OperatorTake$1.onCompleted(OperatorTake.java:53) 
at rx.internal.operators.OperatorObserveOn$ObserveOnSubscriber.pollQueue(OperatorObserveOn.java:195) 
at rx.internal.operators.OperatorObserveOn$ObserveOnSubscriber$1.call(OperatorObserveOn.java:162) 
at rx.internal.schedulers.ScheduledAction.run(ScheduledAction.java:55) 
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) 
at java.util.concurrent.FutureTask.run(FutureTask.java:266) 
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$201(<…>.java:180) 
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(<…>.java:293) 
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142) 
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617) 
at java.lang.Thread.run(Thread.java:745)

Band-aid: add context to logging/exceptions
// generic wrapping code 
public void processRequest(HttpServerRequest request, 
Function<HttpServerRequest, Observable<String>> processor) { 
Observable<String> observable = processor.apply(request); 
observable.subscribe( 
result -> processResult(request, result), 
error -> processError(request, error)); 
} 
 
private void processError(HttpServerRequest request, Throwable error) { 
LOG.error("An error occurred processing: " + request.uri(), error); 
request.response().setStatusCode(500).setStatusMessage(error.getMessage()).end(); 
}

The Future of RxJava looks promising
• Increased adoption for “Reactive Streams”
• RxJava 2 solves some API weirdness and simpliﬁes simple event handling
• Strong adoption in Android and JavaScript
• Spring 5 goes big on reactive, including RxJava support

Spring example
@RestController 
public class RxJavaController { 
private final RxJavaService aService; 
@Autowired 
public RxJavaController(RxJavaService aService) { 
this.aService = aService; 
} 
@RequestMapping(path = "/handleMessageRxJava", method = RequestMethod.POST) 
public Observable<MessageAcknowledgement> handleMessage(@RequestBody Message message) { 
System.out.println("Got Message.."); 
return this.aService.handleMessage(message); 
} 
}

RxJava 2.x
Reactive Streams
(Backpressure)
No Backpressure
0..n items,
complete, error
Flowable Observable
0..1 item, complete,
error
Maybe
1 item, error Single
complete, error Completable

CONCLUSION
RxJava in practice
- Learning to stream
- Hot vs Cold observables
- Always subscribe
- 0 or more events dilemma
- Dealing with always empty results Make it easy
- Still use POJAM code
- Separate subscribe code
- Make up for stack trace
Why we want RxJava
- Avoid Callback Hell
- Streaming helps performance
- Out of the box support
PETER HENDRIKS
@PETERHENDRIKS80
PETER@MINDLOOPS.NL

RxJava from the trenches

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to RxJava from the trenches

Similar to RxJava from the trenches (20)

Recently uploaded

Recently uploaded (20)

RxJava from the trenches