"Deprecating the Observer Pattern" -- 其他语言的代码示例？

Question

我正在尝试理解论文 Deprecating the Observer Pattern，它似乎对 "Reactive" 编程的发展有一定影响。

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

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

Answer 1

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

Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the 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

文章认为观察者模式会导致很多错误，因为它很难推理（需要使用 side-effects 来维护状态，缺乏一致性，控制反转，...）并且它是难以对其应用良好实践（关注点分离、封装等）。

然后继续展示如何使用 Scala.React 库从 observable-based 代码库过渡到反应式代码库。

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

第一步（项目 2）是创建事件抽象。使用 Event，您现在拥有一个可用于封装可观察对象的统一接口。然后它继续定义 "merge" 方法，然后允许组合不同的事件。

第二步（第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" 负责等待事件并在预期时继续执行代码。您还可以看到，在第二个片段中，您不需要 associate/remove 观察者。

第三步（第 4 项）是创建信号。 Signal 是一个 time-varying 值，您可以使用它来定义如何评估此时信号的值（"now" 方法）和观察信号变化（"changes" 方法）通过返回与信号关联的事件。（作为旁注，scala 中的特征与 java 中的接口相同，但增加了在特征本身中实现一些所需行为的可能性。）

第四步（第 5 项）是将 Signal 和 Event 集成到 Scala.Reactor 中。它使 Signal 和 Event 特征扩展了 Reactive 特征，并解释了（在 Scala 中）如何定义将事件和信号转换为数据流的方法 implicitly(user-defined 隐式转换是我试图在其他语言上找到的东西，但它似乎是一个 scala-only 功能）。

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

第 6 项接着解释了它是如何在 scala 中实现的。

第7项列出了其他languages/libraries（包括Java）

的相关作品

"Deprecating the Observer Pattern" -- 其他语言的代码示例？

"Deprecating the Observer Pattern" -- code examples in some other language?

java

scala

design-patterns

reactive-programming

observer-pattern