JavaFX JavaFX mit Hibernate

[halfmoon]

Hallo Leute,

ich habe ein Projekt wo ich für GUI Javafx einsetze und für die Datenbank nutze ich Hibernate mit einer JavaDB dahinter.

Nun komme ich an dem Punkt wo ich die Daten aus der DB ins Model hole und Listen in Form von Arrylisten rausziehe. Das klappt soweit alles ganz gut.
Jetzt möchte ich natürlich ObservableList für JavaFX verwenden...und hier komme ich an mein Problem:

@Entity
public class Project implements Serializable{
    @Id
    @GeneratedValue ( strategy = GenerationType.AUTO)
    private long projectId;
    @Column
    private String name;
    @Column
    private String discription;
    @Column
    @Convert(converter = ColorConverter.class)
    private Color color;
    @OneToMany(fetch = FetchType.EAGER)
    private List<ProjectTask> listTask;

    public Project() {
        listTask = new ArrayList<>();
        color = Color.WHITE;
    }
....  
}

@Entity
public class ProjectTask implements Serializable{
    @Id
    @GeneratedValue
    private long taskId;
    @Column
    private String name;
    @Column
    private String discription;
    @OneToMany (fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    private List<ProjectTime> timeList;
...

public class ProjectController {
    private static ProjectController controller;
    private ObservableList<Project> listProject;
    private ProjectDAOImpl projectDAO;
    private ProjectTaskDAOImpl taskDAO;

    public ProjectController() {
        projectDAO = new ProjectDAOImpl();
        taskDAO = new ProjectTaskDAOImpl();
        listProject = FXCollections.observableArrayList(projectDAO.listProject());
    }
   
   
    public static ProjectController getInstance() {
        if(controller == null) {
            controller = new ProjectController();
        }
        return controller;
    }
   
    public ObservableList<Project> getListProject() {
        return listProject;
    }
   
    public void addProject(String name, String discription, Color color) {
        Project project = new Project(name, discription, color);
        projectDAO.create(project);
        listProject.add(project);
    }

    public ObservableList<ProjectTask> getTaskListByProject(Project project) {
      //  return FXCollections.synchronizedObservableList((ObservableList<ProjectTask>) project.getListTask());
        return FXCollections.observableArrayList(project.getListTask());
    }

    public void addTaskByProject(String name, String discription, Project project) {
        ProjectTask task = new ProjectTask(name, discription);
        project.getListTask().add(task);
        taskDAO.create(task);
        projectDAO.update(project);
    }

Wie kriege ich die Schnittstelle hin zwischen OberservableList für die GUI und normale List im Model?
Vielleicht kann mir da einer mal einen Gedankenanstoß geben.

Danke

 

[halfmoon]

Oder besser gesagt, wie binde ich die JavaFX GUI ordentlich mit dem Model, wo ich keine Propertys nutze.

 

[dzim]

Kannst du mir kurz erläutern, woran es genau klemmt?
Du hast ja in der untersten Klasse deine ObservableList - die könntest du ja nun immerhin schon in einer Liste verwenden.

Ich nehme an, dein Problem ist das Binden auf die Properties einer einzelnen Model-Instanz (z.B. Project)
Ich denke, du könntest es wie folgt lösen: Du benötigst JavaFX Properties.
Zu jedem Datenfeld fügst du eine Property hinzu:

    private String name;
    @JsonIgnore private StringProperty nameProperty;

Damit du sie wie reguläre JavaFX-Properties verwenden kannst, benötigst du die drei entsprechenden Methoden (Getter und Setter sind klar, plus #nameProperty):

    public String getName() {
        return nameProperty == null ? name : nameProperty.get();
    }
  
    public void setName(String name) {
        this.name = name;
        if (this.nameProperty != null) {
            this.nameProperty.set(name);
        }
    }
  
    @JsonIgnore
    public final StringProperty nameProperty() {
        if (this.nameProperty == null) {
            this.nameProperty = new SimpleStringProperty(this, "name", this.name);
            this.nameProperty.addListener((ChangeListener<String>) (observable, oldValue, newValue) -> Calculation.this.name = newValue);
        }
        return this.nameProperty;
    }

Wir brauchten das auch in einem Legacy-Model (wie man sieht) und haben für Jackson alles, was er ignorieren soll, mit @JsonIgnore explizit als zu Ignorieren markiert.

Du könntest das vermutlich mit @Transient erreichen:
http://stackoverflow.com/questions/4662582/make-hibernate-ignore-class-variables-that-are-not-mapped

#edit: Man könnte das noch etwas optimieren, aber egal...

 

[halfmoon]

Danke für die Antwort...das mit dem Properties im Model verstehe ich und hatte ich in einem anderen Projekt auch schon. Damit kommt Hibernate auch noch klar und ich könnte das ganze Model so aufbauen....wollte ich aber explizit nicht.

Jetzt zu der Sache mit der Liste....in der View habe ich die ObservableList, welche aus der List vom Model erzeugt wird. So...wenn ich nun Elemente der ObservableList hinzufüge, bleibt die View aktuell aber die List im Model weiß davon nichts...doof

Wenn ich Elemente in der Liste des Models adde weiß die View nichts davon...wie schlage ich hier die Brücke? Im Model noch zusätzlich die ObservableList hinzufügen?

 

[dzim]

Du musst doch eigentlich nur die Liste (listProject) deinem View (ListView, TableView, ...) übergeben. Ich verstehe da das Problem nicht.

 

[halfmoon]

Du musst doch eigentlich nur die Liste (listProject) deinem View (ListView, TableView, ...) übergeben. Ich verstehe da das Problem nicht.

Die Table nutzt ObservableList

listProject = FXCollections.observableArrayList(projectDAO.listProject());

Dadurch wird aber eine neue Liste erzeugt und wenn ich was im DAO adde...kriegt listProject davon nichts mit.

 

[dzim]

Du hast doch aber deinen ProjectController - der beim Add/Remove die Liste up-to-date hält. Ich verstehe dein Problem im Moment wirklich nicht. Sorry...
Denn ansonsten wäre es ja nur so etwas wie
myTable.setItems(projectControllerInstance.getListProject());
Oder was sehe ich hier nicht?

 

[halfmoon]

Du hast doch aber deinen ProjectController - der beim Add/Remove die Liste up-to-date hält. Ich verstehe dein Problem im Moment wirklich nicht. Sorry...
Denn ansonsten wäre es ja nur so etwas wie
myTable.setItems(projectControllerInstance.getListProject());
Oder was sehe ich hier nicht?

Du siehst alles richtig...Mit der listProject klappt das auch alles so...
Aber an einem Project hängt wieder eine Liste:

public class Project implements Serializable{
    @Id
    @GeneratedValue ( strategy = GenerationType.AUTO)
    private long projectId;
    @Column
    private String name;
    @Transient
    private StringProperty nameProperty;
    @Column
    private String discription;
    @Transient
    private StringProperty discriptionProperty;
    @Column
    @Convert(converter = ColorConverter.class)
    private Color color;
    @OneToMany(fetch = FetchType.LAZY)
    private List<ProjectTask> listTask;
....

Die listTask welche auch wieder an eine zweite Tabelle gebunden wird. Hier stoße ich dann an das Problem.

 

[looparda]

Ich stehe gerade an einem ähnlichen Punkt.
Ich habe kleinere Projekte erstellt in denen ich auf die "Optimale" Lösung von Hibernate mit JavaFX hinarbeite um sie in meinem eigentlichen/größeren Projekt zu benutzen.
https://github.com/No3x/javafx-boilerplate-hibernate
https://github.com/No3x/javafx-boilerplate-hibernate-lifecycles
Moment arbeite ich an einem weiteren kleinen Projekt um explorativ zu entwickeln, wie ich mit n:m Beziehungen umgehe, die eine Auflösungs-Entity benötigen. In meinem Fall PersonTeam mit einem Attribut, das somit die einfache Verwendung von @ManyToMany verhindert und mit 1:n<->n:1 Beziehung aufgelöst werden muss. Das aktuellste Projekt, das ich gerade beschrieben habe ist noch nicht auf GitHub.

Vielleicht können wir Kontakt aufnehmen und gemeinsam an einem minimalen Demo-Projekt arbeiten.
Nun zu deiner Frage:
Leider kann ich sie dir nicht beantworten oder aus Erfahrung sprechen. Aber ich wollte folgenses Probieren:
Mit Benutzung von einer ListProperty sollten sich diese Abhängigkeiten über mehrere Entities und Collections lösen lassen. Ich bin mir nicht sicher ob es sich mit Hibernate vereinabren lässt, da die Collection-Implementierung von Hibernate ausgetauscht wird (meine ich mal gelesen zu haben und möchte ich verifizieren).