1.OneToOne關係對映

OneToOne即一對一對映，簡單來說就是一個主表student和一個從表stucreditcard，B表中存在一個外來鍵關聯到student表，這種關聯關係既可以以外來鍵的方式建立也可以是人工維護的關聯關係。

單向一對一關聯（不包括主鍵關聯）

這種關聯關係只能配置在從表的PO中，簡要示例如下：

1. @Entity

2. @Table(name="stucreditcard")

3. public class StudentCard {

4. private Integer cardId;

5. private Integer balance;

6. private Student student;

7. ......

8. @OneToOne

9. @JoinColumn(name="studentid",referencedColumnName="id")//這裡的studentid為從表的外來鍵欄位名，id為從表所引用的主表字段名

10. ，預設為主鍵

1. public Student getStudent() {

2. return student;

3. }

4. public void setStudent(Student student) {

5. this.student = student;

6. }

以上配置就可以從StudentCard例項中獲取Student例項。

雙向一對一關聯（不包括主鍵關聯）

雙向關聯的配置涉及OneToOne的一個屬性mappedBy，簡要說明如下：

a) 只有OneToOne,OneToMany,ManyToMany上才有mappedBy屬性，ManyToOne不存在該屬性；

b) mappedBy標籤一定是定義在the owned side(被擁有方的，這裡就是主表)，他指向the owning side(擁有方，這裡是從表)；

c) 關係的擁有方負責關係的維護，在擁有方建立外來鍵。所以用到@JoinColumn

d)mappedBy跟JoinColumn/JoinTable總是處於互斥的一方

e)如果雙向關係不配置mappedBy，則預設關聯主鍵（不配置mappedBy就得配置JoinColumn啦）

雙向關聯即在表示主表的PO中可以獲取從表中關聯的資訊，在從表的PO中也可以獲取主表中從表關聯的資訊，示例如下:

主表配置：

1. @Entity

2. @Table(name="student")

3. public class Student implements Serializable{

4. private static final long serialVersionUID = 1L;

5. private Integer studentId;

6. private String name;

7. private StudentCard sc;

8. @OneToOne(mappedBy="student")//這裡的student是從表的PO中主表PO的屬性名

1. public StudentCard getSc() {

2. return sc;

3. }

4. public void setSc(StudentCard sc) {

5. this.sc = sc;

6. }

從表配置：

1. @OneToOne

2. @JoinColumn(name="studentid",referencedColumnName="id")//studentid是從表中的欄位名，id是主表中的欄位名，這裡id也可以不為主鍵

1. public Student getStudent() {

2. return student;

3. }

4. public void setStudent(Student student) {

5. this.student = student;

6. }

2.OneToMany關係

 一對多的關係，舉個例子：一個訂單（order）可以包括多個訂單項（orderItem），但同時一個訂單項有且僅有一個與之對應的訂單，這樣訂單和訂單項就構成了一對多的關係。

在one端配置單向關係

many端PO僅需配置欄位對映關係，而不需要配置關聯關係；

one端配置關聯關係如下：

	private Set<OrderItem> orderItems;//關聯關係屬性

1. public void setOrderItems(Set<OrderItem> orderItems) {

2. this.orderItems = orderItems;

3. }

4. @OneToMany(fetch=FetchType.EAGER)

5. /**

6. * 下面的order_id是many方的表字段;

7. * id為one方的表字段(不寫referencedColumnName="XXX"則預設為主鍵，也可以指定不是主鍵的欄位)

8. * order_id和id關聯

9. */

10. @JoinColumn(name="order_id",referencedColumnName="id")

11. public Set<OrderItem> getOrderItems() {

12. return orderItems;

13. }

如此即可在one端PO中獲取到many端的PO例項了。

在many端配置單向關係

one端PO僅需配置欄位對映關係，而不需要配置關聯關係

many端配置如下：

1. @Entity

2. @Table(name="orderitem")

3. public class OrderItem {

4. private Order order;//關聯關係欄位

5. private Integer id;

6. // private Integer orderId;//與one表的關聯欄位，這裡先註釋掉，可以試下不註釋

7. // @Column(name="order_id")

8. // public Integer getOrderId() {

9. // return orderId;

10. // }

11. // public void setOrderId(Integer orderId) {

12. // this.orderId = orderId;

13. // }

14. @Id

15. @GeneratedValue(strategy=GenerationType.AUTO)

16. public Integer getId() {

17. return id;

18. }

19. public void setId(Integer id) {

20. this.id = id;

21. }

22. @ManyToOne

23. /**

24. * order_id many表的欄位

25. * id為one方的表字段(不寫referencedColumnName="XXX"則預設為主鍵，也可以指定不是主鍵的欄位)

26. * order_id和id關聯

27. */

28. @JoinColumn(name="order_id",referencedColumnName="id")

29. public Order getOrder() {

30. return order;

31. }

32. public void setOrder(Order order) {

33. this.order = order;

34. }

}

配置OneToMany雙向關係

one端和many端都得配置關聯關係

one端：

	private Set<OrderItem> orderItems;//關聯關係欄位

1. public void setOrderItems(Set<OrderItem> orderItems) {

2. this.orderItems = orderItems;

3. }

4. @OneToMany(fetch=FetchType.EAGER,mappedBy="order")//還記得前面說過的雙向關聯需要配置mappedBy嗎？

1. public Set<OrderItem> getOrderItems() {

2. return orderItems;

3. }

many端：

1. private Order order;//關聯關係欄位

2. @ManyToOne

3. /**

4. * order_id many表的欄位

5. * id為one方的表字段(不寫referencedColumnName="XXX"則預設為主鍵，也可以指定不是主鍵的欄位)

6. * order_id和id關聯

7. */

8. @JoinColumn(name="order_id",referencedColumnName="id")

9. public Order getOrder() {

10. return order;

11. }

12. public void setOrder(Order order) {

13. this.order = order;

14. }