Java &引用；弃用观察者模式"；——用其他语言编写示例代码？

我试图理解这篇论文，它似乎对“反应式”编程的发展有一定的影响

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

如果这是另一个堆栈，请告诉我。

您可能感兴趣吗？说明：

JVM的反应式扩展–一个库，用于使用Java VM的可观察序列编写异步和基于事件的程序

解释使用Java7EN8进行反应式编程（示例如图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");
            }

        }
);

Integer[]number={0,1,2,3,4,5}；
可观测的数字可观测=可观测的。从（数字）；
numberObservable.subscribe(
新行动1（）{
@凌驾
公共无效调用（整数输入编号）{
系统输出打印项次（输入编号）；
}
},
新行动1（）{
@凌驾
公共作废调用（可丢弃错误）{
System.out.println（“同步可观测误差”）；
}
},
新操作0（）{
@凌驾
公开作废通知（）{
System.out.println（“此可观察对象已完成”）；
}
}
);

您可能对什么感兴趣？说明：

JVM的反应式扩展–一个库，用于使用Java VM的可观察序列编写异步和基于事件的程序

解释使用Java7EN8进行反应式编程（示例如图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");
            }

        }
);

Integer[]number={0,1,2,3,4,5}；
可观测的数字可观测=可观测的。从（数字）；
numberObservable.subscribe(
新行动1（）{
@凌驾
公共无效调用（整数输入编号）{
系统输出打印项次（输入编号）；
}
},
新行动1（）{
@凌驾
公共作废调用（可丢弃错误）{
System.out.println（“同步可观测误差”）；
}
},
新操作0（）{
@凌驾
公开作废通知（）{
System.out.println（“此可观察对象已完成”）；
}
}
);

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

然后，它继续展示如何使用Scala.React库，从基于可观察的代码库过渡到反应的代码库

在这个答案中，我将使用“ScaleEnglish”和“JaveEnglish”来解释我理解的代码

第一步（第2项）是创建事件抽象。使用事件，您现在有了一个统一的接口，可以用来封装可观察的对象。然后继续定义“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”和“when”和“until”负责等待事件并在预期时继续执行代码。您还可以看到，在第二个代码段中，您不需要关联/删除观察者

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

第四步（项目5）是将信号和事件集成到Scala.Reactor中。它使信号和事件特性扩展了反应特性，并解释了（在scala中）如何定义将事件和信号隐式转换为数据流的方法（用户定义的隐式转换是我试图在其他语言上找到的，但它似乎是scala唯一的特性）

然后定义组合器（在任何数据流上操作的统一方法），并解释在这样做时发现的问题

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

---

第7项列出了其他语言/库（包括Java）的相关工作。

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

然后，它继续展示如何使用Scala.React库，从基于可观察的代码库过渡到反应的代码库

在这个答案中，我将使用“ScaleEnglish”和“JaveEnglish”来解释我理解的代码

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

第二步（第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)
    }
}

进入：

<