标签: reactive-programming

Rx如何与反应式编程相关?

我已经读过反应式编程的基本思想,即基于源值表达式随时间变化的变量.我甚至使用表达式实现了这一点.但后来我看看微软的Reactive Extensions(Rx)并看到完全不同的东西.随着时间的推移,自我更新的变量在哪里?没有人看到.只是通过事件参数枚举的一些奇特方式.

所以我的问题是:Rx真的是"反应性"的吗?我们现在看到的功能现在是未来的前奏吗?或者是微软不小心抛出一个流行词?或者我完全忽略了这一点(在这种情况下,我希望你解释一下)?

编辑: 我已经得到了一些很好的答案与Rx的描述,此外问题被关闭.:(但我仍然希望听到更多的:

  1. 在什么意义上Rx"反应"?我认为自我更新变量是这个想法的核心,但Rx不提供这些.LINQ-to-Events似乎是Rx更好的名字.我开始认为,也许微软滥用"反应"一词将其应用于Rx.
  2. 当前的Rx功能可能以何种方式成为自我更新变量的前身?我实现了这样的功能,并没有注意到Rx为此目的有用的东西.

.net reactive-programming system.reactive

5
推荐指数
2
解决办法
822
查看次数

如何用 observables 定义循环

我正在尝试设置一个简单游戏的更新循环,并考虑到可观察性。顶层组件是一个模型,它接受输入命令并产生更新;和一个视图,它显示接收到的更新,并产生输入。孤立地看,两者都可以正常工作,有问题的部分是将两者放在一起,因为两者都依赖于另一个。

将组件简化为以下内容:

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

5
推荐指数
1
解决办法
1816
查看次数

将未知数量的可观察对象与 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”可观察对象,将我的值从模块内部推入其中。

这是一个正确的方法吗?我认为是的,因为它们归我的模块所有,我应该完全控制发生在它们身上的事情,但我真的很感兴趣更有经验的人对此的看法。

javascript reactive-programming observable rxjs

5
推荐指数
1
解决办法
4718
查看次数

RxCpp:观察者的生命周期,如果使用observe_on(rxcpp::observe_on_new_thread())

如果观察者使用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)

c++ reactive-programming rxcpp

5
推荐指数
1
解决办法
1749
查看次数

RxJava- 缓存直到排放闲置一段时间?

我经常遇到一个模式,我不太确定如何有效地解决它。

基本上,如果我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)

java reactive-programming rx-java

5
推荐指数
1
解决办法
903
查看次数

Project Reactor - 如何按窗口处理结果

我有以下通量:

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 中 …

java spring reactive-programming project-reactor

5
推荐指数
1
解决办法
4123
查看次数

多个 Observable 订阅

我需要多次订阅才能从我的 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 似乎有问题。订阅尚未完成,但我开始遍历列表,这给了我一个双重用户列表!

reactive-programming observable rxjs angularfire2 angular

5
推荐指数
1
解决办法
1437
查看次数

RxJava 对列表执行操作并返回一个可观察对象

我是 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 android reactive-programming rx-java rx-java2

5
推荐指数
1
解决办法
2798
查看次数

从反应流 SubmissionPublisher 接收项目

我正在尝试 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)

reactive-programming reactive-streams java-9

5
推荐指数
1
解决办法
525
查看次数

Project Reactor 和 Java 内存模型

我试图了解 Project reactor 为应用程序代码提供的关于数据可见性的保证。例如,我希望下面的代码会失败,但经过一百万次迭代后不会失败。我正在更改线程 A 上典型 POJO 的状态并从线程 B 读取它。 Reactor 是否保证 POJO 更改在线程间可见?

public class Main {
    public static void main(String[] args) {
        Integer result = Flux.range(1, 1_000_000)
                .map(i -> {
                    Data data = new Data();
                    data.setValue(i);
                    data.setValueThreeTimes(i);
                    data.setValueObj(i + i);
                    return data;
                })
                .parallel(250)
                .runOn(Schedulers.newParallel("par", 500))
                .map(d -> {
                    d.setValueThreeTimes(d.getValueThreeTimes() + d.getValue());
                    return d;
                })
                .sequential()
                .parallel(250)
                .runOn(Schedulers.newParallel("par", 500))
                .map(d -> {
                    d.setValueThreeTimes(d.getValueThreeTimes() + d.getValue());
                    return d;
                })
                //                .sequential()
                .map(d -> {
                    if (d.getValue() * 3 != …
Run Code Online (Sandbox Code Playgroud)

java reactive-programming project-reactor

5
推荐指数
1
解决办法
604
查看次数