Jpa mehrere @ManyToOne mit Cascade

Question

Ich habe drei Einheiten, Session, Order und User (Teil meiner Online-Kinokarten Projekt). In meinem Domänenmodell speichert Order sowohl Benutzer als auch Sitzung fk. Wie Sie in meinem Code sehen:

---

@Table(name="Orders") 
@Entity 

public class Order { 
    @ManyToOne 
    @JoinColumn(nullable = false) 
    private User user; 

    @ManyToOne 
    private Session session; 
    ... 
} 



@Entity 
@Table(name="Session") 

public class Session { 
    @OneToMany(fetch=FetchType.LAZY, 
       cascade = CascadeType.ALL, 
       mappedBy = "session") 
    private List<Order> orders = new ArrayList<Order>(); 
    ... 
} 



@Table(name="User") 
@Entity 

public class User { 
    @OneToMany(cascade = { CascadeType.PERSIST, 
          CascadeType.MERGE, 
          CascadeType.REMOVE }, 
       mappedBy = "user") 
    private @Getter Set<Order> orders = new HashSet<>(); 
    ... 
} 

---

Meine Frage ist, Kann ich CascadeType.ALL sowohl in Session und Nutzer? Gibt es mögliche Konflikte beim Update-Auftrag mit Session und User?

---

Wie Sie sehen können, verwende ich FetchType.LAZY, es kann garantieren, dass Aufträge in beiden Session und Benutzer sind up-to-date?

Answer 1

Frage 1: Es ist eine gute Frage, aber um sie zu beantworten, müssen Sie das Konzept der owning Einheit verstehen. Die Entity mit der @ManyToOne Annotation ist der Besitzer der Beziehung. Dies ist wichtig für den Entwickler, da keine Beziehung beibehalten wird, es sei denn, dies geschieht auf der eigenen Seite. In diesem Fall bedeutet dies, Order.user zu setzen. da Sie haben jedoch die cascade Anmerkung auf der Nicht-Besitz User, haben Sie zusätzliche Arbeit zu tun, um die Kaskade Funktionalität zu verwenden:

// create Order 
Order order = new Order(); 
// create User and Set of orders 
User user = new User(); 
Set<Order> userOrders = new HashSet<Order>(); 
user.setOrders(userOrders); 
userOrders.add(order); 
// and set Order.user 
order.setUser(user); 
// persist with cascade 
em.persist(user); 

Beachten Sie, dass Sie so gut wie eingestellt Order.user ein Set von Aufträgen erstellen müssen mit der Kaskade fortfahren. Wenn Sie jedoch setzen die cascade Anmerkung auf die besitzende Einheit Order, dann Ihre Arbeit wird viel einfacher:

// create User 
User user = new User(); 
// create Order 
Order order = new Order(); 
// and set Order.user 
order.setUser(user); 
// persist with cascade 
em.persist(order); 

Jetzt nur persistierende order wird die neue User und die Order mit einem Anruf bestehen bleiben. Ohne die cascade Annotation auf der Order Entität gibt persistent Order vor User Ihnen eine Ausnahme.

Referenzen: What is the “owning side” in an ORM mapping?, In a bidirectional JPA OneToMany/ManyToOne association, what is meant by “the inverse side of the association”?

Frage 2: FetchType.LAZY bedeutet, dass Sie die Kinder durch spezifische Abfrage zu erhalten, also, wenn ich Ihre Frage verstehen, ist die Antwort nein, ist es für nichts garantieren. Mit FetchType.LAZY, wenn Sie eine Session erhalten, haben Sie keinen Zugriff auf die Session.orders, wenn die Entität losgelöst wird, in der Regel nachdem Sie Ihre Session Bean oder Service Layer verlassen haben. Wenn Sie Zugriff auf Aufträge benötigen, müssen Sie sie in der SELECT-Abfrage erhalten:

"select distinct s von Session s beitreten holen s.orders"

EDIT: Wie bereits erwähnt, wird standardmäßig Diese Abfrage führt einen SQL-internen Join aus, der nichts zurückgibt, wenn keine Aufträge vorhanden sind. Stattdessen tun

"select distinct s von Session s LEFT JOIN holen s.orders"

so dass Sie immer die Sitzungen erhalten, die in der Datenbank vorhanden sind.

Referenz: Difference between FetchType LAZY and EAGER in Java Persistence API?