JPA学习笔记(8)——映射双向一对多关联关系
双向一对多关联关系
前面的博客讲的都是单向的,而本问讲的是双向的(双向一对多 = 双向多对一)
什么是双向?
我们来对照一下单向和双向
单向/双向 | User实体类中是否有List< Order> orders | Order实体类中是否有User user |
---|---|---|
单向多对一 | 无 | 有 |
单向一对多 | 有 | 无 |
双向一对多(双向多对一) | 有 | 有 |
怎么构建关系
User实体类
package com.jpa.helloworld2;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Table(name="T_USER")
@Entity
public class User {
@Column(name="ID")
@GeneratedValue(strategy=GenerationType.AUTO)
@Id
private Integer id;
@Column(name="NAME")
private String name;
@JoinColumn(name="USER_ID")
@OneToMany
private List<Order> orders = new ArrayList<>();
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Order> getOrders() {
return orders;
}
public void setOrders(List<Order> orders) {
this.orders = orders;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", orders=" + orders + "]";
}
}
Order实体类
package com.jpa.helloworld2;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.TableGenerator;
@Table(name="T_ORDER")
@Entity
public class Order {
@Column(name="ID")
@GeneratedValue
@Id
private Integer id;
@Column(name="ORDER_NAME")
private String orderName;
@JoinColumn(name="USER_ID")
@ManyToOne
private User user;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Override
public String toString() {
return "Order [id=" + id + ", orderName=" + orderName + ", user="
+ user + "]";
}
}
注意,两个实体类中的@JoinColumn(name=”USER_ID”) 值要一致
插入
Order order1 = new Order();
order1.setOrderName("o1");
Order order2 = new Order();
order2.setOrderName("o2");
User user = new User();
user.setName("tom");
user.getOrders().add(order1);
user.getOrders().add(order2);
order1.setUser(user);
order2.setUser(user);
entityManager.persist(user);
entityManager.persist(order1);
entityManager.persist(order2);
注意:既要把user放到order中。也要把order加到user中
结果
看截图,你会发现有两次的udpate操作,这是由于要维护关联关系。
假设你先插入两个order,在插入user,将会发现有四次的update操作。这会影响效率。
要怎么解决呢?
在这种一对多的情况下,我们能够指明由“一”的一方来维护关联关系:在User实体类中
@OneToMany(mappedBy="user")
private List<Order> orders = new ArrayList<>();
注意:使用了mappedBy之后,就不能使用@JoinColumn注解,否则抛异常
再次运行插入操作,发现没有再多出update操作了
总结:在一对多和多对一的情况下,插入操作要先插入“一”的对象。再插入“多”的对象。这样能够降低sql语句。假设是双向的,要使用mappedBy指明由“多”的一方(Order)中的user来维护关联关系
查询
User u = entityManager.find(User.class, 3);
System.out.println(u.getName());
System.out.println(u.getOrders().get(0).getOrderName());
这段代码查询没问题,可是假设这样写:
User u = entityManager.find(User.class, 3);
System.out.println(u);
会出现这种结果:
这是由于我的User类和Order类都重写了toString()方法。
打印一个对象事实上就是调用它的toString()方法。而User中有orders,Order中有user。互相调来调去。导致无限死循环下去。因此出现了栈溢出的异常