学步园

　　JPA中一对多和多对一双向关系中，多的一方为关系维护端 。有mappedBy的一方为关系被维护端。

　　关系维护端负责外键纪录的更新 ，关系被维护端是没有权力更新外键纪录的。只能通过关系维护端设置与关系被维护端的关系。

一对多：

@OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,
            CascadeType.MERGE, CascadeType.REMOVE, CascadeType.ALL }, fetch = FetchType.EAGER, mappedBy = "order")

cascade：设置级联操作，对JPQL语句进行的操作没有任何影响

CascadeType.PERSIST对应实体管理器的persist()方法

CascadeType.REFRESH对应实体管理器的refresh()方法

CascadeType.MERGE对应实体管理器的merge()方法

CascadeType.REMOVE对应实体管理器的remove()方法

CascadeType.ALL对应实体管理器的以上方法：persist()、refresh()、merge()、remove()方法

fetch：设置是否延迟加载，FetchType.LZAY为延迟加载， FetchType.EAGER时立即加载。如果加载的是多的一方的话，默认的是延迟加载，否则是加载。

多对一：

@ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = false)
@JoinColumn(name = "order_id")

optional：代表外键字段是否可以为空。true可以为空，false不可以为空。

@JoinColumn(name = "order_id")：设置关联外键字段的名称。

例：

１.两个实体的一对多和多对一

使用现实生活中的订单和订单项的关系，代码为：

Orderinfo.java代码  

1. package com.taoistwar.jpa.entity.onetomany;  
2.   
3. import java.util.HashSet;  
4. import java.util.Set;  
5.   
6. import javax.persistence.CascadeType;  
7. import javax.persistence.Entity;  
8. import javax.persistence.FetchType;  
9. import javax.persistence.GeneratedValue;  
10. import javax.persistence.GenerationType;  
11. import javax.persistence.Id;  
12. import javax.persistence.OneToMany;  
13. import javax.persistence.Table;  
14.   
15. @Entity  
16. @Table(name = "order_info")  
17. public class OrderInfo {  
18.     private Integer id;  
19.     private String name;  
20.   
21.     private Set<OrderItem> items = new HashSet<OrderItem>();  
22.   
23.     @Id  
24.     @GeneratedValue(strategy = GenerationType.AUTO)  
25.     public Integer getId() {  
26.         return id;  
27.     }  
28.   
29.     public void setId(Integer id) {  
30.         this.id = id;  
31.     }  
32.   
33.     public String getName() {  
34.         return name;  
35.     }  
36.   
37.     public void setName(String name) {  
38.         this.name = name;  
39.     }  
40.   
41.     @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.REFRESH,  
42.             CascadeType.MERGE, CascadeType.REMOVE }, fetch = FetchType.EAGER, mappedBy = "order")  
43.     //fetch是否延迟加载，mappedBy有它的一方为关系被维护端。  
44.     public Set<OrderItem> getItems() {  
45.         return items;  
46.     }  
47.   
48.     public void setItems(Set<OrderItem> items) {  
49.         this.items = items;  
50.     }  
51.   
52.     public void addOrderItem(OrderItem orderItem) {  
53.         orderItem.setOrder(this);  
54.         this.items.add(orderItem);  
55.     }  
56.   
57. }  

Orderitem.java代码  

1. package com.taoistwar.jpa.entity.onetomany;  
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.GenerationType;  
8. import javax.persistence.Id;  
9. import javax.persistence.JoinColumn;  
10. import javax.persistence.ManyToOne;  
11. import javax.persistence.Table;  
12.   
13. @Entity  
14. @Table(name = "order_item")  
15. public class OrderItem {  
16.     private Integer Id;  
17.     private String name;  
18.   
19.     private OrderInfo order;  
20.   
21.     @Id  
22.     @GeneratedValue(strategy = GenerationType.AUTO)  
23.     public Integer getId() {  
24.         return Id;  
25.     }  
26.   
27.     public void setId(Integer id) {  
28.         Id = id;  
29.     }  
30.   
31.     @Column(length = 20, nullable = true)  
32.     public String getName() {  
33.         return name;  
34.     }  
35.   
36.     public void setName(String name) {  
37.         this.name = name;  
38.     }  
39.   
40.     @ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = false)  
41.     @JoinColumn(name = "order_id")  
42.     // optional是否可以为空  
43.     public OrderInfo getOrder() {  
44.         return order;  
45.     }  
46.   
47.     public void setOrder(OrderInfo order) {  
48.         this.order = order;  
49.     }  
50.   
51.     @Override  
52.     public int hashCode() {  
53.         final int prime = 31;  
54.         int result = 1;  
55.         result = prime * result + ((Id == null) ? 0 : Id.hashCode());  
56.         return result;  
57.     }  
58.   
59.     @Override  
60.     public boolean equals(Object obj) {  
61.         if (this == obj)  
62.             return true;  
63.         if (obj == null)  
64.             return false;  
65.         if (getClass() != obj.getClass())  
66.             return false;  
67.         OrderItem other = (OrderItem) obj;  
68.         if (Id == null) {  
69.             if (other.Id != null)  
70.                 return false;  
71.         } else if (!Id.equals(other.Id))  
72.             return false;  
73.         return true;  
74.     }  
75.   
76. }  

 2.单个实体的一对多和多对一

使用软件开发中的模块为例子，代码如下：

Moudle.java代码  

1. package com.taoistwar.ejb.sys.entity;  
2.   
3. import java.io.Serializable;  
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.FetchType;  
10. import javax.persistence.GeneratedValue;  
11. import javax.persistence.GenerationType;  
12. import javax.persistence.Id;