Usando javafx.propiedades de los frijoles en las clases modelo

Voy a ofrecer algo de una opinión disidente aquí.

Propiedades JavaFX y JPA

Como comenté en la respuesta de jewelsea, usar un bean basado en propiedades JavaFX con JPA es posible siempre y cuando uses "acceso a propiedades" en lugar de "acceso a campos". La entrada del blog que enlacé allí entra en más detalles sobre esto, pero la idea básica es que cualquier anotación debe estar en los métodos get...() y no en los campos. Por lo que puedo ver, esto evita el uso de cualquiera de los patrones de propiedad JavaFX de solo lectura en conjunto con JPA, pero nunca me he sentido realmente JPA jugó bien con propiedades de solo lectura (es decir, métodos get y ningún método set) de todos modos.

Serialización

Contrariamente a mi comentario sobre la respuesta de jewelsea, y con el beneficio de unas pocas semanas para trabajar con esto (y habiendo sido colocado en una posición donde me enfrentaba a replicar varias clases de entidades en un lado del cliente JavaFX usando propiedades JavaFX), creo que la falta de la serialización de las propiedades de JavaFX se puede solucionar. La observación clave es que realmente solo necesita serializar el estado envuelto de la propiedad (no, por ejemplo, ningún oyente). Puede hacer esto implementando java.io.Externalizable. Externalizable es una sub-interfaz de Serializable que requiere que rellenes los métodos readExternal(...) y writeExternal(...). Estos métodos se pueden implementar para externalizar solo el estado envuelto por la propiedad, en lugar de la propiedad en sí. Esto significa que si su entidad está serializada y luego deserializado, terminará con una nueva instancia de propiedad, y cualquier oyente no se conservará (es decir, los oyentes efectivamente se convierten en transient), pero por lo que puedo ver esto sería lo que se quería en cualquier caso de uso razonable.

Experimenté con frijoles definidos de esta manera y todo parece funcionar bien. Además, ejecuté un pequeño experimento para transferirlos entre el cliente y un servicio web restful, utilizando el Jackson mapper para convertir hacia y desde una representación JSON. Ya el mapeador solo se basa en el uso de los métodos get y set, esto funciona bien.

Algunas advertencias

Es necesario observar un par de puntos. Como con cualquier serialización, es importante tener un constructor sin argumento. Y, por supuesto, todos los valores envueltos por las propiedades JavaFX deben ser serializables, de nuevo esta es la misma regla que para cualquier bean serializable.

El punto sobre las propiedades de JavaFX que funcionan a través de los efectos secundarios está bien tomado, y hay que tener cuidado para se ejercerá al mover estas propiedades (que, en cierta medida, están diseñadas con un modelo de subproceso único en mente) a un servidor potencialmente multiproceso. Una buena regla general es probablemente que si utiliza esta estrategia, los oyentes solo deben registrarse en el lado del cliente (y recuerde, esos oyentes son transitorios con respecto a la transferencia de nuevo al servidor, ya sea por serialización o por representación JSON). Por supuesto, que sugiere que el uso de estos en el lado del servidor entonces podría ser un mal diseño; se convierte en una compensación entre la conveniencia de tener una sola entidad que es "todas las cosas para todas las personas" (propiedades observables para el cliente JavaFX, serializable para persistencia y/o acceso remoto, y con asignaciones persistentes para JPA) versus exponer la funcionalidad (por ejemplo, observabilidad) donde podría no ser completamente apropiada (en el servidor).

Finalmente, si usa las anotaciones de JPA, tienen retención de tiempo de ejecución, lo que implica (creo) que su cliente JavaFX necesitará el javax.especificación de persistencia en el classpath).

Aquí hay un ejemplo de tal entidad" hombre para todas las estaciones":

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());
    }

}