jpa--9.单向多对一

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("gg@163.com");
      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("gg@163.com");
      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