Binding 如何处理相关的数据绑定？

我经常发现自己遇到这样的问题：一个控件的两个（相关）值被更新，这两个值都会触发一个代价高昂的操作，或者控件可能会暂时处于不一致的状态

例如，考虑一个数据绑定，其中两个值（x，y）彼此相减，并且最终结果被用作其他属性z（

）的除数。 z/（x-y）

如果x和y绑定到某个外部值，则一次更新一个会导致意外的零除错误，具体取决于首先更新的属性以及另一个属性的旧值。更新属性z的代码只监听x和y中的更改——它无法预先知道另一个属性的另一个更新即将到来

现在这个问题很容易避免，但是还有其他类似的情况，比如设置宽度和高度。。。我是立即调整窗口大小还是等待其他更改？我是立即为指定的宽度和高度分配内存，还是等待？如果宽度和高度分别为100万和100万，然后更新为100万和1，那么暂时我的宽度和高度为100万x 100万

这可能是一个相当普遍的问题，尽管对我来说，它特别适用于JavaFX绑定。我感兴趣的是如何处理这些情况，而不会出现未定义的行为，或者在另一个绑定发生变化时需要重新执行昂贵的操作

---

到目前为止，我为避免这些情况所做的工作是在设置新值之前首先清除已知值的绑定，但这对更新绑定的代码来说是一个负担，它实际上不应该知道这些情况。

这些情况表明，数据绑定不能在任何地方都使用。它是基于事件的，因此您最终会遇到事件驱动架构的所有问题，包括竞争条件等

所以我要说：不要在副作用不可预测和致命的情况下使用它。例如，在您的情况下，坚持使用一个基本方法，该方法根据彼此和旧值设置两个属性，您可以在安全时间调用这些属性，甚至可以定期调用，甚至可以通过脏值检查来调用。如果可以同时执行这两个操作，则计算量很小，因此不应成为问题

---

数据绑定很好，但并非适用于所有情况。它不是一种宗教（仍然是一种伟大的工具）。不要过度使用它：简单而不是聪明应该适用于这里，不要攻击它，它很快就会变得不可调试。

我现在才学习JavaFX，所以对这个答案持保留态度。。。欢迎任何更正。我对此很感兴趣，所以做了一些研究

无效侦听器 这个问题的答案部分是正确的。您可以详细阅读文档，但本质是

ChangeLister

会立即传播更改，而

invalizationlistener

会注意到某个值无效，但会将计算推迟到需要时。基于“z/（x-y）”计算的两种情况示例：

首先，琐碎的事情：

import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.binding.DoubleBinding;
import javafx.beans.binding.NumberBinding;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableNumberValue;
import javafx.beans.value.ObservableValue;

public class LazyExample
{
    public static void main(String[] args) {
        changeListenerCase();
        System.out.println("\n=====================================\n");
        invalidationListenerCase();
    }
    ...
}

这两种情况（更改和无效侦听器）将设置3个变量，

x

，

y

，

z

，计算表达式

z/（x-y）

，以及相应的侦听器。然后他们调用

operate（）

方法来更改值。将记录所有步骤：

    public static void changeListenerCase() {
        SimpleDoubleProperty x = new SimpleDoubleProperty(1);
        SimpleDoubleProperty y = new SimpleDoubleProperty(2);
        SimpleDoubleProperty z = new SimpleDoubleProperty(3);

        NumberBinding nb = makeComputed(x,y,z);

        nb.addListener(new ChangeListener<Number>() {
            @Override public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
                System.out.println("ChangeListener: " + oldValue + " -> " + newValue);
            }
        });

        // prints 3 times, each after modification
        manipulate(x,y,z);

        System.out.println("The result after changes with a change listener is: " + nb.doubleValue());
    }

    public static void invalidationListenerCase() {
        SimpleDoubleProperty x = new SimpleDoubleProperty(1);
        SimpleDoubleProperty y = new SimpleDoubleProperty(2);
        SimpleDoubleProperty z = new SimpleDoubleProperty(3);

        NumberBinding nb = makeComputed(x,y,z);

        nb.addListener(new InvalidationListener() {
            @Override public void invalidated(Observable observable) {
                System.out.println("Invalidated");
            }
        });

        // will print only once, when the result is first invalidated
        // note that the result is NOT calculated until it is actually requested
        manipulate(x,y,z);

        System.out.println("The result after changes with an invalidation listener is: " + nb.doubleValue());
    }

此操作的输出为：

…正在计算。。。
正在更改z。。。
…计算。。。
ChangeListener:-3.0->-13.0
正在更改y。。。
…计算。。。
ChangeListener:-13.0->Infinity
正在更改x。。。
…计算。。。
ChangeListener:Infinity->13.0
使用更改侦听器进行更改后的结果是：13.0
=====================================
…计算。。。
正在更改z。。。
无效
正在更改y。。。
正在更改x。。。
…计算。。。
使用无效侦听器更改后的结果是：13.0

因此，在第一种情况下，计算数量过多，并且出现了

无穷大的情况。在第二次更改中，数据在第一次更改时被标记为无效，然后仅在需要时重新计算

脉搏
如何绑定图形属性，例如某物的宽度和高度（如您的示例所示）？JavaFX的基础设施似乎不会立即对图形属性进行更改，而是根据一个名为。脉冲是异步调度的，执行时将根据节点属性的当前状态更新UI。动画中的每一帧和UI属性的每一次更改都将安排运行一个脉冲

我不知道在您的示例中会发生什么情况，初始宽度=1px，高度=106px，代码设置宽度=106px（在一步中，调度脉冲），然后高度=1px（第二步）。如果第一步没有被处理，第二步是否会发出另一个脉冲？从JavaFX的角度来看，合理的做法是管道只处理1个脉冲事件，但我需要一些参考。但是，即使处理了两个事件，第一个事件也应处理整个状态更改（宽度和高度），以便在一个可视步骤中发生更改

开发人员必须考虑到我相信的体系结构。假设有一个单独的任务（伪代码）：

我猜如果第一个脉冲事件有机会运行，那么用户将看到宽度的变化-暂停-高度的变化。最好将其编写为（同样，始终在后台任务中）（伪代码）：

更新（来自john16384的评论）：据报道，直接听脉搏是不可能的。但是，可以扩展
javafx.scene.Parent
的某些方法，这些方法每脉冲运行一次，并实现相同的效果。因此，如果不需要对子目录树进行更改，您可以扩展
layoutChildren（）
，也可以扩展
computePrefHeight（双倍宽度）    private static NumberBinding makeComputed(final ObservableNumberValue x, final ObservableNumberValue y, final ObservableNumberValue z) {
        return new DoubleBinding() {
            {
                bind(x,y,z);
            }
            @Override protected double computeValue() {
                System.out.println("...CALCULATING...");
                return z.doubleValue() / (x.doubleValue()-y.doubleValue());
            }
        };
    }

    private static void manipulate(SimpleDoubleProperty x, SimpleDoubleProperty y, SimpleDoubleProperty z) {
        System.out.println("Changing z...");
        z.set(13);
        System.out.println("Changing y...");
        y.set(1);
        System.out.println("Changing x...");
        x.set(2);
    }

width = lengthyComputation();
Platform.runLater(node.setWidth(width));
height = anotherLengthyComputation();
Platform.runLater(node.setHeight(height));

width = lengthyComputation();
height = anotherLengthyComputation();
Platform.runLater(node.setWidth(width));
Platform.runLater(node.setHeight(height));

import javafx.application.Application;
import javafx.application.Platform;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.binding.ObjectBinding;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Dimension2D;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class ExpensiveQuickCalculationExample extends Application
{
    @Override
    public void start(final Stage primaryStage) {
        primaryStage.setTitle("Lazy Example");

        Button btn = new Button();
        btn.setText("Manipulate");
        btn.setOnAction(new EventHandler<ActionEvent>() {
            @Override public void handle(ActionEvent event) {
                //////////////////////////////////
                // DIMENSIONS MANIPULATION HERE //
                //////////////////////////////////
                primaryStage.setHeight(150);
                primaryStage.setWidth(150);
            }
        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.show();


        final ObjectBinding<Dimension2D> stageDimBinding = makeWindowDimensionsBinding(primaryStage);
        stageDimBinding.addListener(new InvalidationListener() {
            @Override public void invalidated(Observable observable) {
                System.out.println("---> Dimensions INVALIDATED");
                Platform.runLater(new Runnable() {
                    @Override public void run() {
                        expensiveQuickCalculation(stageDimBinding.get());
                    }
                });
            }
        });
    }

    private ObjectBinding<Dimension2D> makeWindowDimensionsBinding(final Stage stage) {
        return new ObjectBinding<Dimension2D>() {
            {
                bind(stage.widthProperty(), stage.heightProperty());
            }
            @Override
            protected Dimension2D computeValue() {
                System.out.println("Dimensions computed");
                return new Dimension2D(stage.widthProperty().doubleValue(), stage.heightProperty().doubleValue());
            }
        };
    }

    private void expensiveQuickCalculation(Dimension2D d) {
        System.out.println("-=< EXPENSIVE CALCULATION >=-");
    }

    public static void main(String[] args) {
        launch(args);
    }
}

import javafx.application.Application;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.binding.ObjectBinding;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.concurrent.Service;
import javafx.concurrent.Task;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Dimension2D;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class ExpensiveSlowCalculationExample extends Application
{
    private static class SlowCalculationTask extends Task<Void>
    {
        private Dimension2D dimension;

        public SlowCalculationTask(Dimension2D dimension) {
            this.dimension = dimension;
        }

        @Override
        protected Void call() throws Exception {
            expensiveSlowCalculation();
            if( !isCancelled() ) {
                /////////////////////////////////////
                //        UPDATE STATE HERE        //
                // I would use Platform.runLater() //
                /////////////////////////////////////
                System.out.println("-=< UPDATING STATE >=-");
            }
            return null;
        }

        private void expensiveSlowCalculation() {
            System.out.println("-=< EXPENSIVE SLOW CALCULATION STARTED " + dimension + ">=-");
            try {
                Thread.sleep(5000);
                System.out.println("-=< EXPENSIVE SLOW CALCULATION DONE >=-");
            }
            catch (InterruptedException e) {
                if( isCancelled() ) System.out.println("-=< EXPENSIVE SLOW CALCULATION *CANCELLED* >=-");
                else throw new RuntimeException(e);
            }
        }
    }

    private static class SlowCalculationService extends Service<Void>
    {
        private ObjectProperty<Dimension2D> dimensions = new SimpleObjectProperty<>();
        public void setDimensions(Dimension2D dimensions) { this.dimensions.set(dimensions); }

        @Override
        protected Task<Void> createTask() {
            return new SlowCalculationTask(dimensions.get());
        }
    }



    private SlowCalculationService calculationService;


    @Override
    public void start(final Stage primaryStage) {
        primaryStage.setTitle("Lazy Example");

        Button btn = new Button();
        btn.setText("Manipulate");
        btn.setOnAction(new EventHandler<ActionEvent>() {
            @Override public void handle(ActionEvent event) {
                //////////////////////////////////
                // DIMENSIONS MANIPULATION HERE //
                //////////////////////////////////
                primaryStage.setHeight(150);
                primaryStage.setWidth(150);
            }
        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.show();


        final ObjectBinding<Dimension2D> stageDimBinding = makeWindowDimensionsBinding(primaryStage);
        stageDimBinding.addListener(new InvalidationListener() {
            @Override public void invalidated(Observable observable) {
                System.out.println("---> Dimensions INVALIDATED");
                startService(stageDimBinding.get());
            }
        });
    }

    private ObjectBinding<Dimension2D> makeWindowDimensionsBinding(final Stage stage) {
        return new ObjectBinding<Dimension2D>() {
            {
                bind(stage.widthProperty(), stage.heightProperty());
            }
            @Override
            protected Dimension2D computeValue() {
                System.out.println("Dimensions computed");
                return new Dimension2D(stage.widthProperty().doubleValue(), stage.heightProperty().doubleValue());
            }
        };
    }

    private void startService(Dimension2D d) {
        if( calculationService == null ) calculationService = new SlowCalculationService();
        calculationService.setDimensions(d);
        calculationService.restart();
    }

    public static void main(String[] args) {
        launch(args);
    }
}