Est-il possible de faire une propriété qui écoute les changements d'objets personnalisés dans javafx?

Question

Supposons que j'ai une classe d'entité Foo qui contient des champs, des getters, des setters et des constructeurs. Par exemple:

public class Foo { 
private Integer a = 0; 
private Integer b = 0; 

public Foo() { 
} 

public Integer getA() { 
    return a; 
} 

public void setA(Integer a) { 
    this.a = a; 
} 

public Integer getB() { 
    return b; 
} 

public void setB(Integer b) { 
    this.b = b; 
} 
} 

Ensuite, je veux savoir quand a ou b change. Je sais qu'il existe une ObjectProperty dans javaFX. Je suis donc la création d'objets de la propriété:

ObjectProperty<Foo> fooProperty = new SimpleObjectProperty<>(new Foo()); 

Ensuite, afin de connaître les changements de champs a et b, ajouter ChangeListener:

fooProperty.addListener((observable, oldValue, newValue) -> { 
    System.out.println("Property changed!"); 
}); 

Puis expériences:

fooProperty.set(new Foo()); 

travail bien, mais la ligne suivante:

fooProperty.get().setA(10) 

n'invoque pas l'écouteur. La raison en est claire. La dernière ligne ne change pas réellement l'objet Foo (la référence reste la même).

J'ai quelques solutions possibles. Mais tous ne sont pas assez élégants. Par exemple, changer chaque champ en tant que propriété et ajouter le même écouteur pour chaque variable.

Donc, la question est. Quel est le moyen d'ajouter un écouteur pour les changements de champs de l'objet personnalisé?

Answer 1

Je ne sais pas si ce que vous voulez ou non, vous pouvez le prendre pour référence.

D'abord, je crée une classe, sa fonction est de transporter des informations. Ensuite, créez la classe Foo, elle a deux champs Objet, nous allons écouter s'ils changent.

public class Foo{ 
    private SimpleObjectProperty<Object> a; 
    private SimpleObjectProperty<Object> b; 

    private SimpleObjectProperty<EventObj> out; 


    public Foo(){ 
    a = new SimpleObjectProperty<>(); 
    b = new SimpleObjectProperty<>(); 
    out = new SimpleObjectProperty<>(); 
    initEvent(); 
    } 

    private void initEvent(){ 
    a.addListener(new ChangeListener<Object>(){ 
     @Override 
     public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue){ 
     out.set(new EventObj("a changed", newValue)); 
     } 
    }); 

    b.addListener(new ChangeListener<Object>(){ 
     @Override 
     public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue){ 
     out.set(new EventObj("b changed", newValue)); 
     } 
    }); 
    } 

    public void setA(Object a){ 
    this.a.set(a); 
    } 

    public void setB(Object b){ 
    this.b.set(b); 
    } 

    public SimpleObjectProperty<EventObj> outProperty(){ 
    return out; 
    } 
} 

dans une autre classe, en utilisant le code ci-dessous, pour écouter si a ou b dans foo a changé.

Foo foo = new Foo(); 
foo.outProperty().addListener(new ChangeListener<EventObj>(){ 
    @Override 
    public void changed(ObservableValue<? extends EventObj> observable, EventObj oldValue, EventObj newValue){ 
    System.out.println(newValue.getMessage() + ", new value is : " + newValue.getNewObj()); 
    } 
}); 

foo.setA(new Object()); 
foo.setB(new Object()); 

dans ce cas, nous utilisons simplement la classe d'objets, si vous voulez utiliser une classe personnalisée pour remplacer, ne pas oublier de passer outre ses méthodes hashCode() et equals() pour déterminer si les deux objets sont les même.