private static void demoSingle() { Single.just("Hello,World") // 仅能发布单个数据 .subscribeOn(Schedulers.io()) // 在 I/O 线程执行 .subscribe(RxJavaDemo::println) // 订阅并且消费数据 ; }
@GetMapping(value="/hystrix/data", produces="application/json") @ApiOperation(value = "Gets data hystrix", notes="Gets data asynchronously with hystrix") @ApiResponses(value={@ApiResponse(code=200, message="OK")}) public Single<List<Data>> getDataHystrix(){ Observable<List<Data>> observable = dataService.loadDataHystrix(); //XXX subscribeOn es necesario, si no se haría en el hilo http return observable.toSingle().subscribeOn(scheduler); }
@GetMapping(value="/observable/data", produces="application/json") @ApiOperation(value = "Gets data through Observable returning Observable", notes="Gets data asynchronously through Observable returning Observable") @ApiResponses(value={@ApiResponse(code=200, message="OK")}) public Single<List<Data>> getDataObservable2(){ Observable<List<Data>> dataObservable = dataService.loadDataObservable(); //XXX subscribeOn es necesario, si no se haría en el hilo http return dataObservable.toSingle().subscribeOn(scheduler); }
@CheckResult @NonNull public static <T> Single<T> subscribeOn( @NonNull StorIOSQLite storIOSQLite, @NonNull Single<T> single ) { final Scheduler scheduler = storIOSQLite.defaultScheduler(); return scheduler != null ? single.subscribeOn(scheduler) : single; }
public LiveData<List<Movie>> getMovies() { Single<Response<SearchResult>> resultObservable = movieApi.getMovieList(); resultObservable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(searchResult -> { if (!searchResult.isSuccessful()) { Log.i("Repository", "not respond"); } else { movieDatabaseHelper.save(searchResult.body().getSearch()); } }, throwable -> Log.i("Repository", throwable.getMessage())); return movieDatabaseHelper.getAll(); } }
public static <T> void request(Single<Response<T>> single, ApiListener<T> listener) { single.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe((Response<T> tResponse) -> { if (tResponse.isSuccessful()) { listener.onSuccess(tResponse.body()); } else { listener.onServerError(tResponse.errorBody().toString()); } }, listener::onError); }
private void fetchOverpassLimit(final Double lat, final Double lon) { if (overpassSubscription != null) return; //Active request to Overpass has not responded yet String data = "[out:json];way(around:" + RADIUS + "," + lat + "," + lon + ")[\"highway\"][\"maxspeed\"];out;"; overpassSubscription = overpassService.getLimit(data) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new SingleSubscriber<OverpassResponse>() { @Override public void onSuccess(OverpassResponse overpassResponse) { overpassSubscription = null; overpassManager.handleResponse(overpassResponse, lat, lon); } @Override public void onError(Throwable error) { overpassSubscription = null; //Error was already logged in OverpassInterceptor } }); }
Single<String> content(int id) { return Single.fromCallable(() -> jdbcTemplate .queryForObject( "SELECT content FROM articles WHERE id = ?", String.class, id)) .subscribeOn(Schedulers.io()); }
public void getCats(List<Cat> cats) { checkViewAttached(); mSubscription = mDataManager.getCats(cats) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.io()) .subscribe(new SingleSubscriber<List<Cat>>() { @Override public void onSuccess(List<Cat> cats) { getMvpView().showCats(cats); } @Override public void onError(Throwable error) { getMvpView().showCatsError(); Timber.e(error, "There was an error loading the cats!"); } }); }
public void searchCats(List<Cat> cats) { checkViewAttached(); mSubscription = mDataManager.getCats(cats) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.io()) .subscribe(new SingleSubscriber<List<Cat>>() { @Override public void onSuccess(List<Cat> cats) { getMvpView().showCats(cats); } @Override public void onError(Throwable error) { getMvpView().showCatsError(); Timber.e(error, "There was an error loading the cats!"); } }); }
public static Single<String> getDataB() { return Single.just("DataB") .subscribeOn(Schedulers.io()); }
public Single<FinishedIndicator> createAccount(NameFirstname nameFirstname) { return Single.fromCallable(() -> { try { SysOutUtils.sysout("Processing: " + nameFirstname.toString()); Thread.sleep(5000); // = Simulation of a "very slow" backend SysOutUtils.sysout("Finished: " + nameFirstname.toString()); } catch (InterruptedException e) { SysOutUtils.sysout("Interrupted (=cancelled) -> good!"); } return FinishedIndicator.INSTANCE; }).subscribeOn(Schedulers.io()); }
public static Single<String> getDataA() { return Single.<String> create(o -> { o.onSuccess("DataA"); }).subscribeOn(Schedulers.io()); }
}).subscribeOn(Schedulers.io());
@Test public void test() { getList() .subscribeOn(Schedulers.io()) .flatMapObservable(list -> Observable.from(list)) .flatMap(each -> getSubdetails(each)) .subscribe(new Subscriber<Boolean>() { @Override public void onNext(Boolean t) { } @Override public void onError(Throwable error) { } @Override public void onCompleted() { } }); } }
private Observable<String> createProblematicObservable() { return Observable.<String>fromCallable(() -> { throw new IllegalStateException(); }) .toSingle() .subscribeOn(scheduler) .toObservable() .onErrorResumeNext(caughtError -> { return Observable.just("OK"); }); }
@Test public void test() throws Exception { Single.fromCallable(() -> 42) .subscribeOn(Schedulers.io()) .observeOn(Schedulers.computation()) .doOnSubscribe(() -> System.out.println("subscribed")) .doOnUnsubscribe(() -> System.out.println("unsubscribed")) .subscribe(integer -> System.out.println("got result")); Thread.sleep(1000); } }
@Test public void test() throws Exception { Observable.fromCallable(() -> { throw new IOException(); }) .toSingle() .subscribeOn(Schedulers.computation()) .toObservable() .toSingle() .onErrorResumeNext(v -> Single.just(1)) .subscribe(System.out::println, Throwable::printStackTrace); Thread.sleep(1000); }
@Override public void connectTo(final Example_5_Model model) { onEventFrom(vm2m_nameFirstname).executeAsync(nameFirstname -> { Single<Boolean> modelCallFinished = Single.<Boolean>create(singleSubscriber -> { try { model.createAccount(nameFirstname); if (!singleSubscriber.isUnsubscribed()) { singleSubscriber.onSuccess(true); } } catch (InterruptedException e) { SysOutUtils.sysout("Interrupted (=cancelled) -> good!"); } }).subscribeOn(Schedulers.io()); Single.merge(modelCallFinished, v2vm_cancelButtonEvents.first().toSingle()) .toBlocking() .first(); vm2v_nameEnabled.onNext(true); vm2v_firstnameEnabled.onNext(true); vm2v_submitButtonEnabled.onNext(true); vm2v_cancelButtonEnabled.onNext(false); }); } }
@Test public void plainSubscribeCheck() { Single.<String>fromCallable(() -> { throw new IllegalStateException(); }) .subscribeOn(Schedulers.immediate()) .toObservable() .onErrorResumeNext(throwable -> Observable.empty()) .subscribe(new TestSubscriber<>()); Observable.<String>fromCallable(() -> { throw new IllegalStateException(); }) .subscribeOn(Schedulers.immediate()) .onErrorResumeNext(throwable -> Observable.empty()) .subscribe(new TestSubscriber<>()); } }