JPA一对多关联

　　关于JPA一对多关联这里使用Order与OrderItem来模拟。一个Order可以关联多个OrderItem，而一个OrderItem只能关联一个Order。Order与OrderItem是一对多的关联关系。Order类如下：

 package com.yichun.bean;

 import java.util.HashSet;

 import java.util.Set;

 import javax.persistence.CascadeType;

 import javax.persistence.Column;

 import javax.persistence.Entity;

 import javax.persistence.Id;

 import javax.persistence.OneToMany;

 import javax.persistence.Table;

 @Entity

 @Table(name = "orders")

 public class Order {

     private String orderId;

     private Float amoutn = 0f;

     private Set<OrderItem> items = new HashSet<OrderItem>();

     @Id

     @Column(length = 12, nullable = false)

     public String getOrderId() {

         return orderId;

     }

     public void setOrderId(String orderId) {

         this.orderId = orderId;

     }

     @Column(nullable = false)

     public Float getAmoutn() {

         return amoutn;

     }

     public void setAmoutn(Float amoutn) {

         this.amoutn = amoutn;

     }

     // CascadeType.REFRESH，级联刷新。orderItems更改的时候，就重新加载orderItems

     // CascadeType.PERSIST, 级联保存。insert order insert into orderitem 。调用manager.persist(new Order())的时候才会起作用

     // CascadeType.MERGE,级联更新 。order在游离状态的时候被修改了，order中的orderItem也被修改了，update order for (update orderItem)。 调用manager.merge(order) 的时候才会起作用

     // CascadeType.REMOVE级联删除。 删除order的时候，orderItems也会被删除，没有住外键约束的时候。调用manager.remove(order)的时候才会起作用。

     // 针对实体管理器的四种方法

     // fetch =FetchType.LAZY默认是延迟加载。××tomany由一方得到多的一方的时候，默认就是延迟加载，××toone的时候，默认就是立即加载

     // 出现mappedBy的类就是关系被维护端。关系由对方里面的order属性维护

     @OneToMany(cascade = { CascadeType.REFRESH, CascadeType.PERSIST,

             CascadeType.MERGE, CascadeType.REMOVE }, mappedBy = "order")

     public Set<OrderItem> getItems() {

         return items;

     }

     public void setItems(Set<OrderItem> items) {

         this.items = items;

     }

     // 建立两者之间的关系

     public void addOrderItem(OrderItem orderItem) {

         orderItem.setOrder(this);

         this.items.add(orderItem);

     }

 }

OrderItem类如下：

 package com.yichun.bean;

 import javax.persistence.CascadeType;

 import javax.persistence.Column;

 import javax.persistence.Entity;

 import javax.persistence.GeneratedValue;

 import javax.persistence.Id;

 import javax.persistence.JoinColumn;

 import javax.persistence.ManyToOne;

 @Entity

 public class OrderItem {

     private Integer id;

     private String productName;

     private Float sellPrice = 0f;

     private Order order;

     @Id

     @GeneratedValue

     public Integer getId() {

         return id;

     }

     public void setId(Integer id) {

         this.id = id;

     }

     @Column(length = 40, nullable = false)

     public String getProductName() {

         return productName;

     }

     public void setProductName(String productName) {

         this.productName = productName;

     }

     @Column(nullable = false)

     public Float getSellPrice() {

         return sellPrice;

     }

     public void setSellPrice(Float sellPrice) {

         this.sellPrice = sellPrice;

     }

     // optional=true，在数据库中允许为null

     @ManyToOne(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, optional = true)// 级联更新，级联刷新

     @JoinColumn(name = "order_id")

     public Order getOrder() {

         return order;

     }

     public void setOrder(Order order) {

         this.order = order;

     }

 }

保存数据：

     @Test

     public void save() {

         EntityManagerFactory factory = Persistence

                 .createEntityManagerFactory("testjpa");

         EntityManager manager = factory.createEntityManager();

         manager.getTransaction().begin();

         Order order = new Order();

         order.setAmoutn(120f);

         order.setOrderId("999");// UUID.randomUUID().toString()

         OrderItem item = new OrderItem();

         item.setProductName("足球");

         item.setSellPrice(90f);

         OrderItem item2 = new OrderItem();

         item2.setProductName("排球");

         item2.setSellPrice(30f);

         // 设置两者之间的关联

         order.addOrderItem(item);

         order.addOrderItem(item2);

         // 保存Order，此时也会保持OrderItem

         manager.persist(order);

         manager.getTransaction().commit();

         manager.clear();

         factory.close();

     }