作为我们的应用程序的一部分(现在生产大约4个月),我们有一个来自外部设备的数据流,我们将其转换为IObservable
到目前为止,我们一直在使用以下方法来生成它,并且它一直运行良好.
IObservable<string> ObserveStringStream(Stream inputStream)
{
var streamReader = new StreamReader(inputStream);
return Observable
.Create<string>(observer => Scheduler.ThreadPool
.Schedule(() => ReadLoop(streamReader, observer)));
}
private void ReadLoop(StreamReader reader, IObserver<string> observer)
{
while (true)
{
try
{
var line = reader.ReadLine();
if (line != null)
{
observer.OnNext(line);
}
else
{
observer.OnCompleted();
break;
}
}
catch (Exception ex)
{
observer.OnError(ex);
break;
}
}
}
Run Code Online (Sandbox Code Playgroud)
昨晚我想知道是否有办法使用yield return语法来实现相同的结果并想出了这个:
IObservable<string> ObserveStringStream(Stream inputStream)
{
var streamReader = new StreamReader(inputStream);
return ReadLoop(streamReader)
.ToObservable(Scheduler.ThreadPool);
}
private IEnumerable<string> ReadLoop(StreamReader reader) …Run Code Online (Sandbox Code Playgroud) 我提前为本说明的长度道歉.我花了相当多的时间把它做得更短,而且这个小到我能得到它.
我有一个谜,非常感谢你的帮助.这个谜团来自于observer我在Clojure中写的一个rxjava的行为,这个rxjava来自于几个简单observable的在线样本.
一个observable同步onNext向其观察者的处理程序发送消息,我所谓的原则观察者表现得如预期的那样.
另一个observable异步在另一个线程上通过Clojure执行相同的操作future.完全相同的观察者不会捕获发布到其上的所有事件onNext; 它似乎在尾部丢失了随机数量的消息.
在等待promised onCompleted的到期和等待发送给agent收集器的所有事件的到期之间存在有意的争用.如果promise获胜,我希望看到false的onCompleted,并在一个很短可能队列agent.如果agent获胜,我希望看到true的onCompleted,所有的消息来自agent的队列.我不希望的一个结果是true来自onCompletedAND的短队列agent.但是,墨菲没有睡觉,而这正是我所看到的.我不知道垃圾收集是否有问题,或者是否有一些内部排队到Clojure的STM,或者我的愚蠢,或者完全不同的东西.
我在这里以自包含形式的顺序呈现源代码,以便可以直接运行lein repl.有三个cermonials可以解决问题:首先,leiningen项目文件,project.clj声明依赖于0.9.0Netflix的rxjava版本:
(defproject expt2 "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.5.1"]
[com.netflix.rxjava/rxjava-clojure "0.9.0"]]
:main expt2.core)
Run Code Online (Sandbox Code Playgroud)
现在,命名空间和Clojure要求以及Java导入:
(ns expt2.core
(:require clojure.pprint) …Run Code Online (Sandbox Code Playgroud) jsfiddle:https://jsfiddle.net/leiming/5e6rtgwd/
class Sample extends React.Component {
onInputFocus(event) {
console.log('react input focus')
}
onSpanFocus(event) {
console.log('react span focus')
// event.stopPropagation()
}
render() {
return ( <span onFocus = {this.onSpanFocus}>
react input: <input type="text"
onFocus = {this.onInputFocus} />
</span> )
}
}
ReactDOM.render( < Sample / > ,
document.getElementById('container')
);Run Code Online (Sandbox Code Playgroud)
<div id="container">
<!-- This element's contents will be replaced with your component. -->
</div>
<div>
<span onfocus="(function(){console.log('normal span')})()">
normal input:<input type="text" onfocus="(function(){console.log('normal input focus')})()">
</span>
</div>Run Code Online (Sandbox Code Playgroud)
jsfiddle:https://jsfiddle.net/leiming/5e6rtgwd/
使用反应, …
有没有办法实现以下目标:
我有3个类型的观察者Observable<MyData>.我想要的是:
onCompleted第一个观察者onCompleted第二个可观测量onCompleted第三个可观测量这可以用,concat但我只能观察到最后一次onCompleted.
难看的解决方案
我知道,我可以实现这一目标,如果我onCompleted从前一个事件中开始下一个可以理解的话.
题
即使使用任意数量的可观察量,还有其他方法可以实现这一点吗?我想避免从onCompleted事件中将这一切联系在一起,因为这看起来非常丑陋,链接越深,它就越不清楚......
编辑 - UseCase
我想不断更新UI,我想知道,每个级别的数据加载完成
我正在使用RxJava.我必须每5秒执行一次特定的任务.通过使用"Observable.Interval"方法完美地工作.但是,我还有以下约束:如果最后一个任务没有完成,则不能执行新任务.在这种情况下,新任务只有在最后一个完成时才需要执行.
我无法弄清楚如何使用RxJava做到这一点.
所有的想法都会非常感激^^
谢谢阅读.
我们暂时考虑以下代码
Rx.Observable.merge(
Rx.Observable.just(1),
Rx.Observable.just(1).delay(1000)
).distinctUntilChanged()
.subscribe(x => console.log(x))
Run Code Online (Sandbox Code Playgroud)
我们希望1只记录一次.但是,如果我们想要允许重复一个值,如果它的最后一次发射是可配置的时间量呢?我的意思是记录两个事件.
例如,拥有如下内容会很酷
Rx.Observable.merge(
Rx.Observable.just(1),
Rx.Observable.just(1).delay(1000)
).distinctUntilChanged(1000)
.subscribe(x => console.log(x))
Run Code Online (Sandbox Code Playgroud)
其中distinctUntilChanged()接受某种超时以允许重复下一个元素.然而,这样的事情不存在,我想知道是否有人知道通过使用高级操作员实现这一点的优雅方式,而不会弄乱需要处理状态的过滤器
我有一个用例,每当另一个通知者Observable发出时,我都需要Observable跳过其下一个发出。
source: |---X---X---X---X---X---X---X---X---X---X--|>
notifier: |-------------X---------X----------X-------|>
result: |---X---X---X-------X---X-------X-------X--|>
Run Code Online (Sandbox Code Playgroud)
基本上,我希望有一个叫做的运算符skipNextWhen,它以可观察的方式接收通知程序,并跳过源中的下一个发射。
我尝试使用使用pausable运算符的实现(使用来重新实现switchMap),但无法使其正常工作。
停顿的
import { Observable } from 'rxjs/Observable';
import { Subject } from 'rxjs/Subject';
import 'rxjs/add/observable/never';
import 'rxjs/add/operator/startWith';
declare module 'rxjs/Observable' {
interface Observable<T> {
pausable: typeof pausable;
}
}
function pausable<T>(notifier: Observable<boolean>): Observable<T> {
return notifier.startWith(false).switchMap((paused) => {
if (paused) {
return Observable.never();
} else {
const source = new Subject();
this.subscribe(source);
return source;
}
});
}
Observable.prototype.pausable = pausable;
Run Code Online (Sandbox Code Playgroud)
skipNextWhen.ts
import { Observable } …Run Code Online (Sandbox Code Playgroud) 我一直在学习Spring 5 WebFlux,反应式编程和websockets.我看过Josh Long的Spring Tips:Spring Framework 5的Reactive WebSockets.其通过WebSocket连接从服务器将数据发送到客户端的代码使用一个Spring集成IntegrationFlow一个发布到PublishSubcribeChannel其中有一个自定义MessageHandler订阅了它,是以消息时,它转换为一个对象,然后将其转化成JSON和发射到FluxSink从提供给Flux.create()的回调函数,用于发送给WebSocketConnection.
我想知道是否使用IntegrationFlow和PublishSubscribeChannel是将事件从后台进程推送到客户端的推荐方法,或者在这个特定示例中是否更方便(监视文件系统).我想如果你能控制后台进程,你可以让它FluxSink直接发射吗?
我正在考虑类似于以下的用例:
我是反应式编程的新手,这是我正在尝试的
.驾驶
searchController.rx.text
.asDriver()
.drive(onNext: { (element) in
print(element)
}).disposed(by: disposeBag)
Run Code Online (Sandbox Code Playgroud)
.订阅
searchController.rx.text
.asObservable()
.subscribe(onNext: { (element) in
print(element)
}).disposed(by: disposeBag)
Run Code Online (Sandbox Code Playgroud)
这两个区块的工作完全一样,什么是使用的目的.drive了.subscribe?在这情况下,我们应该使用.drive过.subscribe?
任何帮助将不胜感激
我见过这样的照片:
Observable<String> nameChanges = nameDataSource.changes().share();
// One subscriber
autoUnsubscribe(nameChanges.subscribe(() -> { ... }));
// Another subscriber
autoUnsubscribe(nameChanges.map(...).filter(...).subscribe(...));
// autoUnsubscribe is called when the UI is torn down
Run Code Online (Sandbox Code Playgroud)
我的问题是:
为什么每当我想在多个地方收听Observable时都需要调用share()?
为什么不是share()所有observable的默认行为?
如果上面的代码即使没有相同的工作也会很好.share().我不需要考虑何时需要共享Observable,何时不需要.
是出于性能原因,因为拥有一个订户是一个特殊情况,可以更有效地处理?
从文档中我不清楚:
share()返回一个新的ObservableSource,它可以多播(共享)原始的ObservableSource.只要至少有一个观察者,这个ObservableSource就会被订阅并发出数据.