jpa--10.单向一对多

最新推荐文章于 2024-04-26 08:00:00 发布

原创最新推荐文章于 2024-04-26 08:00:00 发布 · 818 阅读

1 ·

CC 4.0 BY-SA版权

本文介绍Java Persistence API (JPA)中实现单向一对多关联的方式，包括配置、数据模型定义、基本操作如保存、查询、更新及删除等，并提供示例代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1 单向一对多

1.1 概念

只有一方维护

1.2 配置

一个订单只有一个用户，一个用户多个订单

使用 @ManyToOne 来映射多对一的关联关系， fetch 属性来修改默认的关联属性的加载策略

使用 @JoinColumn 来映射外键.

@JoinColumn(name="CUSTOMER_ID")

@OneToMany

1.3 数据生成信息

Order表会产生外键

1.4 测试准备

1.4.1 Customer

@Table(name="JPA_CUTOMERS")
@Entity
public class Customer {

	private Integer id;
	private String lastName;

	private String email;
	private int age;

	private Date createdTime;
	private Date birth;

	private Set<Order> orders = new HashSet<>();

	@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-n 的关联关系
	//	1.使用 @OneToMany 来映射 1-n 的关联关系;使用 @JoinColumn 来映射外键列的名称
	//	2.可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略
	//	3.可以通过 @OneToMany 的 cascade 属性来修改默认的删除策略. 
	//注意: 若在 1 的一端的 @OneToMany 中使用 mappedBy 属性, 则 @OneToMany 端就不能再使用 @JoinColumn 属性了. 
	@JoinColumn(name="CUSTOMER_ID")
	//	@OneToMany
//	@OneToMany(fetch=FetchType.EAGER)
	@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})
	public Set<Order> getOrders() {
		return orders;
	}

	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}

}

1.4.2 Order

@Table(name="JPA_ORDERS")
@Entity
public classOrder {
 
   private Integer id;
   private String orderName;
 
   @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;
   }
 
}

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语句

//单向 1-n 关联关系执行保存时, 一定会多出 UPDATE 语句.
   //因为 n 的一端在插入时不会同时插入外键列.
   @Test
   public void testOneToManyPersist(){
      Customercustomer= newCustomer();
      customer.setAge(18);
      customer.setBirth(new Date());
      customer.setCreatedTime(new Date());
      customer.setEmail("mm@163.com");
      customer.setLastName("MM");
     
      Orderorder1= newOrder();
      order1.setOrderName("O-MM-1");
     
      Orderorder2= newOrder();
      order2.setOrderName("O-MM-2");
     
      //建立关联关系
      customer.getOrders().add(order1);
      customer.getOrders().add(order2);
     
      //执行保存操作
      entityManager.persist(customer);
 
      entityManager.persist(order1);
      entityManager.persist(order2);
   }

2.2 查询（oid）

2.2.1 默认懒加载

查询一方；懒加载：当调用时，才发送查询sql语句

//默认对关联的多的一方使用懒加载的加载策略.
   //可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略
   @Test
   public void testOneToManyFind(){
      Customercustomer= entityManager.find(Customer.class, 3);
      System.out.println(customer.getLastName());
 
      System.out.println(customer.getOrders().size());
   }

2.2.2 正常加载（EAGER）

2.可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略

2.3 删除（一方）

2.3.1 外键置空，只删一方

//默认情况下, 若删除 1 的一端, 则会先把关联的 n 的一端的外键置空, 然后进行删除.
   //可以通过 @OneToMany 的 cascade 属性来修改默认的删除策略.
   @Test
   public void testOneToManyRemove(){
      Customercustomer= entityManager.find(Customer.class, 8);
      entityManager.remove(customer);
   }

2.3.2 外键置空，都删

//可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略

@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})

2.4 更新

只要是针对一方，多方就直接单表了

@Test
   public void testUpdate(){
      Customercustomer= entityManager.find(Customer.class, 3);
     
      customer.getOrders().iterator().next().setOrderName("O-XXX-10");
   }