我最近一直在阅读关于rx-java的一些内容.我想知道框架是否适合线程之间的通信系统的账单.我正在使用java编写的REST服务器.每次某些资源是PUT/POST时,我想使用工作线程池进行一些计算.但是,我仍然希望能够监控请求,也许打印出一些统计信息.基本上我想要一个,Observable所以我可以灵活地处理多个Observers 的请求.
我的问题是,我该如何创造一个合适的Observable?我见过的大多数指南都涉及对Observables的操作,例如映射等.Obervables主要是从集合或整数范围创建的.在任何情况下,似乎都不可能将新值推送到创建的Observables.显然,保持这种灵活性的唯一方法就是使用Observable.create.然而,这似乎是相当低级的.我必须为每个新订阅者实现一个队列列表,并对每个订阅者进行synchronized推送.这是真的有必要还是已经在rx-java中实现了这样的东西?
我想Observable从列表的结果中实时生成Futures.
在最简单的情况下,假设我有一个我正在运行的期货清单Future.sequence,而我只是监控他们的进度,Observable每次完成时都会告诉我.我基本上是这样做的:
def observeFuturesProgress(futs: List[Future[Int]]) : Observable[String] = {
Observable[String](observer => {
val loudFutures: List[Future[Int]] = futs.map(f => {
f onComplete {
case Success(a) => observer.onNext(s"just did $a more")
case Failure(e) => observer.onError(e)
}
f
})
Future.sequence(loudFutures) onComplete {
case Success(_) => observer.onCompleted()
case Failure(e) => observer.onError(e)
}
})
}
Run Code Online (Sandbox Code Playgroud)
这在我的测试环境中工作正常.但我刚刚读过,onNext不应该从不同的线程调用,至少不要小心没有重叠的调用.建议的解决方法是什么?似乎许多现实世界的使用Observables需要onNext从这样的异步代码中调用,但我在文档中找不到类似的例子.
我正在为Android中的RxJava observable创建单元测试.
我想从模拟中链接返回值并在observable中模拟错误/恢复值.
我这样做:
when(repository.getObservable())
.thenReturn(Observable.error(new Exception()))
.thenReturn(Observable.just(driver));
Run Code Online (Sandbox Code Playgroud)
我的观察:
return repository.getObservable()
.retryWhen(observale -> {
return observable
.zipWith(Observable.range(1, 3), Pair::create)
.flatMap(o -> {
if (o.second < count) {
return Observable.timer(1000, TimeUnit.MILLISECONDS);
}
return Observable.error(o.first);
})))
Run Code Online (Sandbox Code Playgroud)
但我只接受了Observable.error(new Exception()),甚至称该retryWhen方法3次以上.
有人知道我怎样才能测试重新发射不同的观测值以测试retryWhen操作员?
谢谢!
我在scala Play Framework 2.5中使用java ReactiveX(RxJava)与couchbase异步通信我想知道我的observable运行需要多长时间?我使用下面的代码定义我的observable.
def get(id: String) : Observable[Profile] = {
this.bucket
.async()
// can I have a start time here possibly using map?
.get(id)
.map[Profile](toProfile)
// can I have an end time here possibly using map?
}
Run Code Online (Sandbox Code Playgroud)
我用以下方法称呼它
Thread.sleep(1000)
val observable = get("myID")
Thread.sleep(1000)
// measure start time here
println("observable: " + observable.toBlocking.first())
// measure end time here
Thread.sleep(1000)
Run Code Online (Sandbox Code Playgroud)
如何衡量观察者运行所需的时间?
提前感谢你
弗朗西斯
我有一种方法可以将多个文件同时上传到云存储.它看起来像这样:
List<String> files = Arrays.asList("file0", "file1", "file2");
Observable.from(files)
.flatMap(file -> uploadFile(file)
.flatMap(done -> notifyFinished(file)))
.subscribe(this::onNext, this::onError, this::onCompleted);
private Observable<Boolean> uploadFile(String file) {
Timber.d("Uploading: " + file);
return Observable.just(true).delay(6, TimeUnit.SECONDS);
}
private Observable<Boolean> notifyFinished(String file) {
Timber.d("Notify finished: " + file);
return Observable.just(true).delay(3, TimeUnit.SECONDS);
}
Run Code Online (Sandbox Code Playgroud)
这个输出是:
06-09 02:10:04.779 D: Uploading: file0
06-09 02:10:04.780 D: Uploading: file1
06-09 02:10:04.781 D: Uploading: file2
06-09 02:10:10.782 D: Notify finished: file1
06-09 02:10:10.782 D: Notify finished: file0
06-09 02:10:10.783 D: Notify finished: file2
06-09 02:10:13.784 …Run Code Online (Sandbox Code Playgroud) 我想List<Object>根据用户的查询进行过滤,然后返回List<Object>给他/她.我发现了如何过滤项目但问题是我不知道如何返回List<Object>.我也看到了一些迭代和调用的方法,flatMap但我不认为这是一种优雅的方式.
这是我的最后一次尝试:
Observable.from(my_list_of_object)
.debounce(500, TimeUnit.MILLISECONDS)
.filter(new Func1<MyObject, Boolean>() {
@Override
public Boolean call(MyObject o) {
return o.getName().contains(query); //filtering
}
})
.observeOn(Schedulers.computation())
//problem is here and I dont know how
//to convert filtered Item to list
Run Code Online (Sandbox Code Playgroud) 我为我的应用程序构建了一个API,它位于一个带有请求限制的网关后面.在我构建API之前,我的应用程序协调自己的请求,因此可以在几毫秒内启动许多请求,以便在用于获取数据的9个提供程序之间同步应用程序的数据.现在,这个逻辑被推到了我的API适配器层,我需要考虑如何控制每秒的请求数量,以避免达到我自己的速率限制.提高速率限制不是一种选择,因为它需要网关提供商中的一个层级冲击,我不愿意支付.
为了在Java社区内进行这种强有力的运动,我选择将RxJava与Retrofit和Retrolamba一起用于我构建的API SDK.这基本上是成功的,并且在没有问题的情况下在现场运行.
现在,我的应用程序允许用户保存"点",当同步检索该区域的当地天气,潮汐和膨胀条件时.每个点使用4个API资源来获得完整的数据集,具体而言;
/luna/locations/xtide/{id} - Luna Event detail (read: tide times)
/solar/locations/xtide/{id} - Solar Event detail (read: sunrise/sunset)
/water/locations/{provider}/{id}{?daysData} - Water Event detail (read: swell measures)
/meteo/wwo/weather{?query,daysData} - Meteo Event detail (read: weather data)
Run Code Online (Sandbox Code Playgroud)
该应用程序允许任意数量的点,n意味着使用当前代码我每个点有4n个请求.例如,如果我保存了10个点并尝试同步 - 我将导致4*10 = 40个API请求在0.75秒左右被触发!
我想使用Rx来简化我的API请求的自我编程过程.这是我希望实现的(希望是准确的)大理石图表;
该SynchronisationService.java代码看起来有点像这样;
Observable.zip(
Observable.from(spots),
Observable.interval(SYNC_TICK, TimeUnit.MILLISECONDS),
(obs, timer) -> obs)
.subscribeOn(scheduler)
.observeOn(scheduler)
.unsubscribeOn(scheduler)
.flatMap(spot -> syncTidePosition.get().buildObservable(spot))
.subscribe(spotAndTideEvent -> new TideEventSubscriber(
lunaEventService,
synchronisationIntentProvider.get(),
spotAndTideEvent.spot,
String.format( …Run Code Online (Sandbox Code Playgroud) 在使用RxJava 2的Android项目中,我Flowable在onCreate我的初始活动中创建了这样的:
Flowable.create(new MyFlowableOnSubscribe1(), BackpressureStrategy.BUFFER)
.doOnComplete(new MyAction())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new MySubscriber());
Run Code Online (Sandbox Code Playgroud)
FlowableOnSubscribe的实现是:
public class MyFlowableOnSubscribe1 implements FlowableOnSubscribe<String> {
public static final String TAG = "XX MyFlOnSub1";
@Override
public void subscribe(FlowableEmitter<String> emitter) {
Log.i(TAG, "subscribe");
emitter.onNext("hello");
emitter.onComplete();
}
}
Run Code Online (Sandbox Code Playgroud)
这是订户实施:
public class MySubscriber implements Subscriber<String> {
public static final String TAG = "XX MySubscriber";
@Override
public void onSubscribe(Subscription s) {
Log.i(TAG, "onSubscribe");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete");
}
@Override
public void onError(Throwable e) { …Run Code Online (Sandbox Code Playgroud) 我正在创建一个简单的应用程序,用于使用RxAndroidBle库与蓝牙设备进行连接(干得好!)。我有时遇到的情况是,当我连接到设备时,收到状态为133的Gatt错误。我知道它可能会发生,所以我想做的就是在发生该错误时重试所有内容。没问题,我可以使用retryWhen()运算符轻松地做到这一点,但是我还有另一个要求-如果连接失败,流必须在30秒后终止。我曾经timeout()这样做,但是问题是当我重试时,计时器再次启动。
因此,问题是如何将timeout()运算符与retryWhen()结合使用,以便我可以重试某些特定错误,但保持计数器继续运行。
我对合并可观察变量有一些想法,或者有一些单独的可观察变量,它们将在超时期限后检查连接状态,但是我想知道是否可以在单个可观察变量中进行此操作。
到目前为止,我的代码如下所示:
public Observable<ConnectingViewState> connectToDevice(String macAddress) {
final RxBleDevice rxBleDevice = rxBleClient.getBleDevice(macAddress);
return rxBleDevice.establishConnection(false)
.subscribeOn(Schedulers.io())
.map(rxBleConnection -> new ConnectingViewState.ConnectedViewState(rxBleConnection))
.cast(ConnectingViewState.class)
.timeout(40, TimeUnit.SECONDS)
.startWith(new ConnectingViewState.ConnectingInProgressViewState())
.retryWhen(errors -> errors.flatMap(error -> {
if (isDefaultGattError(error)) {
return Observable.just(new Object());
} else {
return Observable.error(error);
}
}
))
.onErrorReturn(throwable -> new ConnectingViewState.ErrorState(throwable));
}
Run Code Online (Sandbox Code Playgroud) AFAIK debounce()是rxJava 的运营商,用于延迟事件的发射.当我在搜索框中应用它时,它正常工作:
RxTextView.textChangeEvents(editText)
.debounce(1000, TimeUnit.MILLISECONDS) //Only emit after 1 sec
.subscribe(new Observer<TextViewTextChangeEvent>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(TextViewTextChangeEvent event) {
//Get more information about text change event
Log.e(TAG, "Before: " + event.before() + ", start: " + event.start() + ", count: " + event.count());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.e(TAG, "textChangeEvents: onComplete");
}
});
Run Code Online (Sandbox Code Playgroud)
但是当我Observable.range()像这样应用它时:
Observable.range(1, 10000)
.debounce(1000, TimeUnit.MILLISECONDS)
.subscribe(new Observer<Long>() { …Run Code Online (Sandbox Code Playgroud) rx-java ×10
android ×6
java ×6
rx-android ×4
scala ×2
mockito ×1
observable ×1
reactivex ×1
rx-java2 ×1
rx-scala ×1
rxandroidble ×1