JPA双向一对多和多对一及自关联实例

JPA双向一对多和多对一

• 博客分类： 
• EJB3.0 from http://taoistwar.iteye.com/blog/409015

　　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;  
13. import javax.persistence.JoinColumn;  
14. import javax.persistence.ManyToOne;  
15. import javax.persistence.OneToMany;  
16. import javax.persistence.Table;  
17.   
18. /**  
19.  * @author TaoistWar 模块实体类　（一对多）  
20.  * 　JPA中一对多和多对一双向关系中，多的一方为关系维护端。  
21.  *  关系维护端负责外键纪录的更新，关系被维护端是没有权力更新外键纪录的。  
22.  */  
23. @Entity  
24. @Table(name = "s_moudle")  
25. public class Moudle implements Serializable {  
26.     @Id  
27.     @GeneratedValue(strategy = GenerationType.AUTO)  
28.     private Integer id;  
29.     // 模块名(一般中文)  
30.     @Column(name = "modName")  
31.     private String modName;  
32.     // 模块值(英文)  
33.     @Column(name = "modValue")  
34.     private String modValue;  
35.     // 模块排序编码  
36.     @Column(name = "orderCode")  
37.     private Integer orderCode;  
38.     // 模块是否禁用  
39.     @Column(name = "forbidden")  
40.     private boolean forbidden;  
41.     // 模块链接路径  
42.     @Column(name = "modUrl")  
43.     private String modUrl;  
44.     // 父级模块  
45.     @ManyToOne(cascade = { CascadeType.REFRESH, CascadeType.REMOVE }, optional=true)  
46.     @JoinColumn(name="parent_id")  
47.     // optional关联字段是否可以为空  
48.     private Moudle parent;  
49.     // 子级模块  
50.     @OneToMany(cascade = { CascadeType.REFRESH, CascadeType.REMOVE }, fetch=FetchType.LAZY, mappedBy="parent")  
51.     private Set<Moudle> children;  
52.   
53.     public Integer getId() {  
54.         return id;  
55.     }  
56.   
57.     public void setId(Integer id) {  
58.         this.id = id;  
59.     }  
60.   
61.     public String getModName() {  
62.         return modName;  
63.     }  
64.   
65.     public void setModName(String modName) {  
66.         this.modName = modName;  
67.     }  
68.   
69.     public String getModValue() {  
70.         return modValue;  
71.     }  
72.   
73.     public void setModValue(String modValue) {  
74.         this.modValue = modValue;  
75.     }  
76.   
77.     public Integer getOrderCode() {  
78.         return orderCode;  
79.     }  
80.   
81.     public void setOrderCode(Integer orderCode) {  
82.         this.orderCode = orderCode;  
83.     }  
84.   
85.     public boolean isForbidden() {  
86.         return forbidden;  
87.     }  
88.   
89.     public void setForbidden(boolean forbidden) {  
90.         this.forbidden = forbidden;  
91.     }  
92.   
93.     public String getModUrl() {  
94.         return modUrl;  
95.     }  
96.   
97.     public void setModUrl(String modUrl) {  
98.         this.modUrl = modUrl;  
99.     }  
100.   
101.     public Moudle getParent() {  
102.         return parent;  
103.     }  
104.   
105.     public void setParent(Moudle parent) {  
106.         this.parent = parent;  
107.     }  
108.   
109.     public Set<Moudle> getChildren() {  
110.         return children;  
111.     }  
112.   
113.     public void setChildren(Set<Moudle> children) {  
114.         this.children = children;  
115.     }  
116.   
117. }