1      單向多對一

1.1  概念

只有一方維護

1.2  配置

一個訂單隻有一個使用者，一個使用者多個訂單

   使用 @ManyToOne來對映多對一的關聯關係， fetch屬性來修改預設的關聯屬性的載入策略

   使用 @JoinColumn來對映外來鍵.

   @JoinColumn(name="CUSTOMER_ID")

   @ManyToOne(fetch=FetchType.LAZY)

1.3  資料生成資訊

Order表會產生外來鍵

1.4  測試準備

1.4.1  Customer

@Table(name="JPA_CUTOMERS")
@Entity
public classCustomer {
  
   private Integer id;
   private String lastName;
 
   private String email;
   private int age;
  
   private Date createdTime;
   private Date birth;
  
   @GeneratedValue(strategy=GenerationType.AUTO)
   @Id
   public Integer getId() {
      return id;
   }
   public void setId(Integer id) {
      this.id = id;
   }
  
   @Column(name = "last_name",length = 50, nullable = false)
   public String getLastName() {
      return lastName;
   }
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }
   public String getEmail() {
      return email;
   }
   public void setEmail(String email) {
      this.email = email;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
  
   @Temporal(TemporalType.TIMESTAMP)
   public Date getCreatedTime() {
      return createdTime;
   }
   public void setCreatedTime(Date createdTime) {
      this.createdTime = createdTime;
   }
   @Temporal(TemporalType.DATE)
   public Date getBirth() {
      return birth;
   }
   public void setBirth(Date birth) {
      this.birth = birth;
   }
}
 

1.4.2  Order

@Table(name="JPA_ORDERS")
@Entity
public classOrder {
 
   private Integer id;
   private String orderName;
 
   private Customer customer;
 
   @GeneratedValue
   @Id
   public Integer getId() {
      return id;
   }
 
   public void setId(Integer id) {
      this.id = id;
   }
 
   @Column(name="ORDER_NAME")
   public String getOrderName() {
      return orderName;
   }
 
   public void setOrderName(String orderName) {
      this.orderName = orderName;
   }
 
   //對映單向 n-1 的關聯關係
   //使用 @ManyToOne 來對映多對一的關聯關係， fetch 屬性來修改預設的關聯屬性的載入策略
   //使用 @JoinColumn來對映外來鍵.
   @JoinColumn(name="CUSTOMER_ID")
   @ManyToOne(fetch=FetchType.LAZY)
   public Customer getCustomer(){
      return customer;
   }
 
   public void setCustomer(Customer customer) {
      this.customer = customer;
   }
 
} 
 

1.4.3  準備JPATest

public classJPATest {
 
   private EntityManagerFactory entityManagerFactory;
   private EntityManager entityManager;
   private EntityTransaction transaction;
  
   @Before
   public void init(){
      entityManagerFactory= Persistence.createEntityManagerFactory("jpa_test1");
      entityManager = entityManagerFactory.createEntityManager();
      transaction = entityManager.getTransaction();
      transaction.begin();
   }
  
   @After
   public void destroy(){
      transaction.commit();
      entityManager.close();
      entityManagerFactory.close();
   }
  
}
 

2      操作

2.1  儲存

建議先儲存一的一方，再儲存多的一方，就不會出現update語句

2.1.1  測試先多再一

先儲存一的一端，再儲存多的一端

/**
    * 儲存多對一時, 建議先儲存 1 的一端, 後儲存 n 的一端, 這樣不會多出額外的 UPDATE 語句.
    */
   @Test
   public void testManyToOnePersist(){
      Customercustomer= newCustomer();
      customer.setAge(18);
      customer.setBirth(new Date());
      customer.setCreatedTime(new Date());
      customer.setEmail("[email protected]");
      customer.setLastName("GG");
     
      Orderorder1= newOrder();
      order1.setOrderName("G-GG-1");
      Orderorder2= newOrder();
      order2.setOrderName("G-GG-2");
     
      //設定關聯關係
      order1.setCustomer(customer);
      order2.setCustomer(customer);
     
      //執行儲存操作
      entityManager.persist(order1);
      entityManager.persist(order2);
     
      entityManager.persist(customer);
   }

2.1.2  測試先一再多

/**
    * 儲存多對一時, 建議先儲存 1 的一端, 後儲存 n 的一端, 這樣不會多出額外的 UPDATE 語句.
    */
   @Test
   public void testManyToOnePersist2(){
      Customercustomer= newCustomer();
      customer.setAge(18);
      customer.setBirth(new Date());
      customer.setCreatedTime(new Date());
      customer.setEmail("[email protected]");
      customer.setLastName("GG");
     
      Orderorder1= newOrder();
      order1.setOrderName("G-GG-1");
      Orderorder2= newOrder();
      order2.setOrderName("G-GG-2");
     
      //設定關聯關係
      order1.setCustomer(customer);
      order2.setCustomer(customer);
     
      //執行儲存操作(先一再多)
      entityManager.persist(customer);
     
      entityManager.persist(order1);
      entityManager.persist(order2);
     
   }

2.2  查詢（oid）

2.2.1  預設載入

查詢多方

//預設情況下, 使用左外連線的方式來獲取 n 的一端的物件和其關聯的 1 的一端的物件.
   //可使用 @ManyToOne 的 fetch 屬性來修改預設的關聯屬性的載入策略
   @Test
   public void testManyToOneFind(){
      Orderorder= entityManager.find(Order.class, 1);
      System.out.println(order.getOrderName());
 
      System.out.println(order.getCustomer().getLastName());
   }

2.2.2  懶載入

懶載入：當呼叫時，才傳送查詢sql語句

2.3  刪除（多方）

只能刪除多的一方

 //不能直接刪除 1 的一端, 因為有外來鍵約束.
   @Test
   public void testManyToOneRemove(){
 
      Orderorder= entityManager.find(Order.class, 1);
      entityManager.remove(order);
     
//    不能刪除1的一方
//    Customercustomer = entityManager.find(Customer.class, 1);
//    entityManager.remove(customer);
   }

2.4  更新

只要是針對多方，一方就直接單表了

@Test

   public void testManyToOneUpdate(){

      Orderorder= entityManager.find(Order.class, 2);

      order.getCustomer().setLastName("FFF");

   }

原始碼：https://download.csdn.net/download/qq_26553781/10320230