JPA一对多关联

 1 package com.yichun.bean;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.persistence.CascadeType;
 7 import javax.persistence.Column;
 8 import javax.persistence.Entity;
 9 import javax.persistence.Id;
10 import javax.persistence.OneToMany;
11 import javax.persistence.Table;
12 
13 @Entity
14 @Table(name = "orders")
15 public class Order {
16 
17     private String orderId;
18     private Float amoutn = 0f;
19     private Set<OrderItem> items = new HashSet<OrderItem>();
20 
21     @Id
22     @Column(length = 12, nullable = false)
23     public String getOrderId() {
24         return orderId;
25     }
26 
27     public void setOrderId(String orderId) {
28         this.orderId = orderId;
29     }
30 
31     @Column(nullable = false)
32     public Float getAmoutn() {
33         return amoutn;
34     }
35 
36     public void setAmoutn(Float amoutn) {
37         this.amoutn = amoutn;
38     }
39 
40     // CascadeType.REFRESH，级联刷新。orderItems更改的时候，就重新加载orderItems
41 
42     // CascadeType.PERSIST, 级联保存。insert order insert into orderitem 。调用manager.persist(new Order())的时候才会起作用
43 
44     // CascadeType.MERGE,级联更新 。order在游离状态的时候被修改了，order中的orderItem也被修改了，update order for (update orderItem)。 调用manager.merge(order) 的时候才会起作用
45 
46     // CascadeType.REMOVE级联删除。 删除order的时候，orderItems也会被删除，没有住外键约束的时候。调用manager.remove(order)的时候才会起作用。
47     
48     // 针对实体管理器的四种方法
49     // fetch =FetchType.LAZY默认是延迟加载。××tomany由一方得到多的一方的时候，默认就是延迟加载，××toone的时候，默认就是立即加载
50     // 出现mappedBy的类就是关系被维护端。关系由对方里面的order属性维护
51     @OneToMany(cascade = { CascadeType.REFRESH, CascadeType.PERSIST,
52             CascadeType.MERGE, CascadeType.REMOVE }, mappedBy = "order")
53     public Set<OrderItem> getItems() {
54         return items;
55     }
56 
57     public void setItems(Set<OrderItem> items) {
58         this.items = items;
59     }
60 
61     // 建立两者之间的关系
62     public void addOrderItem(OrderItem orderItem) {
63         orderItem.setOrder(this);
64         this.items.add(orderItem);
65     }
66 }

 1 package com.yichun.bean;
 2 
 3 import javax.persistence.CascadeType;
 4 import javax.persistence.Column;
 5 import javax.persistence.Entity;
 6 import javax.persistence.GeneratedValue;
 7 import javax.persistence.Id;
 8 import javax.persistence.JoinColumn;
 9 import javax.persistence.ManyToOne;
10 
11 @Entity
12 public class OrderItem {
13     private Integer id;
14     private String productName;
15     private Float sellPrice = 0f;
16     private Order order;
17 
18     @Id
19     @GeneratedValue
20     public Integer getId() {
21         return id;
22     }
23 
24     public void setId(Integer id) {
25         this.id = id;
26     }
27 
28     @Column(length = 40, nullable = false)
29     public String getProductName() {
30         return productName;
31     }
32 
33     public void setProductName(String productName) {
34         this.productName = productName;
35     }
36 
37     @Column(nullable = false)
38     public Float getSellPrice() {
39         return sellPrice;
40     }
41 
42     public void setSellPrice(Float sellPrice) {
43         this.sellPrice = sellPrice;
44     }
45 
46     // optional=true，在数据库中允许为null
47     @ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = true)// 级联更新，级联刷新
48     @JoinColumn(name = "order_id")
49     public Order getOrder() {
50         return order;
51     }
52 
53     public void setOrder(Order order) {
54         this.order = order;
55     }
56 }

 1     @Test
 2     public void save() {
 3         EntityManagerFactory factory = Persistence
 4                 .createEntityManagerFactory("testjpa");
 5         EntityManager manager = factory.createEntityManager();
 6         manager.getTransaction().begin();
 7 
 8         Order order = new Order();
 9         order.setAmoutn(120f);
10         order.setOrderId("999");// UUID.randomUUID().toString()
11 
12         OrderItem item = new OrderItem();
13         item.setProductName("足球");
14         item.setSellPrice(90f);
15 
16         OrderItem item2 = new OrderItem();
17         item2.setProductName("排球");
18         item2.setSellPrice(30f);
19 
20         // 设置两者之间的关联
21         order.addOrderItem(item);
22         order.addOrderItem(item2);
23 
24         // 保存Order，此时也会保持OrderItem
25         manager.persist(order);
26 
27         manager.getTransaction().commit();
28         manager.clear();
29         factory.close();
30     }