敲除.js 计算的可观察对象的 Java 等价物？

Question

使用knockout.js computed observables 可以定义一个依赖于其他可观察对象的 JavaScript 可观察对象，使用函数表达式，例如

var computedObservable = ko.computed(function(){ 
    return firtName() + lastName();
});

如果引用的 observable 之一（例如 firstName）发生变化，则计算出的 observable 会自动更新。 引用的 observables 由给定的函数表达式定义，并且不必明确指定。

如何在 Java 中实现类似的功能？

（嗯，有JavaFx Bindings，但它们需要显式注册引用的属性/可观察对象。）

我区分两种情况：

a) 使用 Java 分析给定的 lambda 表达式，以自动找出必须考虑哪些引用的 observable。 （引用的可观察对象可能会引用依赖链中的更多可观察对象。） 预期的示例代码：

ComputedObservable<String> computedObservable = new ComputedObservable<>(() -> {
    return firstName.get() + lastName.get();
}); 

b)我必须手动注册每个引用的 observable 才能观察它们。我想避免这种情况。换句话说，我不想拥有类似

的代码

ComputedObservable<String> computedObservable = new CoputedObservable<>();
computedObservable.registerReference(firstName);
computedObservable.registerReference(lastName);
computedObservable.setExpresion(() -> {
        return firstName.get() + lastName.get();
});

或（使用JavaFx Bindings）

 DoubleBinding db = new DoubleBinding() { 
        {
            super.bind(a, b, c, d);
        }

        @Override
        protected double computeValue() {
            return (a.get() * b.get()) + (c.get() * d.get());
        }
 };

情况 a) 是否可能，如果是，是否有现有的 Java 实现/库可以这样做？

编辑： 还有一种策略：

c) 使用专用运算符 来定义函数表达式。这些运算符隐式地注册了引用的 observables。因此无需额外的手动注册步骤。 （函数表达式将仅限于可用的运算符，并且可能需要高级功能来实现新的帮助运算符。）

StringBinding fullName = firstName.concat(secondName);
DoubleBinding result = a.multiply(b).add(c.multiply(d)); 

相关问题：

• How to get Method Parameter names in Java 8 using reflection?
• Java 8: convert lambda to a Method instance with clousure included
• Reflection type inference on Java 8 Lambdas
• Swing data binding frameworks

Answer 1

即使您明确排除了 JavaFX 绑定，我认为它们是最接近的，无需复杂的反射（甚至字节码）黑客攻击。

您的 sn-p 是 Bindings::concat 的模型用例：

ObservableValue<String> firstName = ...;
ObservableValue<String> lastName = ...;
StringExpression name = Bindings.concat(firstName, " ", lastName);

Bindings 定义了大量有用的原子，但可以想象您有更高级的需求，例如a*b + c*d。救援的实用方法！

NumberBinding result = MyBindings.multiplyAndAdd(a, b, c, d);

与

public NumberBinding multiplyAndAdd(
        ObservableNumberValue a, ObservableNumberValue b,
        ObservableNumberValue c, ObservableNumberValue d) {
    return Bindings.add(Bindings.multiply(a, b), Bindings.multiply(c, d));
}

这不应该满足您的要求吗？

PS：您的 JavaFX 绑定链接指向版本 2 的文档。在研究 JavaFX 时，您应该确保搜索“JavaFX 8”。

Answer 2

也许以下策略也可以，对所有可观察对象使用静态注册表：

• 对给定的 lambda 进行第一次评估。在执行 lambda 表达式时，被引用的 observable 的 get 方法 有一个side effekt：它们告诉注册表它们已被调用。
• 从注册表中检索引用的 observable 列表。
• 重置注册表。
• 将侦听器附加到引用的可观察对象以定义当前更新周期。
• 重新评估表达式时，还重新创建更新周期。

此处更详细地解释了用于淘汰计算 observables 的类似工作流程：

http://knockoutjs.com/documentation/computed-dependency-tracking.html

此策略的

缺点可能是（还有其他缺点吗？）：

• 由于注册开销和更新周期刷新导致性能损失。
• 可能不适用于多线程（JavaScript 通常在单线程中运行）
• 单个注册表必须可用于（已知）所有可观察对象。 （在 JavaScript 中，我曾经遇到过一个问题，即对于测试框架，使用了第二个敲除实例。在我注入对测试代码的敲除实例的引用之前，测试代码的 observable 不会与测试代码中的 observable 一起播放.)

优点：

• 计算的 observables 的定义将更直观、更轻便：无需使用/学习专门的运算符，因为所需的所有信息已包含在函数表达式中强>。

Answer 3

我问自己同样的问题，然后我想，为什么不直接实施它。 这是一个非常初稿（还不是线程安全的），这证明它并不难。 我只是在一个小时内把它写下来，但如果我有时间我会改进它。

https://github.com/t-oster/knockout4j