Question

我正在努力理解论文Deprecating the Observer Pattern，这似乎对“反应性”编程的发展有一定影响。

然而，所有的例子都在Scala中，这阻碍了我的理解。有没有人将这些示例翻译成更常见的语言，如Java或JavaScript？或者是否有类似的介绍，使用超过7人的语言中的示例？：）

如果这属于不同的堆栈，请告诉我。

Answer 1

您可能对RxJava感兴趣吗？说明：

JVM的Reactive Extensions - 一个使用Java VM的可观察序列组成异步和基于事件的程序的库。

This page解释了使用Java 7 en 8的反应式编程（示例如图7所示）。例如：

Integer[] numbers = { 0, 1, 2, 3, 4, 5 };

Observable numberObservable = Observable.from(numbers);

numberObservable.subscribe(
        new Action1<Integer>() {
            @Override
            public void call(Integer incomingNumber) {
                System.out.println(incomingNumber);
            }
        },
        new Action1<Throwable>() {
            @Override
            public void call(Throwable error) {
                System.out.println("Error in synchronous observable");
            }
        },
        new Action0() {
            @Override
            public void call() {
                System.out.println("This observable is finished");
            }

        }
);

Answer 2

文章认为，观察者模式导致许多错误，因为它很难推理（需要使用副作用来维持状态，缺乏统一性，控制反转......）并且很难应用好实践（关注点分离，封装，......）。

然后继续展示如何使用Scala.React库，从基于可观察的代码库转换为被动代码库。

在这个答案中，我将使用“scalenglish”和“javenglish”来尝试解释我所理解的代码。

第一步（第2项）是创建事件抽象。使用Event，您现在可以使用统一的接口来封装observable。然后它继续并定义“合并”方法，然后允许组合不同的事件。

第二步（第3项）是解决控制问题的反转。为此，使用Scala.React库，他们定义了一个可以翻译它的DSL：

var state = null
observe(event1).then{
    state = new StartState()
    remove_observer(event1)
    observe(event2).then {
        state = new AccumulateState(old_state+new_data)
    }
    observe(event3).then {
        do_something()
        state = null
        remove_observer(event2)
        remove_observer(event3)
    }
}

成：

once {
   state = new StartState(when(event1))
   until(event3) {
      state = new AccumulateState(when(event2))
   }
   do_something()
}

库透明地定义了等待预期事件但不会停止程序执行的函数。在上面的代码中，方法“once”和“when”和“until”负责等待事件并在预期时继续执行代码。您还可以看到，在第二个片段中，您不需要关联/删除观察者。

然后第三步（第4项）创建一个信号。信号是一个时变值，您可以使用它来定义如何评估此时信号的值（“现在”方法）并通过返回与之关联的事件来观察信号变化（“更改”方法）信号。（作为旁注，scala中的trait与java中的接口相同，但增加了在trait本身中实现一些所需行为的可能性。）

然后第四步（第5项）将Signal和Event集成到Scala.Reactor中。它使信号和事件特征扩展了Reactive特性，并解释了（在scala中）如何定义将事件和信号转换为数据流隐式的方法（用户定义的隐式转换是我尝试过的方法）找到其他语言，但它似乎只是一个scala功能。）

然后定义组合器（对任何数据流进行操作的统一方法）并解释在执行此操作时发现的问题。

然后，项目6继续解释它是如何在scala中实现的。

第7项列出了其他语言/图书馆（包括Java）的相关作品

“弃用Observer模式” - 其他语言的代码示例？

2 个答案: