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();
     }