Apresentação feita no meetup do PagSeguro na iMasters sobre como utilizar Rx-Java em aplicações existentes.

1. RxJava: Como compor sua aplicação
com Observables

3. async + callbacks

4. async + callbacks

5. Future<T>
Future<List<T>>

6. Future<T>
Future<List<T>>

7. Future<T>
Future<List<T>>
Future<List<Future<T>>>

8. Observable<T>
Future<T>
Future<List<T>>
Future<List<Future<T>>>

9. Tudo é um fluxo de dados

10. List<Order> getOrders(int customerId)
List<Product> getProducts(Order order)
ShippingStatus getShippingStatus(Order o, Product p)
getOrders → getProducts → getShippingStatus

11. List<Order> getOrders(int customerId)
List<Product> getProducts(Order order)
ShippingStatus getShippingStatus(Order o, Product p)
APIs blocantes
getOrders → getProducts → getShippingStatus

12. IPC via Apache HTTP
Memcached
Cassandra
Tomcat e Servlets

13. IPC via Apache HTTP
Memcached
Cassandra
Tomcat e Servlets
Todos blocantes

14. Fachada assíncrona

15. Observable<Order> getOrders(int customerId)
Observable<Product> getProducts(Order order)
Observable<ShippingStatus> getShippingStatus(Order o, Product p)
getOrdersAsync → getProductsAsync → getShippingStatusAsync
getOrders → getProducts → getShippingStatus

16. Observable<Order> getOrders(int customerId)
Observable<Product> getProducts(Order order)
Observable<ShippingStatus> getShippingStatus(Order o, Product p)
getOrdersAsync → getProductsAsync → getShippingStatusAsync
API observável
getOrders → getProducts → getShippingStatus

17. getOrdersAsync(1)
.limit(1)
.flatMap(o -> {
return getProductsAsync(o)
.flatMap(p -> {
return getShippingStatusAsync(o, p);
});
})
.forEach(s -> System.out.println(Thread.currentThread()
+ " [Async] Shipping Status: " + s));

18. getOrdersAsync(1)
.limit(1)
.flatMap(o -> {
return getProductsAsync(o)
.flatMap(p -> {
return getShippingStatusAsync(o, p);
});
})
.forEach(s -> System.out.println(Thread.currentThread()
+ " [Async] Shipping Status: " + s));

19. getOrdersAsync(1)
.limit(1)
.flatMap(o -> {
return getProductsAsync(o)
.flatMap(p -> {
return getShippingStatusAsync(o, p);
});
})
.forEach(s -> System.out.println(Thread.currentThread()
+ " [Async] Shipping Status: " + s));

20. getOrdersAsync(1)
.limit(1)
.flatMap(o -> {
return getProductsAsync(o)
.flatMap(p -> {
return getShippingStatusAsync(o, p);
});
})
.forEach(s -> System.out.println(Thread.currentThread()
+ " [Async] Shipping Status: " + s));

21. Observable<ShippingStatus> getShippingStatusAsync(Order o, Product p)
ShippingStatus getShippingStatus(Order o, Product p)

22. Observable<ShippingStatus> getShippingStatusAsync(Order o, Product p)
return Observable.defer(() -> {
return Observable.just(getShippingStatus(o, p));
}).subscribeOn(Schedulers.io());

23. Observable<ShippingStatus> getShippingStatusAsync(Order o, Product p)
return Observable.defer(() -> {
return Observable.just(getShippingStatus(o, p));
}).subscribeOn(Schedulers.io());

24. Observable<ShippingStatus> getShippingStatusAsync(Order o, Product p)
return Observable.defer(() -> {
return Observable.just(getShippingStatus(o, p));
}).subscribeOn(Schedulers.io());

25. Observable<ShippingStatus> getShippingStatusAsync(Order o, Product p)
return Observable.defer(() -> {
return Observable.just(getShippingStatus(o, p));
}).subscribeOn(Schedulers.io());

26. Observable<ShippingStatus> getShippingStatusAsync(Order o, Product p)
return Observable.defer(() -> {
return Observable.just(getShippingStatus(o, p));
}).subscribeOn(Schedulers.io());

27. List<Order> orders = getOrders(1);
Observable<Order> orders = getOrdersAsync(1);

28. List<Order> orders = getOrders(1);
Observable<Order> orders = getOrdersAsync(1);

29. List<Order> orders = getOrders(1);
Observable<Order> orders = getOrdersAsync(1);

30. return Observable.defer(() -> {
return Observable.from(getOrders(customerId));
}).subscribeOn(Schedulers.io());
Observable<Order> orders = getOrdersAsync(1);

31. return Observable.defer(() -> {
return Observable.from(getOrders(customerId));
}).subscribeOn(Schedulers.io());
Observable<Order> orders = getOrdersAsync(1);

32. Observable<Order> orders = getOrdersAsync(1);
return Observable.defer(() -> {
return Observable.from(getOrders(customerId));
}).subscribeOn(Schedulers.io());

33. return Observable.defer(() -> {
return Observable.from(getOrders(customerId));
}).subscribeOn(Schedulers.io());
Observable<Order> orders = getOrdersAsync(1);

34. return Observable.defer(() -> {
return Observable.from(getOrders(customerId));
}).subscribeOn(Schedulers.io());
Observable<Order> orders = getOrdersAsync(1);

35. Encapsulado por threads
JDBC?

36. List<Order> orders = getOrders(1);
try (Connection c = Database.getConnection()) {
ResultSet rs = c.createStatement()
.executeQuery("select * from orders");
ArrayList<Order> orders = new ArrayList<>();
while (rs.next()) {
orders.add(new Order(rs.getInt(1)));
}
rs.close();
return orders;
} catch (Exception e) {
throw new RuntimeException(e);
}

37. List<Order> orders = getOrders(1);
try (Connection c = Database.getConnection()) {
ResultSet rs = c.createStatement()
.executeQuery("select * from orders");
ArrayList<Order> orders = new ArrayList<>();
while (rs.next()) {
orders.add(new Order(rs.getInt(1)));
}
rs.close();
return orders;
} catch (Exception e) {
throw new RuntimeException(e);
}

38. Observable<Order> orders = getOrdersAsync(1);
return Observable.<Order> create(o -> {
try (Connection c = Database.getConnection()) {
ResultSet rs = c.createStatement()
.executeQuery("select * from orders");
while (rs.next() && !o.isUnsubscribed()) {
o.onNext(new Order(rs.getInt(1)));
}
rs.close();
o.onCompleted();
} catch (Exception e) {
o.onError(e);
}
}).subscribeOn(Schedulers.io());

39. Observable<Order> orders = getOrdersAsync(1);
return Observable.<Order> create(o -> {
try (Connection c = Database.getConnection()) {
ResultSet rs = c.createStatement()
.executeQuery("select * from orders");
while (rs.next() && !o.isUnsubscribed()) {
o.onNext(new Order(rs.getInt(1)));
}
rs.close();
o.onCompleted();
} catch (Exception e) {
o.onError(e);
}
}).subscribeOn(Schedulers.io());

40. return Observable.<Order> create(o -> {
try (Connection c = Database.getConnection()) {
ResultSet rs = c.createStatement()
.executeQuery("select * from orders");
while (rs.next() && !o.isUnsubscribed()) {
o.onNext(new Order(rs.getInt(1)));
}
rs.close();
o.onCompleted();
} catch (Exception e) {
o.onError(e);
}
}).subscribeOn(Schedulers.io());
Observable<Order> orders = getOrdersAsync(1);

41. return Observable.<Order> create(o -> {
try (Connection c = Database.getConnection()) {
ResultSet rs = c.createStatement()
.executeQuery("select * from orders");
while (rs.next() && !o.isUnsubscribed()) {
o.onNext(new Order(rs.getInt(1)));
}
rs.close();
o.onCompleted();
} catch (Exception e) {
o.onError(e);
}
}).subscribeOn(Schedulers.io());
Observable<Order> orders = getOrdersAsync(1);

42. return Observable.<Order> create(o -> {
try (Connection c = Database.getConnection()) {
ResultSet rs = c.createStatement()
.executeQuery("select * from orders");
while (rs.next() && !o.isUnsubscribed()) {
o.onNext(new Order(rs.getInt(1)));
}
rs.close();
o.onCompleted();
} catch (Exception e) {
o.onError(e);
}
}).subscribeOn(Schedulers.io());
Observable<Order> orders = getOrdersAsync(1);

43. return Observable.<Order> create(o -> {
try (Connection c = Database.getConnection()) {
ResultSet rs = c.createStatement()
.executeQuery("select * from orders");
while (rs.next() && !o.isUnsubscribed()) {
o.onNext(new Order(rs.getInt(1)));
}
rs.close();
o.onCompleted();
} catch (Exception e) {
o.onError(e);
}
}).subscribeOn(Schedulers.io());
Observable<Order> orders = getOrdersAsync(1);

44. ou com suporte a backpressure …

45. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

46. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

47. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

48. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

49. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

50. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

51. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

52. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

53. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

54. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

55. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

56. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

57. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

58. return Observable.create(SyncOnSubscribe.<Order, ResultSet> create(s -> {
ResultSet rs = s.state();
try {
if (rs.next()) {
s.onNext(new Order(rs.getInt(1)));
} else {
s.onCompleted();
}
} catch (SQLException e) {
s.onError(e);
}
}, s -> {
Connection c = Database.getConnection();
try {
Statement stmt = c.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
java.sql.ResultSet.CONCUR_READ_ONLY);
stmt.setFetchSize(Integer.MIN_VALUE);
return stmt.executeQuery("select * from orders");
} catch (SQLException e) {
s.onError(e);
return null;
}
}, rs -> rs.close() } // ignoring try/catch for slide brevity
)).subscribeOn(Schedulers.io());

59. Observable.defer
Observable.from/just
Observable.subscribeOn
Observable.create

60. protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
try {
// perform service composition asynchronously
getShippingStatusForCustomerOrdersAsync(req.getParameter(“customerId"))
.toBlocking() // block on servlet thread
.forEach(status -> {
try {
// write output using blocking IO
resp.getWriter().write(status.toString());
} catch (Exception e) {
throw new RuntimeException("unable to write", e);
}
});
} catch (Exception e) {
// toBlocking and forEach will convert async onError events into thrown exceptions
resp.setStatus(500);
// write and log error ...
}
}

61. protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
try {
// perform service composition asynchronously
getShippingStatusForCustomerOrdersAsync(req.getParameter("customerId"))
.toBlocking() // block on servlet thread
.forEach(status -> {
try {
// write output using blocking IO
resp.getWriter().write(status.toString());
} catch (Exception e) {
throw new RuntimeException("unable to write", e);
}
});
} catch (Exception e) {
// toBlocking and forEach will convert async onError events into thrown exceptions
resp.setStatus(500);
// write and log error ...
}
}

62. protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
try {
// perform service composition asynchronously
getShippingStatusForCustomerOrdersAsync(req.getParameter("customerId"))
.toBlocking() // block on servlet thread
.forEach(status -> {
try {
// write output using blocking IO
resp.getWriter().write(status.toString());
} catch (Exception e) {
throw new RuntimeException("unable to write", e);
}
});
} catch (Exception e) {
// toBlocking and forEach will convert async onError events into thrown exceptions
resp.setStatus(500);
// write and log error ...
}
}

63. Observable<ShippingStatus> getShippingStatusForCustomerOrdersAsync(String customerId) {
return getOrdersAsync(Integer.parseInt(customerId))
.limit(1)
.flatMap(o -> {
return getProductsAsync(o)
.flatMap(p -> {
return getShippingStatusAsync(o, p);
});
});
}

64. Observable<ShippingStatus> getShippingStatusForCustomerOrdersAsync(String customerId) {
return getOrdersAsync(Integer.parseInt(customerId))
.limit(1)
.flatMap(o -> {
return getProductsAsync(o)
.flatMap(p -> {
return getShippingStatusAsync(o, p);
});
});
}

65. Observable<ShippingStatus> getShippingStatusForCustomerOrdersAsync(String customerId) {
return getOrdersAsync(Integer.parseInt(customerId))
.limit(1)
.flatMap(o -> {
return getProductsAsync(o)
.flatMap(p -> {
return getShippingStatusAsync(o, p);
});
});
}

66. protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
try {
// perform service composition asynchronously
getShippingStatusForCustomerOrdersAsync(req.getParameter("customerId"))
.toBlocking() // block on servlet thread
.forEach(status -> {
try {
// write output using blocking IO
resp.getWriter().write(status.toString());
} catch (Exception e) {
throw new RuntimeException("unable to write", e);
}
});
} catch (Exception e) {
// toBlocking and forEach will convert async onError events into thrown exceptions
resp.setStatus(500);
// write and log error ...
}
}

67. protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
try {
// perform service composition asynchronously
getShippingStatusForCustomerOrdersAsync(req.getParameter("customerId"))
.toBlocking() // block on servlet thread
.forEach(status -> {
try {
// write output using blocking IO
resp.getWriter().write(status.toString());
} catch (Exception e) {
throw new RuntimeException("unable to write", e);
}
});
} catch (Exception e) {
// toBlocking and forEach will convert async onError events into thrown exceptions
resp.setStatus(500);
// write and log error ...
}
}

68. protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
try {
// perform service composition asynchronously
getShippingStatusForCustomerOrdersAsync(req.getParameter("customerId"))
.toBlocking() // block on servlet thread
.forEach(status -> {
try {
// write output using blocking IO
resp.getWriter().write(status.toString());
} catch (Exception e) {
throw new RuntimeException("unable to write", e);
}
});
} catch (Exception e) {
// toBlocking and forEach will convert async onError events into thrown exceptions
resp.setStatus(500);
// write and log error ...
}
}

69. Observable.toBlocking

70. Observable.toBlocking
Ponte entre sincrono e assincrono

71. Como adicionar código reativo
em um projeto existente?

72. Iterable<String> is = Arrays.asList("a", "b", "c");
ArrayList<String> ts = new ArrayList<>();
for(String s : is) {
ts.add(s + "-modified");
}
// do stuff with ts ...
Observable<String> os = Observable.just("a", "b", "c");
os.map(s -> s + "-modified");
// do stuff with os ...

73. try {
for (String s : is) {
ts.add(s + "-modified");
}
} catch (Exception e) {
// do something with exception
}
os.map(s -> s + "-modified")
.onErrorResumeNext(exception -> {
// do something with exception
return Observable.empty();
});

74. Leia a documentação

77. Debug assincrono é mais difícil

78. java.lang.RuntimeException: failure!
at jdbc.Test.lambda$19(Test.java:63)
at jdbc.Test$$Lambda$8/888452645.call(Unknown Source)
at rx.internal.operators.OperatorMap$1.onNext(OperatorMap.java:55)
at rx.internal.operators.OperatorSubscribeOn$1$1$1.onNext(OperatorSubscribeOn.java:76)
at rx.observables.AbstractOnSubscribe$SubscriptionState.accept(AbstractOnSubscribe.java:533)
at rx.observables.AbstractOnSubscribe$SubscriptionProducer.doNext(AbstractOnSubscribe.java:367)
at rx.observables.AbstractOnSubscribe$SubscriptionProducer.request(AbstractOnSubscribe.java:345)
at rx.internal.operators.OperatorSubscribeOn$1$1$1$1.request(OperatorSubscribeOn.java:88)
at rx.Subscriber.setProducer(Subscriber.java:177)
at rx.Subscriber.setProducer(Subscriber.java:171)
at rx.internal.operators.OperatorSubscribeOn$1$1$1.setProducer(OperatorSubscribeOn.java:81)
at rx.observables.AbstractOnSubscribe.call(AbstractOnSubscribe.java:191)
at rx.observables.AbstractOnSubscribe$LambdaOnSubscribe.call(AbstractOnSubscribe.java:274)
at rx.Observable.unsafeSubscribe(Observable.java:7495)
at rx.internal.operators.OperatorSubscribeOn$1$1.call(OperatorSubscribeOn.java:62)
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(ScheduledThreadPoolExecutor.java:180)
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.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)
Caused by: rx.exceptions.OnErrorThrowable$OnNextValue: OnError while emitting onNext value: jdbc.Product.class
at rx.exceptions.OnErrorThrowable.addValueAsLastCause(OnErrorThrowable.java:98)
at rx.internal.operators.OperatorMap$1.onNext(OperatorMap.java:58)
... 20 more
Stacktraces feios

80. C10k e além

81. 0%
25%
50%
75%
100%
50 100 150 200 250 300 350 400 450 500 550 600 650 700 750 800 850 900 950 100010501100
RxNetty Tomcat
Uso de CPU em percentual
concurrent clients

82. 0ms
0.225ms
0.45ms
0.675ms
0.9ms
50 100 150 200 250 300 350 400 450 500 550 600 650 700 750 800 850 900 950 100010501100
RxNetty Tomcat
Consumo de CPU por requisição
concurrent clients

83. 0rps
1250rps
2500rps
3750rps
5000rps
50 100 150 200 250 300 350 400 450 500 550 600 650 700 750 800 850 900 950 100010501100
RxNetty Tomcat
Vazão
concurrent clients

84. 0
400000
800000
1200000
1600000
50 100 150 200 250 300 350 400 450 500 550 600 650 700 750 800 850 900 950 100010501100
RxNetty Tomcat
Migração de thread
concurrent clients