@OneToMany或@ManyToOne的用法-annotation關係映射篇（上)

例如我們用一個例子來開啓JPA的一對多和多對一的學習。

  比如你去噹噹網上買書籍，噹噹網就給你一個訂單。
  通過上面的業務活動描述你可以分析得出：一個訂單可以包含一個或多個訂單項.那麼我們將將訂單和訂單項設計關係爲(1:N)一對多的關係(排除0)。得出關係我們就使用JPA來實現這個關係(關於建立JPA和基本的配置我就不再說了，如果不明白請看JPA入門篇)。

首先建立訂單實體類

Java代碼 

1. import java.util.HashSet;   
2. import java.util.Set;   
3.   
4. import javax.persistence.CascadeType;   
5. import javax.persistence.Column;   
6. import javax.persistence.Entity;   
7. import javax.persistence.Id;   
8. import javax.persistence.OneToMany;   
9. import javax.persistence.Table;   
10.   
11. @Entity  
12. @Table(name="orders")   
13. public class Order {   
14.        
15.     private String orderid;   
16.     private Float amount = 0f;   
17.     private Set<OrderItem> items = new HashSet<OrderItem>();   
18.   
19.     @Id  
20.     @Column(length = 12)   
21.     public String getOrderid() {   
22.         return orderid;   
23.     }   
24.   
25.     public void setOrderid(String orderid) {   
26.         this.orderid = orderid;   
27.     }   
28.   
29.     @Column(nullable = false)   
30.     public Float getAmount() {   
31.         return amount;   
32.     }   
33.   
34.     public void setAmount(Float amount) {   
35.         this.amount = amount;   
36.     }   
37.   
38.     @OneToMany(cascade = { CascadeType.REFRESH, CascadeType.PERSIST,CascadeType.MERGE, CascadeType.REMOVE },mappedBy ="order") //這裏配置關係，並且確定關係維護端和被維護端。mappBy表示關係被維護端，只有關係端有權去更新外鍵。這裏還有注意OneToMany默認的加載方式是賴加載。當看到設置關係中最後一個單詞是Many，那麼該加載默認爲懶加載   
39.     public Set<OrderItem> getItems() {   
40.         return items;   
41.     }   
42.   
43.     public void setItems(Set<OrderItem> items) {   
44.         this.items = items;   
45.     }   
46.        
47.          /**   
48.            *該方法用於向order中加order項   
49.           /*   
50.     public void addOrderItem(OrderItem orderItem){   
51.         orderItem.setOrder(this);//用關係維護端來維護關係   
52.         this.items.add(orderItem);   
53.     }   
54.   
55. }  

訂單項的實體類

Java代碼 

1. import javax.persistence.CascadeType;   
2. import javax.persistence.Column;   
3. import javax.persistence.Entity;   
4. import javax.persistence.GeneratedValue;   
5. import javax.persistence.Id;   
6. import javax.persistence.JoinColumn;   
7. import javax.persistence.ManyToOne;   
8.   
9. @Entity  
10. public class OrderItem {   
11.     private Integer id;   
12.     private String productName;   
13.     private Float sellPrice = 0f;   
14.     private Order order;   
15.   
16.     @Id  
17.     @GeneratedValue  
18.     public Integer getId() {   
19.         return id;   
20.     }   
21.   
22.     public void setId(Integer id) {   
23.         this.id = id;   
24.     }   
25.   
26.     @Column(length = 40, nullable = false)   
27.     public String getProductName() {   
28.         return productName;   
29.     }   
30.   
31.     public void setProductName(String productName) {   
32.         this.productName = productName;   
33.     }   
34.   
35.     @Column(nullable = false)   
36.     public Float getSellPrice() {   
37.         return sellPrice;   
38.     }   
39.   
40.     public void setSellPrice(Float sellPrice) {   
41.         this.sellPrice = sellPrice;   
42.     }   
43.   
44.     @ManyToOne(cascade = {CascadeType.MERGE,CascadeType.REFRESH }, optional = true)   
45.     @JoinColumn(name="order_id")//這裏設置JoinColum設置了外鍵的名字，並且orderItem是關係維護端  
46.     public Order getOrder() {   
47.         return order;   
48.     }   
49.   
50.     public void setOrder(Order order) {   
51.         this.order = order;   
52.     }   
53.   
54. }  

下面看看測試類

Java代碼 

1. import javax.persistence.EntityManager;   
2. import javax.persistence.EntityManagerFactory;   
3. import javax.persistence.Persistence;   
4.   
5. import org.junit.BeforeClass;   
6. import org.junit.Test;   
7.   
8. import cn.itcast.bean.Order;   
9. import cn.itcast.bean.OrderItem;   
10.   
11. public class OneToManyTest {   
12.   
13.     @BeforeClass  
14.     public static void setUpBeforeClass() throws Exception {   
15.     }   
16.     @Test public void addOrder(){   
17.          EntityManagerFactory factory = Persistence.createEntityManagerFactory("test");   
18.          EntityManager em = factory.createEntityManager();   
19.          em.getTransaction().begin(); // start transaction   
20.             
21.                    Order order = new Order();    
22.          order.setAmount(34f);    
23.          order.setOrderid("00001");   
24.                       
25.                    //order中包含的OrderItem項OrderItem1，OrderItem2   
26.          OrderItem orderItem1 = new OrderItem();   
27.          orderItem1.setProductName("書");   
28.          orderItem1.setSellPrice(22f);   
29.          order.addOrderItem(orderItem1); //add orderitem in order   
30.             
31.          OrderItem orderItem2 = new OrderItem();   
32.          orderItem2.setProductName("籃球");   
33.          orderItem2.setSellPrice(100f);   
34.          order.addOrderItem(orderItem2);   
35.             
36.          em.persist(order); //persist order object   
37.          em.getTransaction().commit(); //commit transaction   
38.          em.close();   
39.          factory.close();   
40.     }   
41. }