JPA - 双向多对一映射

程序员文章站 2022-04-24 11:25:02

...

双向多对一关系中，必须存在一个关系维护端，在 JPA 规范中，要求 many 的一方作为关系的维护端(owner side), one 的一方作为被维护端(inverse side)。

可以在 one 方指定 @OneToMany 注释并设置 mappedBy 属性，以指定它是这一关联中的被维护端，many 为维护端。

在 many 方指定 @ManyToOne 注释，并使用 @JoinColumn 指定外键名称

【1】修改Order和Customer

Order：Customer = N:1。

Order如下：

@Table(name="JPA_ORDERS")
@Entity
public class Order {

	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来映射多对一的关联关系
	//使用@JoinColumn 来映射外键  	 	 	
	//可使用 @ManyToOne 的fetch 属性来修改默认的关联属性的加载策略
	@JoinColumn(name="CUSTOMER_ID")
//	@ManyToOne(fetch=FetchType.LAZY)
	@ManyToOne(fetch=FetchType.EAGER)
	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}

}

Customer如下：

@NamedQuery(name="testNamedQuery", query="FROM Customer c WHERE c.id = ?")
@Cacheable(true)
@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;
	
	public Customer() {
	}
	
	public Customer(String lastName, int age) {
		super();
		this.lastName = lastName;
		this.age = age;
	}



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

//	@TableGenerator(name="ID_GENERATOR",
//			table="jpa_id_generators",
//			pkColumnName="PK_NAME",
//			pkColumnValue="CUSTOMER_ID",
//			valueColumnName="PK_VALUE",
//			allocationSize=100)
//	@GeneratedValue(strategy=GenerationType.TABLE,generator="ID_GENERATOR")
	@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的关联关系
	//使用@OneToMany 映射单向1-n的关联关系
	//使用@JoinColumn 来映射外键的名称
	//可以使用@OneToMany 的 fetch 属性来修改加载策略
	//可以使用@OneToMany 的 cascade 属性来修改默认的删除策略
	@JoinColumn(name="CUSTOMER_ID")
	@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE})
	public Set<Order> getOrders() {
		return orders;
	}

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

	@Transient
	public String getInfo(){
		return "lastName: " + lastName + ", email: " + email;
	}

	@Override
	public String toString() {
		return "Customer [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", age=" + age + ", createdTime=" + createdTime
				+ ", birth=" + birth + "]";
	}

}

【2】双向多对一持久化操作

示例代码如下：

	@Test
	public void testOneToManyPersist(){
		Customer customer = new Customer();
		customer.setAge(18);
		customer.setBirth(new Date());
		customer.setCreatedTime(new Date());
		customer.setEmail("[email protected]");
		customer.setLastName("MM");
		
		Order order1 = new Order();
		order1.setOrderName("O-MM-1");
		
		Order order2 = new Order();
		order2.setOrderName("O-MM-2");
		
		//建立关联关系
		customer.getOrders().add(order1);
		customer.getOrders().add(order2);
		
		order1.setCustomer(customer);
		order2.setCustomer(customer);
		
		//执行保存操作
		entityManager.persist(customer);

		entityManager.persist(order1);
		entityManager.persist(order2);
	}

这里先保存了1的一端。

控制台输出如下：

Hibernate: 
    insert 
    into
        JPA_CUTOMERS
        (age, birth, createdTime, email, LAST_NAME) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=? 
    where
        id=?

如果先保存 n的一端呢，即先保存Order。

代码修改如下：

		entityManager.persist(order1);
		entityManager.persist(order2);

		entityManager.persist(customer);

控制台输出如下：

Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_CUTOMERS
        (age, birth, createdTime, email, LAST_NAME) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=?,
        ORDER_NAME=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=?,
        ORDER_NAME=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=? 
    where
        id=?

综上可知：

若是双向 1-n 的关联关系, 执行保存时：

若先保存 n 的一端, 再保存 1 的一端, 默认情况下, 会多出2n 条 UPDATE 语句；
若先保存 1 的一端, 则会多出 n 条 UPDATE 语句。

故在进行双向 1-n 关联关系时, 建议使用 n 的一方来维护关联关系, 而 1 的一方不维护关联系, 这样会有效的减少 SQL 语句。

即，N的一端对应的表中使用外键关联1的一端，外键对应1的一端的表主键

【3】一的一端放弃维持关联关系

修改Customer实体类如下（放弃维持关联关系）：

//	@JoinColumn(name="CUSTOMER_ID")
	@OneToMany(fetch=FetchType.EAGER,cascade={CascadeType.REMOVE},mappedBy="customer")
	public Set<Order> getOrders() {
		return orders;
	}

注意: 若在 1 的一端的 @OneToMany 中使用 mappedBy 属性, 则 @OneToMany 端就不能再使用 @JoinColumn 属性了。

先保存N的一端时控制台输出如下：

Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_CUTOMERS
        (age, birth, createdTime, email, LAST_NAME) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=?,
        ORDER_NAME=? 
    where
        id=?
Hibernate: 
    update
        JPA_ORDERS 
    set
        CUSTOMER_ID=?,
        ORDER_NAME=? 
    where
        id=?

先保存1 的一端时控制台输出如下：

Hibernate: 
    insert 
    into
        JPA_CUTOMERS
        (age, birth, createdTime, email, LAST_NAME) 
    values
        (?, ?, ?, ?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        JPA_ORDERS
        (CUSTOMER_ID, ORDER_NAME) 
    values
        (?, ?)

在一的一端放弃维持关联关系时，先插入n的一端，会多出n条update语句；先保存一的一端时只有n+1条insert语句！

综上，多对一持久化操作时，建议由一的一端放弃维持关联关系，多的一端维持关联关系。保存时先保存1的一端，这样减少SQL执行，提高效率。

JPA - 双向多对一映射

【1】修改Order和Customer

【2】双向多对一持久化操作

【3】一的一端放弃维持关联关系

java Hibernate 一对多自身关联问题

axure菜单怎么设置一对多联动效果?

绿联10000mAh双向快充移动电源拆解：多合一芯片

JPA中实现双向多对多的关联关系(附代码下载)

MyBatis从入门到精通(十一)：MyBatis高级结果映射之一对多映射

[sql]使用自连接查询多对一数据

EXCEL VLOOKUP一对多查找根据部门查找员工姓名

JPA中实现双向一对多的关联关系

JPA中实现双向一对一的关联关系

关于MyBatis 查询数据时属性中多对一的问题(多条数据对应一条数据)

JPA - 双向多对一映射

【1】修改Order和Customer

【2】双向多对一持久化操作

【3】一的一端放弃维持关联关系

java Hibernate 一对多自身关联问题

axure菜单怎么设置一对多联动效果?

绿联10000mAh双向快充移动电源拆解：多合一芯片

JPA中实现双向多对多的关联关系(附代码下载)

MyBatis从入门到精通(十一)：MyBatis高级结果映射之一对多映射

[sql]使用自连接查询多对一数据

EXCEL VLOOKUP一对多查找 根据部门查找员工姓名

JPA中实现双向一对多的关联关系

JPA中实现双向一对一的关联关系

关于MyBatis 查询数据时属性中多对一的问题(多条数据对应一条数据)

EXCEL VLOOKUP一对多查找根据部门查找员工姓名