public SingleHostConnectionProvider(Observable<HostConnector<W, R>> connectors) { connectors.toSingle() .subscribe(new Action1<HostConnector<W, R>>() { @Override public void call(HostConnector<W, R> connector) { provider = connector.getConnectionProvider(); } }, new Action1<Throwable>() { @Override public void call(Throwable t) { logger.error("Failed while fetching a host connector from a scalar host source", t); } }); }
private static void demoSingle() { Single.just("Hello,World") // 仅能发布单个数据 .subscribeOn(Schedulers.io()) // 在 I/O 线程执行 .subscribe(RxJavaDemo::println) // 订阅并且消费数据 ; }
@Override public void start() throws Exception { WebClient client = WebClient.create(vertx); Single<HttpResponse<String>> request = client.get(8080, "localhost", "/") .as(BodyCodec.string()) .rxSend(); // Fire the request request.subscribe(resp -> System.out.println("Server content " + resp.body())); // Again request.subscribe(resp -> System.out.println("Server content " + resp.body())); // And again request.subscribe(resp -> System.out.println("Server content " + resp.body())); } }
@Override public void start() throws Exception { WebClient client = WebClient.create(vertx); Single<HttpResponse<Data>> request = client.get(8080, "localhost", "/") .as(BodyCodec.json(Data.class)) .rxSend(); // Fire the request request.subscribe(resp -> System.out.println("Server content " + resp.body().message)); // Again request.subscribe(resp -> System.out.println("Server content " + resp.body().message)); // And again request.subscribe(resp -> System.out.println("Server content " + resp.body().message)); } }
private void insertAndFind() { // Documents to insert Observable<JsonObject> documents = Observable.just( new JsonObject().put("username", "temporalfox").put("firstname", "Julien").put("password", "bilto"), new JsonObject().put("username", "purplefox").put("firstname", "Tim").put("password", "wibble") ); mongo.rxCreateCollection("users").flatMapObservable(v -> { // After collection is created we insert each document return documents.flatMap(doc -> mongo.rxInsert("users", doc).toObservable()); }).doOnNext(id -> { System.out.println("Inserted document " + id); }).last().toSingle().flatMap(id -> { // Everything has been inserted now we can query mongo System.out.println("Insertions done"); return mongo.rxFind("users", new JsonObject()); }).subscribe(results -> { System.out.println("Results " + results); }, error -> { System.out.println("Err"); error.printStackTrace(); }); } }
@Override public void start() throws Exception { // Create two requests WebClient client = WebClient.create(vertx); Single<JsonObject> request = client.get(8080, "localhost", "/") .as(BodyCodec.jsonObject()) .rxSend() .map(resp -> resp.body()); // Combine the responses with the zip into a single response request .zipWith(request, (b1, b2) -> new JsonObject().put("req1", b1).put("req2", b2)) .subscribe(json -> { System.out.println("Got combined result " + json); }, err -> { err.printStackTrace(); }); } }
reply.subscribe(heats -> {
@Override public void start() throws Exception { EventBus eb = vertx.eventBus(); eb.consumer(ADDRESS) .toObservable() .subscribe(message -> { System.out.println("Received " + message.body()); message.reply("PONG"); }); // Send a message every second vertx.setPeriodic(1000, v -> { eb.rxSend(ADDRESS, "PING") .subscribe(reply -> { System.out.println("Received reply " + reply.body()); }); }); } }
@Override public void start() throws Exception { JsonObject config = new JsonObject().put("url", "jdbc:hsqldb:mem:test?shutdown=true") .put("driver_class", "org.hsqldb.jdbcDriver"); JDBCClient jdbc = JDBCClient.createShared(vertx, config); // Connect to the database jdbc.rxGetConnection().flatMap(conn -> { // Now chain some statements using flatmap composition Single<ResultSet> resa = conn.rxUpdate("CREATE TABLE test(col VARCHAR(20))") .flatMap(result -> conn.rxUpdate("INSERT INTO test (col) VALUES ('val1')")) .flatMap(result -> conn.rxUpdate("INSERT INTO test (col) VALUES ('val2')")) .flatMap(result -> conn.rxQuery("SELECT * FROM test")); return resa.doAfterTerminate(conn::close); }).subscribe(resultSet -> { // Subscribe to the final result System.out.println("Results : " + resultSet.getRows()); }, err -> { System.out.println("Database problem"); err.printStackTrace(); }); } }
} else if (v instanceof Single) { return new Deferred( deferred -> single.apply((Single) v).subscribe(new DeferredSubscriber(deferred))); } else if (v instanceof Completable) { return new Deferred(deferred -> completable.apply((Completable) v)
@Test public void testGetSingleUser() { final String id = "1"; Single<User> user = userService.getSingleUser(id, "name: "); user.subscribe(new Action1<User>() { @Override public void call(User user) { assertEquals(id, user.getId()); } }); com.netflix.hystrix.HystrixInvokableInfo getUserCommand = getHystrixCommandByKey("getSingleUser"); assertTrue(getUserCommand.getExecutionEvents().contains(HystrixEventType.SUCCESS)); }
).subscribe(resultSet -> {
@Test public void testGetSingleUserWithRegularFallback(){ Single<User> user = userService.getSingleUserWithRegularFallback(null, "name: "); user.subscribe(new Action1<User>() { @Override public void call(User user) { assertEquals("default_id", user.getId()); } }); com.netflix.hystrix.HystrixInvokableInfo getUserCommand = getHystrixCommandByKey("getSingleUserWithRegularFallback"); assertTrue(getUserCommand.getExecutionEvents().contains(HystrixEventType.FAILURE)); assertTrue(getUserCommand.getExecutionEvents().contains(HystrixEventType.FALLBACK_SUCCESS)); }
@Test public void testGetSingleUserWithRxFallback(){ Single<User> user = userService.getSingleUserWithRxFallback(null, "name: "); user.subscribe(new Action1<User>() { @Override public void call(User user) { assertEquals("default_id", user.getId()); } }); com.netflix.hystrix.HystrixInvokableInfo getUserCommand = getHystrixCommandByKey("getSingleUserWithRxFallback"); assertTrue(getUserCommand.getExecutionEvents().contains(HystrixEventType.FAILURE)); assertTrue(getUserCommand.getExecutionEvents().contains(HystrixEventType.FALLBACK_SUCCESS)); }
SingleAdaptor(final Single<T> single) { this.subscription = single.subscribe(this::complete, this::completeExceptionally); }
@Override protected void subscribeActual(MaybeObserver<? super T> observer) { SourceSingleSubscriber<T> parent = new SourceSingleSubscriber<T>(observer); observer.onSubscribe(parent); source.subscribe(parent); }
@Override protected void subscribeActual(io.reactivex.SingleObserver<? super T> observer) { SourceSingleSubscriber<T> parent = new SourceSingleSubscriber<T>(observer); observer.onSubscribe(parent); source.subscribe(parent); }
static <T> rx.observers.TestSubscriber<T> test1(rx.Single<T> s) { rx.observers.TestSubscriber<T> ts = new rx.observers.TestSubscriber<T>(); s.subscribe(ts); return ts; }
@Override public ShoppingCartService addCartEvent(CartEvent event, Handler<AsyncResult<Void>> resultHandler) { Future<Void> future = Future.future(); repository.save(event).subscribe(future::complete, future::fail); future.setHandler(resultHandler); return this; }
public CartEventDataSourceImpl(io.vertx.core.Vertx vertx, JsonObject json) { this.client = JDBCClient.createNonShared(Vertx.newInstance(vertx), json); // TODO: Should not init the table here. client.rxGetConnection() .flatMap(connection -> connection.rxExecute(INIT_STATEMENT) .doAfterTerminate(connection::close) ) .subscribe(); }