JPA双向一对多多一对一

 •

双向一对多关系中，必须存在一个关系维护端，在 JPA 规范中，要求  many 的一方作为关系的维护端(owner side), one 的一方作为被维护端(inverse side)。

•可以在 one 方指定 @OneToMany 注释并设置 mappedBy 属性，以指定它是这一关联中的被维护端，many 为维护端。

•在 many 方指定 @ManyToOne 注释，并使用 @JoinColumn 指定外键名称

1. package com.morris.entity;  
2.    
3. import javax.persistence.CascadeType;  
4. import javax.persistence.Column;  
5. import javax.persistence.Entity;  
6. import javax.persistence.FetchType;  
7. import javax.persistence.GeneratedValue;  
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.       
17.      @Id  
18.      @GeneratedValue  
19.      @Column(name="order_item_id")  
20.      private Integer orderItemId;  
21.       
22.      @Column(name="product_name",length=50,nullable=false)  
23.      private String productName;  
24.       
25.      @Column(name="product_price",nullable=false)  
26.      private Double productPrice;  
27.       
28.      /** 
29.       * ManyToOne：多对一的配置 
30.       * cascade(级联)：all(所有)，merge(更新)，refresh(查询)，persistence(保存)，remove(删除) 
31.       * fetch: eager:立即加载  one的一方默认是立即加载 
32.       *            lazy:懒加载    many的一方默认是懒加载 
33.       * optional:是否可选,外键是否允许为空 
34.       * 
35.       * JoinColumn:指定外键名 
36.       * 
37.       */  
38.      @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},fetch=FetchType.EAGER,optional=false)  
39.      @JoinColumn(name="order_id")  
40.      private Order order;  
41.    
42.       
43.      public OrderItem() {  
44.          super();  
45.          // TODO Auto-generated constructor stub  
46.      }  
47.    
48.      @Override  
49.      public String toString() {  
50.          return "OrderItem [orderItemId=" + orderItemId + ", productName="  
51.                    + productName + ", productPrice=" + productPrice + ", order="  
52.                    + order + "]";  
53.      }  
54.    
55.      public Integer getOrderItemId() {  
56.          return orderItemId;  
57.      }  
58.    
59.      public void setOrderItemId(Integer orderItemId) {  
60.          this.orderItemId = orderItemId;  
61.      }  
62.    
63.      public String getProductName() {  
64.          return productName;  
65.      }  
66.    
67.      public void setProductName(String productName) {  
68.          this.productName = productName;  
69.      }  
70.    
71.      public Double getProductPrice() {  
72.          return productPrice;  
73.      }  
74.    
75.      public void setProductPrice(Double productPrice) {  
76.          this.productPrice = productPrice;  
77.      }  
78.    
79.      public Order getOrder() {  
80.          return order;  
81.      }  
82.    
83.      public void setOrder(Order order) {  
84.          this.order = order;  
85.      }  
86.    
87.      public OrderItem(String productName,  
88.               Double productPrice) {  
89.          super();  
90.          this.productName = productName;  
91.          this.productPrice = productPrice;  
92.      }  
93. }  
94.  ---------------------------------------------------------------------------------
95.  双向一对多
96. package com.morris.entity;  
97.    
98. import java.util.Set;  
99.    
100. import javax.persistence.CascadeType;  
101. import javax.persistence.Column;  
102. import javax.persistence.Entity;  
103. import javax.persistence.FetchType;  
104. import javax.persistence.Id;  
105. import javax.persistence.OneToMany;  
106. import javax.persistence.Table;  
107.    
108. @Entity  
109. @Table(name="orders")  
110. public class Order {  
111.      
112.     @Id  
113.     @Column(name="order_id",length=32)  
114.     private String orderId;  
115.      
116.     @Column(name="order_name",length=50)  
117.     private String orderName;  
118.      
119.     /** 
120.      * OneToMany:一对多的配置 
121.      * mappedBy="order":指定由多的一方的order属性维护关联关系 
122.      * 
123.      */  
124.     @OneToMany(cascade={CascadeType.REFRESH,CascadeType.MERGE,CascadeType.REMOVE,CascadeType.PERSIST},fetch=FetchType.LAZY,mappedBy="order")  
125.     private Set<OrderItem> orderItems;  
126.    
127.     public Order(String orderId, String orderName, Set<OrderItem> orderItems) {  
128.        super();  
129.        this.orderId = orderId;  
130.        this.orderName = orderName;  
131.        this.orderItems = orderItems;  
132.     }  
133.    
134.     public Set<OrderItem> getOrderItems() {  
135.        return orderItems;  
136.     }  
137.    
138.     public void setOrderItems(Set<OrderItem> orderItems) {  
139.        this.orderItems = orderItems;  
140.     }  
141.    
142.     public Order() {  
143.        super();  
144.        // TODO Auto-generated constructor stub  
145.     }  
146.    
147.     public Order(String orderId, String orderName) {  
148.        super();  
149.        this.orderId = orderId;  
150.        this.orderName = orderName;  
151.     }  
152.    
153.     @Override  
154.     public String toString() {  
155.        return "Order [orderId=" + orderId + ", orderName=" + orderName + "]";  
156.     }  
157.    
158.     public String getOrderId() {  
159.        return orderId;  
160.     }  
161.    
162.     public void setOrderId(String orderId) {  
163.        this.orderId = orderId;  
164.     }  
165.    
166.     public String getOrderName() {  
167.        return orderName;  
168.     }  
169.    
170.     public void setOrderName(String orderName) {  
171.        this.orderName = orderName;  
172.     }  
173. }