传智播客jpa详解视频教程（七）：JPA中的一对多双向关联与级联操作、延迟加载与关系维护

以“订单Order 1:N 订单项OrderItem”为例：

//在JPA中，如果是双向1:N的关系，则N的一方为关系维护端
//关系维护端负责外键记录的更新，关系被维护端是没有权利更新外键记录的
‍//例如只能通过订单项(OrderItem)来修改所属的订单(Order)，而不能通过订单来修改订单项所属的订单
//N一边的默认加载方式为延迟加载，1一边的默认加载方式为立即加载

Order.java：

package cn.itcast.bean;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="orders")
public class Order {
private String orderid;
private Float amount = 0f;
private Set<OrderItem> items = new HashSet<OrderItem>();

@Id
@Column(length=12)
public String getOrderid() {
   return orderid;
}
public void setOrderid(String orderid) {
   this.orderid = orderid;
}

@Column(nullable=false)
public Float getAmount() {
   return amount;
}
public void setAmount(Float amount) {
   this.amount = amount;
}

//1:N的关系用注解：@OneToMany
//CascadeType.PERSIST: insert Order 时，自动 insert OrderItem
//CascadeType.MERGE：当Order对象处于游离状态时，修改 Order 时，自动修改 OrderItem
//级联条件：只有在调用Merge方法时CascadeType.MERGE才起作用，只有在调用Remove方法时，CascadeType.REMOVE才起作用，其他方法以此类推
@OneToMany(cascade={CascadeType.REFRESH, CascadeType.PERSIST, CascadeType.MERGE},
    fetch=FetchType.LAZY, //Many端默认为LAZY
    mappedBy="order") //有mappedBy的是被维护端，指定关联的属性，此处指名Order通过“order”属性与OrderItem关联
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.java：

package cn.itcast.bean;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
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;
}

@ManyToOne(cascade={CascadeType.MERGE, CascadeType.REFRESH },
    fetch=FetchType.EAGER, //One端默认为EAGER
    optional=false //是否可选
    )
@JoinColumn(name="order_id") // 定义外键
public Order getOrder() {
   return order;
}
public void setOrder(Order order) {
   this.order = order;
}
}

ManyToOneTest.java：

package cn.itcast.bean;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.junit.Test;

public class OneToManyTest {
@Test
public void save() {
   EntityManagerFactory factory = Persistence
     .createEntityManagerFactory("itcast");
   EntityManager em = factory.createEntityManager();

   em.getTransaction().begin(); // 开始事务
   Order order = new Order();
   order.setAmount(34f);
   order.setOrderid("999"); //UUID.randomUUID().toString()
  
   OrderItem orderItem1 = new OrderItem();
   orderItem1.setProductName("足球");
   orderItem1.setSellPrice(90f);

   OrderItem orderItem2 = new OrderItem();
   orderItem2.setProductName("篮球");
   orderItem2.setSellPrice(30f);

   order.addOrderItem(orderItem1);
   order.addOrderItem(orderItem2);
  
   em.persist(order);
   em.getTransaction().commit();

   em.close();
   factory.close();
}

}