À l'aide de javafx.haricots propriétés dans les classes du modèle

Je vais vous offrir quelque chose d'une opinion dissidente ici.

JavaFX Propriétés et JPA

Comme je l'ai commenté sur jewelsea réponse, à l'aide d'un JavaFX propriété à base de haricot avec JPA est possible aussi longtemps que vous utilisez "l'accès à la propriété", plutôt que "sur le terrain". Le post de blog j'ai fait un lien il n'y va plus dans le détail sur ce point, mais l'idée de base est que toutes les annotations doivent être sur le get...() méthodes et non pas sur les champs. Aussi loin que je peux voir, ceci n'empêche l'utilisation de tout la lecture seule JavaFX propriété des modèles en collaboration avec JPA, mais je n'ai jamais vraiment senti JPA bien joué avec des propriétés en lecture seulement (c'est à dire des méthodes get et pas de la méthode de jeu) de toute façon.

Sérialisation

Contrairement à mon commentaire sur jewelsea réponse, et avec le bénéfice de quelques semaines pour travailler avec cela (et d'avoir été placé dans une position où j'étais face à la réplication de plusieurs classes d'entité sur un JavaFX côté client à l'aide de JavaFX propriétés), je pense que le manque de sérialisation de JavaFX propriétés peuvent être contournées. L'observation essentielle est que vous avez vraiment besoin de sérialiser le enveloppés de l'état de la propriété (et non, par exemple, tous les auditeurs). Vous pouvez le faire par la mise en œuvre de java.io.Externalizable. Externalizable est une sous-interface de Serializable qui vous oblige à remplir le readExternal(...) et writeExternal(...) méthodes. Ces méthodes peuvent être mises en œuvre à l'externalisation de l'état enveloppé par la propriété, plutôt que le bien lui-même. Cela signifie que si votre entité est sérialisé et puis désérialisé, vous allez vous retrouver avec une nouvelle propriété de l'instance, et les auditeurs ne seront pas conservées (c'est à dire les auditeurs de devenir effectivement transient), mais aussi loin que je peux voir, ce serait ce qu'on voulait dans la mesure du raisonnable cas d'utilisation.

J'ai expérimenté avec des haricots défini de cette façon et tout semble fonctionner à merveille. En outre, j'ai couru une petite expérience dans le transfert entre le client et un service web restful, à l'aide de l'Jackson mappeur pour convertir une représentation JSON. Depuis le mappeur juste s'appuie sur l'utilisation des méthodes get et set, cela fonctionne bien.

Quelques mises en garde

Un couple de points doivent être observés. Comme avec toute la Sérialisation, il est important d'avoir un constructeur sans argument. Et bien sûr, toutes les valeurs enveloppé par le JavaFX propriétés doivent eux-mêmes être sérialisable - encore une fois c'est la même règle que pour tout serializable bean.

Le point sur JavaFX propriétés de travail via des effets secondaires est bien pris, et de soins doit être exercée lors du déplacement de ces propriétés (qui sont, dans une certaine mesure, conçu avec un seul modèle de thread dans l'esprit) à une potentiellement multi-thread serveur. Une bonne règle de base est que si vous utilisez cette stratégie, les auditeurs devraient être inscrits sur le côté client (et rappelez-vous, ces auditeurs sont transitoires concernant le transfert vers le serveur, que ce soit par la sérialisation ou par représentation JSON). Bien sûr, cela suggère que l'utilisation de ces sur le côté serveur peut être une mauvaise conception; il devient un compromis entre le confort d'avoir une entité unique qui est "tout à tous" (propriétés observables pour l'JavaFX client, serializable de persistance et/ou d'accès à distance, et avec la persistance des mappages de JPA) par rapport exposant les fonctionnalités (par exemple, l'observabilité) où il pourrait ne pas être totalement approprié (sur le serveur).

Enfin, si vous ne l'utilisez les annotations JPA, ceux-ci ont d'exécution de rétention qui implique (je pense) que votre JavaFX client aura besoin de l'un javax.la persistance de la spécification dans le classpath).

Voici un exemple d'un tel "homme pour toutes les saisons" entité:

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.time.MonthDay;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
/**
* Entity implementation class for Entity: Person
*
*/
@Entity
public class Person implements Externalizable {
private static final long serialVersionUID = 1L;
public Person() {
}
public Person(String name, MonthDay birthday) {
setName(name);
setBirthday(birthday);
}
private final IntegerProperty id = new SimpleIntegerProperty(this, "id");
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
public int getId() {
return id.get();
}
public void setId(int id) {
this.id.set(id);
}
public IntegerProperty idProperty() {
return id ;
}
private final StringProperty name = new SimpleStringProperty(this, "name");
//redundant, but here to indicate that annotations must be on the property accessors:
@Column(name="name")
public final String getName() {
return name.get();
}
public final void setName(String name) {
this.name.set(name);
}
public StringProperty nameProperty() {
return name ;
}
private final ObjectProperty<MonthDay> birthday = new SimpleObjectProperty<>();
public final MonthDay getBirthday() {
return birthday.get();
}
public final void setBirthday(MonthDay birthday) {
this.birthday.set(birthday);
}
public ObjectProperty<MonthDay> birthdayProperty() {
return birthday ;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeInt(getId());
out.writeObject(getName());
out.writeObject(getBirthday());
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
setId(in.readInt());
setName((String) in.readObject());
setBirthday((MonthDay) in.readObject());
}
}

pour la persistance jpa collections il suffit d'utiliser cette signature pour méthode de lecture..

@OneToMany
List<Person> getAll()
{
return observableList;
}