[JPA / Hibernate] Cascade qui ne cascade pas !
Bonjour à tous (et à toutes)
Bon, en fait je voulais titrer plus précisément, mais ça aurait donné un truc dans le genre :
[Glassfish][Hibernate][JPA][EJB3][Seam][Ajax4jsf][Facelets] Persistence d'entités en relation avec cascadeType.PERSIST qui ne fonctionne pas
et ça fait un titre un peu long pour le forum.
Donc, je présente en gros ce que j'ai (je vous avoue avoir pas mal cherché jusqu'à maintenant...). Le principe est simple :
Un customer a plusieurs orders qui ont elles-même plusieurs orderLines
Un customer a plusieurs contacts
Les contacts sont liés aux orderLines par un Binder qui dit quel contact a quel type de service pour quell orderLine
Le souci c'est que la persistence se fait bien pour les contacts et les orders, mais qu'elle ne va pas plus loin. C'est à dire que lorsqu'on fait
le customer est persisté, les orders en relation sont persistées et les contacts en relation sont persistés, mais pas les orderlines, ni les binders.
Je précise qu'ayant débuggué jusqu'au moment de la persistance, mes objets sont bien en relation (avec les bons identifiants, des orderlines crées et rattachées à l'orders etc...).
Voici le code de la classe customer
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
@Entity
@Name("Customer")
public class Customer implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long customerId;
//champs
/**
*Creates the foreign key in relation to the Order table
*/
@OneToMany(mappedBy = "customer", cascade = CascadeType.PERSIST)
private List<Order> orders;
/**
*Creates the foreign key in relation to the Contact table
*/
@OneToMany(mappedBy = "customer", cascade = CascadeType.PERSIST)
private List<Contact> contacts;
/** Creates a new instance of Client */
public Customer() {
}
...
//getter et setters
} |
celui de la classe order
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
@Entity
@Table(name = "client_order")
public class Order implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long orderId;
//champs
/**
*Creates the foreign key in relation to the Partner table
*/
@ManyToOne
@JoinColumn (name = "partnerId_fk")
private Partner partner;
/**
*Creates the foreign key in relation to the Customer table
*/
@ManyToOne
@JoinColumn (name = "customerId_fk")
private Customer customer;
/**
*This table creates the joint between the purchase order and its lines of order.
*The primary key of this table is consisted of the two foreign keys.
*/
@OneToMany(mappedBy = "order")
private List<OrderLine> orderLines;
/**
* Creates a new instance of Order
*/
public Order() {
}
...
//getter et setters
} |
celui de la classe OrderLine
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
@Entity
@Name("OrderLine")
public class OrderLine implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long lineId;
//champs
@ManyToOne
@JoinColumn (name = "orderId")
private Order order;
/** Creates a new instance of OrderLine */
public OrderLine() {
}
...
//getter et setters
} |
Si quelqu'un a une idée, ça ne serait pas de refus.
Je précise également qu'à l'origine la relation order<->orderline était unidirectionnelle (une table de jointure explicitement faite entre les deux) et ça ne fonctionnait pas. Je pensais que la bidirectionnalité y ferait quelque chose...
Merci à ceux qui ont les yeux fatigués par la lecture de ce long post.
Courage, plus qu'une phrase.
Merci
