实体关系之@OneToMany

1. packagecom.entity;
2. importjava.io.Serializable;
3. importjava.util.Date;
4. importjava.util.HashSet;
5. importjava.util.Set;
6. importjavax.persistence.CascadeType;
7. importjavax.persistence.Column;
8. importjavax.persistence.Entity;
9. importjavax.persistence.FetchType;
10. importjavax.persistence.GeneratedValue;
11. importjavax.persistence.Id;
12. importjavax.persistence.OneToMany;
13. importjavax.persistence.OrderBy;
14. importjavax.persistence.Table;
15. importjavax.persistence.Temporal;
16. importjavax.persistence.TemporalType;
17. @Entity
18. @Table(name="Orders")
19. publicclassOrderimplementsSerializable{
20. privateIntegerorderid;//订单号
21. privateFloatamount;//订单金额
22. privateSet<OrderItem>orderItems=newHashSet<OrderItem>();//订单项
23. privateDatecreatedate;//订单创建日期
24. @Id
25. @GeneratedValue
26. publicIntegergetOrderid(){
27. returnorderid;
28. }
29. publicvoidsetOrderid(Integerorderid){
30. this.orderid=orderid;
31. }
32. @Column(name="amount")//name:映射的列名,如果不指定映射列名，容器默认将属性名称作为的映射的数据库表列名。
33. publicFloatgetAmount(){
34. returnamount;
35. }
36. publicvoidsetAmount(Floatamount){
37. this.amount=amount;
38. }
39. /*
40. *@OneToMany:指明Order与OrderItem关联关系为一对多关系
41. *
42. *mappedBy:定义类之间的双向关系。如果类之间是单向关系，不需要提供定义，如果类和类之间形成双向关系，我们就需要使用这个属性进行定义，
43. *否则可能引起数据一致性的问题。
44. *
45. *cascade:CascadeType[]类型。该属性定义类和类之间的级联关系。定义的级联关系将被容器视为对当前类对象及其关联类对象采取相同的操作，
46. *而且这种关系是递归调用的。举个例子：Order和OrderItem有级联关系，那么删除Order时将同时删除它所对应的OrderItem对象。
47. *而如果OrderItem还和其他的对象之间有级联关系，那么这样的操作会一直递归执行下去。cascade的值只能从CascadeType.PERSIST（级联新建）、
48. *CascadeType.REMOVE（级联删除）、CascadeType.REFRESH（级联刷新）、CascadeType.MERGE（级联更新）中选择一个或多个。
49. *还有一个选择是使用CascadeType.ALL，表示选择全部四项。
50. *
51. *fatch:可选择项包括：FetchType.EAGER和FetchType.LAZY。前者表示关系类(本例是OrderItem类)在主类(本例是Order类)加载的时候
52. *同时加载;后者表示关系类在被访问时才加载,默认值是FetchType.LAZY。
53. *
54. */
55. @OneToMany(mappedBy="order",cascade=CascadeType.ALL,fetch=FetchType.LAZY)
56. @OrderBy(value="idASC")//注释指明加载OrderItem时按id的升序排序
57. publicSet<OrderItem>getOrderItems(){
58. returnorderItems;
59. }
60. publicvoidsetOrderItems(Set<OrderItem>orderItems){
61. this.orderItems=orderItems;
62. }
63. //@Temporal注释用来指定java.util.Date或java.util.Calendar属性与数据库类型date,time或timestamp中的那一种类型进行映射
64. @Temporal(value=TemporalType.TIMESTAMP)
65. publicDategetCreatedate(){
66. returncreatedate;
67. }
68. publicvoidsetCreatedate(Datecreatedate){
69. this.createdate=createdate;
70. }
71. /*
72. *添加订单
73. */
74. publicvoidaddOrderItem(OrderItemorderitem){
75. if(!this.orderItems.contains(orderitem)){
76. this.orderItems.add(orderitem);
77. orderitem.setOrder(this);
78. }
79. }
80. /*
81. *删除订单
82. */
83. publicvoidremoveOrderItem(OrderItemorderitem){
84. orderitem.setOrder(null);
85. this.orderItems.remove(orderitem);
86. }
87. }

OrderItem.java

Java代码

1. packagecom.entity;
2. importjava.io.Serializable;
3. importjavax.persistence.CascadeType;
4. importjavax.persistence.Column;
5. importjavax.persistence.Entity;
6. importjavax.persistence.GeneratedValue;
7. importjavax.persistence.Id;
8. importjavax.persistence.JoinColumn;
9. importjavax.persistence.ManyToOne;
10. importjavax.persistence.Table;
11. @Entity
12. @Table(name="OrderItems")//name="OrderItems"，表示本实体对应数据库表OrderItems，可选。
13. publicclassOrderItemimplementsSerializable{
14. privateIntegerid;//作为主键
15. privateStringproductname;//产品名称
16. privateFloatprice;//价格
17. privateOrderorder;//对应的订单
18. /*
19. *无参数构造器可别忘了
20. */
21. publicOrderItem(){
22. }
23. /*
24. *带参数的构造器，用于初始化实例变量
25. */
26. publicOrderItem(Stringproductname,Floatprice){
27. this.productname=productname;
28. this.price=price;
29. }
30. @Id
31. @GeneratedValue
32. publicIntegergetId(){
33. returnid;
34. }
35. publicvoidsetId(Integerid){
36. this.id=id;
37. }
38. @Column(name="productname")
39. publicStringgetProductname(){
40. returnproductname;
41. }
42. publicvoidsetProductname(Stringproductname){
43. this.productname=productname;
44. }
45. @Column(name="price")
46. publicFloatgetPrice(){
47. returnprice;
48. }
49. publicvoidsetPrice(Floatprice){
50. this.price=price;
51. }
52. /*
53. *@ManyToOne指明OrderItem和Order之间为多对一关系，多个OrderItem实例关联的都是同一个Order对象。
54. *其中的属性和@OneToMany基本一样，但@ManyToOne注释的fetch属性默认值是FetchType.EAGER。
55. *
56. *optional属性是定义该关联类对是否必须存在，值为false时，关联类双方都必须存在，如果关系被维护端不存在，查询的结果为null。
57. *值为true时,关系被维护端可以不存在，查询的结果仍然会返回关系维护端，在关系维护端中指向关系被维护端的属性为null。
58. *optional属性的默认值是true。举个例：某项订单(Order)中没有订单项(OrderItem)，如果optional属性设置为false，
59. *获取该项订单（Order）时，得到的结果为null，如果optional属性设置为true，仍然可以获取该项订单，但订单中指向订单项的属性为null。
60. *实际上在解释Order与OrderItem的关系成SQL时，optional属性指定了他们的联接关系optional=false联接关系为innerjoin,
61. *optional=true联接关系为leftjoin。
62. *
63. *@JoinColumn:指明了被维护端（OrderItem）的外键字段为order_id，它和维护端的主键(orderid)连接,unique=true指明order_id列的值不可重复。
64. */
65. @ManyToOne(cascade=CascadeType.REFRESH,optional=false)
66. @JoinColumn(name="order_id",referencedColumnName="orderid")
67. publicOrdergetOrder(){
68. returnorder;
69. }
70. publicvoidsetOrder(Orderorder){
71. this.order=order;
72. }
73. }

转自：http://lym6520.iteye.com/blog/312125