处理JavaFX中的派生属性

Question

I'm playing with JavaFX right now and I'm following a tutorial to learn this sector of Java. I have a question about properties though:

How to properly deal with derived property in JavaFX?

Let me clarify with an example. Suppose you have a model with a simple property:

public class User {

    private final StringProperty name;
    private final ObjectProperty<LocalDate> birthday;
}

(I ignored the constructor and the property getters: suppose they are there) and suppose you have a view with a TableView with 2 columns listing users where:

• in the first column there is the name of the user;
• in the second column there is the age of the user;

Something like this (also displaying some paint skills!):

Now, the age is of course a derived property of the birthday field and it can be easily implemented via the method:

public int getAge() {
    return Period.between(this.getBirthday().get(), LocalDate.now()).getYears();
}

However the table view won't accept an integer, but only an observable integer. I want the table to change automatically if someone changes the birthday of a user.

I could create a SimpleIntegerProperty inside the setCellValueFactory but I don't think that could be a solution. I could also create a IntegerProperty inside User class called age but it doesn't sound right to me because the age is a derived property from birthday.

So that arise my question: how to deal with derived property in JavaFX?

PS: I looked at this SO answer but, probably for my inexpertise in this field, I couldn't find it satisfactory.

Thanks for any kind reply.

Answer 1

You can do it with the mentioned setCellValueFactory and SimpleIntegerProperty :

TableColumn<User, Integer> ageCol = new TableColumn<User, Integer>("Age");

ageCol.setCellValueFactory(param -> {
    SimpleIntegerProperty prop = new SimpleIntegerProperty(param.getValue().getAge());
    prop.bind(Bindings.createIntegerBinding(() -> {
        return param.getValue().getAge();
    }, param.getValue().birthday));
    return prop.asObject();
});

However, when you create the binding you use the following dependency param.getValue().birthday which is the mark that you know the inner calculation of the getAge() method (okay, for this case it's quite obvious that the calculation is based on the birthday, but there are some cases where it is not).

Therefore I would choose the second option that you mentioned to encapsulate the calculation to the place where it belongs: an additional (readonly) property in the User class, where the age is bound to the birthday.

public static class User {

    private final StringProperty name;
    private final ObjectProperty<LocalDate> birthday;

    private final ReadOnlyIntegerWrapper age;

    public StringProperty nameProperty() { return name; }
    public ObjectProperty<LocalDate> birthdayProperty() { return birthday; }
    public ReadOnlyIntegerProperty ageProperty() { return age.getReadOnlyProperty(); }

    private User(String name, LocalDate bDay) {
        this.name = new SimpleStringProperty(name);
        birthday = new SimpleObjectProperty<LocalDate>(bDay);
        this.age = new ReadOnlyIntegerWrapper();
        age.bind(Bindings.createIntegerBinding(() -> Period.between(this.getBirthday(), LocalDate.now()).getYears(), birthday));
    }

    public String getName() { return name.get(); }
    public LocalDate getBirthday() { return birthday.get(); }
    public int getAge() { return ageProperty().get(); }
}

and then to use it:

TableColumn<User, Integer> ageCol = new TableColumn<User, Integer>("Age");
ageCol.setCellValueFactory(new PropertyValueFactory<User, Integer>("age"));

The example uses the ReadOnlyIntegerWrapper (from the answer you have linked) and exposes the inner property age via a ReadOnlyIntegerProperty :

public ReadOnlyIntegerProperty ageProperty() { return age.getReadOnlyProperty(); }

Update: The same User class using lazy-initialization on the age property.

public static class User {

    private final StringProperty name;
    private final ObjectProperty<LocalDate> birthday;

    private ReadOnlyIntegerWrapper age = null;

    public StringProperty nameProperty() { return name; }
    public ObjectProperty<LocalDate> birthdayProperty() { return birthday; }

    public ReadOnlyIntegerProperty ageProperty() {
        if (age == null) {
            age = new ReadOnlyIntegerWrapper();
            age.bind(Bindings.createIntegerBinding(() -> calculateAge(), birthday));
        }

        return age.getReadOnlyProperty();
    }

    private User(String name, LocalDate bDay) {
        this.name = new SimpleStringProperty(name);
        birthday = new SimpleObjectProperty<LocalDate>(bDay);
    }

    public String getName() { return name.get(); }

    public LocalDate getBirthday() {return birthday.get(); }

    public int getAge() {
        return (age != null) ? age.get() : calculateAge();
    }

    private final int calculateAge() {
        return Period.between(this.getBirthday(), LocalDate.now()).getYears();
    }
}

Answer 2

You could expose a DoubleBinding instead of a property for the age. A DoubleBinding is an implementation of ObservableValue<Number> (so it can be returned by the callback in a cellValueFactory ), but unlike a DoubleProperty or ReadOnlyDoubleProperty it doesn't store its value internally:

public class User {

    private final ObjectProperty<LocalDate> birthday ;

    public ObjectProperty<LocalDate> birthdayProperty() {
        return birthday ;
    }

    public final LocalDate getBirthday() {
        return birthdayProperty().get();
    }

    public final void setBirthday(LocalDate birthday) {
        birthdayProperty().set(birthday);
    }

    private final DoubleBinding age = Bindings.createDoubleBinding(
        () -> Period.between(this.getBirthday(), LocalDate.now()).getYears(),
        birthday);

    public DoubleBinding age() {
        return age ;
    }
}

You can then do things like

TableColumn<User, Number> ageColumn = new TableColumn<>(age);
ageColumn.setCellValueFactory(cellData -> cellData.getValue().age());

Note this example isn't really ideal, because age can change value without birthday changing value (due to the irrepressible nature of the advance of time...). So to make this really accurate you might want to create an ObjectProperty<LocalDate> today somewhere, which updated on a daily basis. Then make your age binding update when it changed too

private final DoubleBinding age = Bindings.createDoubleBinding(
    () -> Period.between(this.getBirthday(), LocalDate.now()).getYears(),
    birthday, today);

Though the original version is likely to be sufficient for most realistic use cases.