Introductory RxJava

void task(int num) {
log("begin task " + num);
sleep(1000L); // Work 1, 2,... N
log("end task " + num);
}
...
log("START");
task(1);
log("END");
log("DONE");

work 1 | work 2 | … | work N

sleep(1000L); // Work 1, 2,... N
}
...
log("START");
task(1);
task(2);
task(3);
log("END");
log("DONE");

class Task implements Runnable {
private final int id;
Task(int id) {
this.id = id;
}
public void run() {
task(id);
}
}

sleep(1000L); // Work 1, 2,... N
}
...
log(“START");
Thread t1, t2, t3;
t1 = new Thread(new Task(1)); t1.start();
log("END");
t1.join(); t2.join(); t3.join();
log("DONE");

synchronized void task(int num) {
sleep(1000L); // Work 1, 2,... N
}
...
log("START");
Thread t1, t2, t3;
log("END");
t1.join(); t2.join(); t3.join();
log("DONE");

Independent Each Other
Resource Consuming, Heavyweight Task

Order doesn’t Matter (Commutative)
Lightweight Calculation

Independent work part (fork) collecting result part (join)

int total = 0;
int integral(String sector, int from, int to) {
log("Sector %s integral from %d" , sector, from);
sleep((to - from) * 1000L); // integral takes very long time
log("Sector %s integral to %d" , sector, to);
return (to - from) * 1000;
}
synchronized void accumulate(String sector, int partial) {
log("Prepare adding sector %s + %d", sector, partial);
sleep(500L); // accumulation also tasks time
total += partial;
log("Done adding sector %s + %d", sector, partial);
}
class Partial implements Runnable {
final String sector; final int from, to;
Partial(String s, int f, int t) { sector = s; from = f; to = t; }
public void run() {
int partial = integral(sector, from, to);
accumulate(sector, partial);
}
}

t1 = new Thread(new Partial("A",0,5));
t2 = new Thread(new Partial("B",5,10));
t3 = new Thread(new Partial("C",10,15));
t1.start();
t2.start();
t3.start();
t1.join();
t2.join();
t3.join();
log("RESULT: " + total);

total = integral("ABC", 0, 15);
log("RESULT: " + total);

Thread Spawning Cost User Implemented Work

Thread Resource User Work
Thread Resource User Work

List<String> list = Arrays.asList("a", "b", "c");
// list is container for “string event”,
// so “x” is string by type inference
list.forEach(x -> log(x.toUpperCase());
List<Integer> list = Arrays.asList(1, 2, 3);
// list is container for “integer event”,
// so “x” is integer by type inference
list.forEach(x -> log(x + x));

http://reactivex.io/intro.html

log("START");
try {
List<Integer> l = // [1, 2, 3, null, 5]
for (Integer each : l) {
log("> just: " + each);
if (!filter(each)) { continue; }
log("> filter: " + each);
Integer y = map(each);
log("> map: " + y);
log("subscribe: " + y);
}
log("completed");
} catch (Throwable t) {
log("error: " + t);
} finally {
log("END");
}
boolean filter(Integer x) {
return x % 2 == 1;
}
Integer map(Integer in) {
return in * 10;
}
log("START");
Observable.just(1, 2, 3, null, 5)
.doOnNext(x -> log("> just: " + x))
.filter(x -> x % 2 == 1)
.doOnNext(x -> log("> filter: " + x))
.map(x -> x * 10)
.doOnNext(x -> log("> map: " + x))
.subscribe(
x -> log("subscribe: " + x),
ex -> log("error: " + ex),
() -> log("completed")
);
log("END");
11.119 [main] START
11.121 [main] > just: 1
11.124 [main] > filter: 1
11.125 [main] > map: 10
11.127 [main] subscribe: 10
11.128 [main] > just: 2
11.129 [main] > just: 3
11.129 [main] > filter: 3
11.130 [main] > map: 30
11.130 [main] subscribe: 30
11.131 [main] > just: null
11.140 [main] error: java.lang.NullPointerException
11.142 [main] END

// List<Event> events = …
try {
for (Event e : events) {
onNextEvent(e);
}
onSuccessfulComplete();
onErrorEvent(t);
}

// List<Event> events = …
try {
events.forEach(e -> onNextEvent(e));
onErrorEvent(t);
}

// Stream<Event> stream = …
try {
stream
.map(e -> transform(e))
// more transformations 
.forEach(e -> onNextEvent(e));
onErrorEvent(t);
}

// Observable<Event> observable = …
observable
.map(e -> transform(e))
// more transformations 
.subscribe(
e -> onNextEvent(e),
t -> onSuccessfulComplete(),
() -> onErrorEvent(t)
);

// input expressed as: ‘a’, ‘b’, ‘c’
Output hardWork(Input in) {
log("Beginning Work: " + in.id());
// Very HARD WORK such as Network I/O
log("Done Work: " + in.id());
return out;
}

log("start")
observable.map(x -> hardWork(x))
.filter(x -> f(x))
.operator(x -> g(x))
...
.subscribe(x -> log("result: " + x);
log("end");

log("start")
observable.map(x -> hardWork(x))
.filter(x -> f(x))
.subscribeOn(scheduler)
...
log("end");

log("start")
observable
.flatMap(x ->
Observable.fromCallable(() -> hardWork(x))
.subscribeOn(scheduler)
)
.filter(x -> f(x))
...
log("end");

log("start")
observable
.flatMap(x ->
Observable.defer(() ->
Observable.just(hardWork(x))
).subscribeOn(scheduler)
)
.filter(x -> f(x))
...
log("end");

log("prepare");
Observable<Long> a = Observable.just("bread")
.doOnNext(x -> log("substream: " + x))
.map(x -> repository.purchase(x, 1))
.subscribeOn(schedulerA());
Observable<Long> b = Observable.just("cucumber")
Observable<Long> c = Observable.just("beef")
log("start");
Observable.just(a, b, c)
.flatMap(x -> x)
.observeOn(schedulerB())
// .reduce((x, y) -> x.add(y))
.subscribe(x -> log("Q'ty: " + x));
log("end");

Destinations
Quoting
Customers

destination.path("recommended").request().header("Rx-User", "Async").async()
.get(new InvocationCallback<List<Destination>>() {
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("destination", dest.getDestination()).request().async()
.get(new InvocationCallback<Forecast>() {
public void completed(final Forecast forecast) {
forecasts.put(dest.getDestination(), forecast); innerLatch.countDown();
}
public void failed(final Throwable throwable) {
errors.offer("Forecast: " + throwable.getMessage()); innerLatch.countDown();
}
});
}
try {
if (!innerLatch.await(10, TimeUnit.SECONDS))
errors.offer("Inner: Waiting for requests to complete has timed out.");
} catch (final InterruptedException e) {
errors.offer("Inner: Waiting for requests to complete has been interrupted.");
}
// Continue with processing.
}
public void failed(final Throwable throwable) { errors.offer("Recommended: " + throwable.getMessage()); }
});

Observable<Destination> recommended = RxObservable.from(dest)
.path("recommended")
.request()
.header("Rx-User", "RxJava")
.rx().get(new GenericType<List<Destination>>() {})
.onErrorReturn(t -> emptyList())
.flatMap(Observable::from)
.cache();
Observable<Forecast> forecasts = recommended.flatMap(dest ->
RxObservable.from(forecast)
.resolveTemplate("destination", dest.getDestination())
.request().rx().get(Forecast.class)
.onErrorReturn(t -> new Forecast(dest.getDestination(), "N/A")
)
);
Observable<Recommendation> recommendations = Observable.zip(
recommended,
forecasts,
Recommendation::new);

Existing Structure (SpringCamp 2016)
user 
service
40+ tables
admin 
console
client
slave 
(MySQL)master 
(MySQL)
adjustment
C/R/U/D
update “list” order
fetch “list”
10+ RPCs

C/R/U/D
replicator40+ tables
admin 
console
composite json
master 
(MySQL)
item data
adjustment
purchase data
#1
#2
Asymmetric Replication (SpringCamp 2016)
user 
service
NoSQL replica 
(Couchbase) client

List<FixedDeal> fixed = fixedDealService.find(cid, bid);
FixedDealPagination pagination = FixedDealPagination.paginate(fixed, limit);
FixedDealPage currentPage = pagination.find(pageNo);
PaginationOffset offset = PaginationOffset.adjust(currentPage);
List<String> plain = plainDealService.find(cid, bid, offset);
List<String> collatedIds = PageRankCollator.collate(currentPage, plain)
return Observable.from(collatedIds)
.concatMapEager(repository::get)
.map(JsonDocument::content)
.map(stickerFilter::apply)
.map(priceFilter::apply)
.map(viewAttributeFilter::apply)
.toList()
.toBlocking()
.singleOrDefault(Json.DEAL_LIST_DEFAULT);

Observable<FixedDeal> fixed = fixedDealService.prepare(cid, bid, pageNo, limit);
Observable<PlainDeal> plain = plainDealService.prepare(cid, bid, pageNo, limit);
return Observable.zip(fixed, plain, DealId::collate)
.flatMap(DealId::targets)
.concatMapEager(repository::get)
.map(JsonDocument::content)
.map(stickerFilter::apply)
.map(priceFilter::apply)
.map(viewAttributeFilter::apply)
.toList()
.toBlocking()
.singleOrDefault(Json.DEAL_LIST_DEFAULT);

// 1. gather from N tables concurrently, then aggregate
// 2. insert to replica persistence
Observable<Deal> deal = Observable.just(dealNo)
.flatMap(id -> dealRepository.findDeferred(id))
.retry(3)
.onErrorReturn(throwable -> Deal.ERROR);
Observable<DealCategory> category = Observable.just(categoryNo)
.flatMap(id -> dealCategoryRepository.findDeferred(id))
.retry(3)
.onErrorReturn(throwable -> DealCategory.ERROR);
Observable<DealScore> score = Observable.just(dealNo)
.flatMap(id -> dealScoreRepository.findDeferred(id))
.onErrorReturn(throwable -> DealScore.DEFAULT);
Observable.zip(deal, category, score, DealJson::aggregate)
.observeOn(schedulerSlot.dealSourceScheduler())
.subscribe(src -> replicaService.send(src));

Introductory RxJava

More Related Content

What's hot (20)

Similar to Introductory RxJava (20)

Recently uploaded (20)

Introductory RxJava