hibernate对象关系映射-注解

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. ......

9.  

10. @OneToOne

11. @JoinColumn(name="studentid",referencedColumnName="id")//这里的studentid为从表的外键字段名，id为从表所引用的主表字段名

12. ，默认为主键

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.  

5. private static final long serialVersionUID = 1L;

6. private Integer studentId;

7. private String name;

8. private StudentCard sc;

9.  
10.  

11. @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.  

5. @OneToMany(fetch=FetchType.EAGER)

6. /**

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

8. * id为one方的表字段(不写referencedColumnName="XXX"则默认为主键，也可以指定不是主键的字段)

9. * order_id和id关联

10. */

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

12. public Set<OrderItem> getOrderItems() {

13. return orderItems;

14. }

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

 

在many端配置单向关系

one端PO仅需配置字段映射关系，而不需要配置关联关系

many端配置如下：

1. @Entity

2. @Table(name="orderitem")

3. public class OrderItem {

4.  

5. private Order order;//关联关系字段

6. private Integer id;

7. // private Integer orderId;//与one表的关联字段，这里先注释掉，可以试下不注释

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

9. // public Integer getOrderId() {

10. // return orderId;

11. // }

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

13. // this.orderId = orderId;

14. // }

15. @Id

16. @GeneratedValue(strategy=GenerationType.AUTO)

17. public Integer getId() {

18. return id;

19. }

20. public void setId(Integer id) {

21. this.id = id;

22. }

23.  

24. @ManyToOne

25. /**

26. * order_id many表的字段

27. * id为one方的表字段(不写referencedColumnName="XXX"则默认为主键，也可以指定不是主键的字段)

28. * order_id和id关联

29. */

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

31. public Order getOrder() {

32. return order;

33. }

34. public void setOrder(Order order) {

35. this.order = order;

36. }

}

配置OneToMany双向关系

one端和many端都得配置关联关系

one端：

	private Set<OrderItem> orderItems;//关联关系字段

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

2. this.orderItems = orderItems;

3. }

4.  

5. @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. }