我正在尝试设置一个简单游戏的更新循环,并考虑到可观察性。顶层组件是一个模型,它接受输入命令并产生更新;和一个视图,它显示接收到的更新,并产生输入。孤立地看,两者都可以正常工作,有问题的部分是将两者放在一起,因为两者都依赖于另一个。
将组件简化为以下内容:
var view = function (updates) {
return Rx.Observable.fromArray([1,2,3]);
};
var model = function (inputs) {
return inputs.map(function (i) { return i * 10; });
};
Run Code Online (Sandbox Code Playgroud)
我把事情联系在一起的方式是这样的:
var inputBuffer = new Rx.Subject();
var updates = model(inputBuffer);
var inputs = view(updates);
updates.subscribe(
function (i) { console.log(i); },
function (e) { console.log("Error: " + e); },
function () { console.log("Completed"); }
);
inputs.subscribe(inputBuffer);
Run Code Online (Sandbox Code Playgroud)
也就是说,我添加了一个主题作为输入流的占位符,并将模型附加到该主题上。然后,在构建视图之后,我将实际输入传递给占位符主题,从而关闭循环。
然而,我不禁感到这不是正确的做事方式。为此使用主题似乎有点矫枉过正。有没有办法用 publish() 或 defer() 或类似的方法做同样的事情?
更新:这是一个不太抽象的例子来说明我遇到的问题。下面你会看到一个简单的“游戏”的代码,玩家需要点击一个目标来击中它。目标可以出现在左侧或右侧,每当它被击中时,它就会切换到另一侧。看起来很简单,但我仍然觉得我错过了一些东西......
//-- Helper methods and whatnot
// …Run Code Online (Sandbox Code Playgroud) reactive-programming system.reactive reactive-extensions-js rxjs
我目前正在尝试创建一个小项目来演示使用 RxJS 进行响应式编程。目标是向我的同事展示这个东西就在那里,值得研究。我对框架没有经验,所以这让事情变得复杂。
我正在尝试扩展我的另一个演示以使用 RxJS。不是一个很复杂的demo,基本上我可以添加任意数量的小表格,得到一个小公式计算出来的数字,还有一个按钮,可以汇总所有表格的值。
在表格中计算公式很容易,但我想我可以走得更远。
我想通过合并的 observable 自动完成求和运算。我想出的唯一解决方案是:
//dummy observables
var s1 = Rx.Observable.Interval(100);
var s2 = Rx.Observable.Interval(200);
//Combine the observables
var m = s1.combineLatest(s2, function(x,y){return x+y});
//Subscribe to the combined observable
var sub = m.subscribe(function(x){console.log(x)});
//A new observable is created
var s3 = Rx.Observable.Interval(300);
//Now I need to update all my subscriptions, wich is a pain.
m = m.combine(s3, function(x,y){return x+y});
sub.dispose();
sub=m.subscribe(function(x){console.log(x)});
Run Code Online (Sandbox Code Playgroud)
我想我可以得到另一个 observable 来通知我的订阅者自我更新 - 因为知道我的所有订阅者的工作方式会使整个架构变得毫无用处,但这对于这样的任务来说听起来有点矫枉过正,我不仅仅是指演示,我真的无法想象有一个“每天”真实世界的例子,这样的架构比仅仅观察任何变化和从我的表单“主动”获取计算值更能让事情变得更干净。
我可能会在处理表单的模块内主动获取和汇总值,并让外部世界订阅“m”可观察对象,将我的值从模块内部推入其中。
这是一个正确的方法吗?我认为是的,因为它们归我的模块所有,我应该完全控制发生在它们身上的事情,但我真的很感兴趣更有经验的人对此的看法。
如果观察者使用observe_on(rxcpp::observe_on_new_thread()),等待所有观察者on_completed被调用的正确方法是什么:
例如:
{
Foo foo;
auto generator = [&](rxcpp::subscriber<int> s)
{
s.on_next(1);
// ...
s.on_completed();
};
auto values = rxcpp::observable<>::create<int>(generator).publish();
auto s1 = values.observe_on(rxcpp::observe_on_new_thread())
.subscribe([&](int) { slow_function(foo); }));
auto lifetime = rxcpp::composite_subscription();
lifetime.add([&](){ wrapper.log("unsubscribe"); });
auto s2 = values.ref_count().as_blocking().subscribe(lifetime);
// hope to call something here to wait for the completion of
// s1's on_completed function
}
// the program usually crashes here when foo goes out of scope because
// the slow_function(foo) is still working on foo. I also noticed …Run Code Online (Sandbox Code Playgroud) 我经常遇到一个模式,我不太确定如何有效地解决它。
基本上,如果我Observable<T>持有一个昂贵的物品T,我不想在T每次使用它时重新构建该物品,或者将其映射到一千个不同的其他可观察对象,这将导致它被构建 1000 次。
所以我开始使用replay()缓存它一段时间,但理想情况下我希望它在排放闲置一段时间时清除缓存。
是否有我可以使用的操作员或某些变压器来完成此操作?
public final class ActionManager {
private final Observable<ImmutableList<Action>> actionMap;
private ActionManager() {
this.actionMap = Observable.defer(() -> buildExpensiveList()).replay(10, TimeUnit.SECONDS).autoConnect();
}
//this method could get called thousands of times
//I don't want to rebuild the map for every call
public Observable<Action> forItem(Item item) {
actionMap.map(l -> //get Action for item);
}
}
Run Code Online (Sandbox Code Playgroud)
更新
试图将其实现为 Transformer/Operator 组合。我在这里做错了吗?
public static <T> Transformer<T,T> recacheOnIdle(long time, TimeUnit timeUnit) {
return obs -> …Run Code Online (Sandbox Code Playgroud) 我正在使用Reactive Extensions 'combine_latest在任何输入勾选时执行操作。问题是如果多个输入蜱在同一时间然后combine_latest触发各个输入蜱后多次。这会引起头痛,因为combine_latest它实际上是用陈旧的值进行虚假滴答。
最小工作示例,其中fastobservable 每 10ms 滴答一次,而slowobservable 每 30ms 滴答一次:
from rx.concurrency import HistoricalScheduler
from rx import Observable
from __future__ import print_function
scheduler = HistoricalScheduler(initial_clock=1000)
fast = Observable.generate_with_relative_time(1, lambda x: True, lambda x: x + 1, lambda x: x, lambda x: 10, scheduler=scheduler)
slow = Observable.generate_with_relative_time(3, lambda x: True, lambda x: x + 3, lambda x: x, lambda x: 30, scheduler=scheduler)
Observable.combine_latest(fast, slow, lambda …Run Code Online (Sandbox Code Playgroud) 我有以下通量:
Flux.range(0, 100)
.log("before window")
.window(10)
.map(Flux::toList)
.log("after window")
.map((w) -> {
System.out.println(w.subscribe().get()));
return 1;
})
.reduce(0, (a, b) -> a + b)
.doOnSuccess(System.out::println)
.subscribe();
Run Code Online (Sandbox Code Playgroud)
我想doOnNext此刻我应该能够获得物品块。但.get总是因Timeout on Mono blocking read异常而失败。
我从日志中看到,之前都已处理过.window,结果日志给出:
[ main] before window : onNext(0)
[ main] after window : onNext({ operator : "BufferAll" })
Run Code Online (Sandbox Code Playgroud)
官方文档中没有那么多信息,所以我想我误解了一些东西,并且window错误地使用了函数。但我到底做错了什么?
更新
我发现如果我改用可以避免这个特殊问题.doOnSuccess。喜欢:
.map((w) -> {
w.doOnSuccess((w2) -> System.out.println(w2))).subscribe();
return 1;
}
Run Code Online (Sandbox Code Playgroud)
但真正的问题是,在我的情况下,我需要根据对提供的数据(而不是1)的一些计算来返回一个数字。我可以Mono在这里创建一个新的,但无论如何,以后我应该.get这样做。例如在 final 中 …
我需要多次订阅才能从我的 NoSQL 数据库中获取正确的数据。为了获取特定项目的用户列表,我这样做:
ngOnInit() {
//Subscription 1 (Service): Get project data
this.projectService.getCurrentproject().take(1).subscribe(projectData => {
console.log('Got project data.');
//Subscription 2: Get project user IDS
this.af.database.list('/project_roles/'+projectData.$key)
.subscribe((userMeta) => {
});
});
}
Run Code Online (Sandbox Code Playgroud)
正如你所看到的,一个订阅,一个订阅,一个订阅。每个订阅都依赖于前一个 reslt。
订阅 3 和 4 可以并行。
代码运行良好,但我是否遗漏了什么,或者我认为这是如何处理多个订阅,而前一个的结果取决于下一个?
更新:订阅 #2 似乎有问题。订阅尚未完成,但我开始遍历列表,这给了我一个双重用户列表!
我是 RxJava(特别是 RxJava2)的新手,我在似乎相对简单的操作上遇到了一些麻烦。我需要从数据库中获取一些数据,遍历数据(它表示为一个列表),对每个项目执行操作,将数据包装在另一个对象中并返回。这是我到目前为止:
mDataManager
.getStuffList(id)
.flatMapIterable(listOfStuff -> listOfStuff)
.flatMap(item ->
mDataManager
.performCount(id, item.getTitle())
.doOnNext(item::setCounter)
.takeLast(1)
.map(counter -> item))
.toList()
.toObservable()
.flatMap(listOfStuff -> Observable.just(new StuffWrapper(listOfStuff));
Run Code Online (Sandbox Code Playgroud)
我遇到的问题是我的数据管理器调用永远不会完成。这个想法是,每当底层数据发生变化时,UI 也会发生变化。但是,如果没有完成这些调用, toList() 将不会发出该事件。
我正在尝试 Java 9 中的一些新功能。所以我组织了一个测试,让发布者以给定的速率发出数字。我还实现了一个订阅者来收听这些出版物并将它们打印到控制台。
虽然我可能不完全理解如何使用这个 Api,因为该onNext()方法不打印任何内容,getLastItem()只返回 0。
唯一似乎有效的部分是onSubscribe()正确初始化lastItem变量的部分。
@Test
public void testReactiveStreams(){
//Create Publisher
SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();
//Register Subscriber
TestIntegerSubscriber subscriber = new TestIntegerSubscriber();
publisher.subscribe(subscriber);
assertTrue(publisher.hasSubscribers());
//Publish items
System.out.println("Publishing Items...");
List.of(1,2,3,4,5).stream().forEach(i -> {
publisher.submit(i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// blah
}
});
assertEquals(5, subscriber.getLastItem());
publisher.close();
}
private class TestIntegerSubscriber implements Flow.Subscriber<Integer> {
private int lastItem;
@Override
public void onSubscribe(Flow.Subscription subscription) {
System.out.println("Subscribed");
lastItem = 0;
} …Run Code Online (Sandbox Code Playgroud) 我已多次阅读文档,需要澄清...
鉴于以下代码段:
let signal: Signal<Value,Error>
//call this observer y
signal.take(first: 1).observeValues{ (value) in
//intended strong capture on self. this is the only one that retains self so if this observer is triggered and completes, self should dealloc
self.doSomethingElse(value) //trivial call, no async or thread hopping
}
//call this observer x
signal.take(duringLifetimeOf: self).observeValues{ [unowned self] (value) in //is this safe or better to use weak and guard against it?
self.doSomeProcess(value) //trivial call, no async or thread hopping
}
Run Code Online (Sandbox Code Playgroud)
如果signal被触发并通知其观察者 …