JPA学习笔记（7）——映射多对一关联关系

多对一关联关系

两个实体类，User和Order，一个User可以有多个Order，一个Order只能有一个User

建立关联关系

使用@ManyToOne注解映射多对一关联关系

User实体类

package com.jpa.helloworld;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
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;

    @Column(name="EMAIL")
    private String email;


    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 String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", email=" + email + "]";
    }


}

Order实体类

package com.jpa.helloworld;

import javax.persistence.Column;
import javax.persistence.Entity;
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")//关联user表的字段
    @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 + "]";
    }


}

JPA建的T_ORDER表

JPA建的T_USER表

JPA帮我们建立关联关系

测试一下：

User user = new User();
user.setName("tom");
user.setEmail("tom@qq.com");

Order order1 = new Order();
order1.setOrderName("o1");
order1.setUser(user);

Order order2 = new Order();
order2.setOrderName("o2");
order2.setUser(user);
//插入
entityManager.persist(user);
entityManager.persist(order1);
entityManager.persist(order2);

运行以上代码，将会执行三个insert语句，这是毋庸置疑的。

但是有两个问题：

1. 插入order1和order2时，它如何知道user的id？我们并没有将插入的user查询出来啊。

   设了断点后发现，在执行entityManager.persist(user); 之后，user的id就有值了，相当于从数据库查询出来了。

2. 如果先插入order，再插入user会怎么样？

   按照正常的逻辑，应该会由于插入order时找不到外键关联的user而报错或者置为空，我们来验证一下。

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

结果

结论：如果先插入order，它的USER_ID字段会先为空，在插入user之后，再进行update操作，USER_ID。因此，在多对一映射关系的情况下，建议先插入“一”的对象（user），再插入“多”的对象（order），减少sql语句可以提高效率

关联关系的查询

Order order = entityManager.find(Order.class, 1);
System.out.println("ordername:"+order.getOrderName());

System.out.println("user:"+order.getUser());

很简单，建立关联关系后，会自动关联查询。

现在改造一下Order实体类，在@ManyToOne注解后面加上fetch属性来修改加载策略

//映射多对一的关联关系
@JoinColumn(name="USER_ID")
@ManyToOne(fetch=FetchType.LAZY)
private User user;

运行结果：

使用懒加载，你会发现JPA先单表查询Order，然后打印order信息。然后要打印user时，它才又执行了一次查询语句去查询user。也就是，如果你没有使用到user，它就不会查询user

删除

可以删除order

Order order = entityManager.find(Order.class, 1);
entityManager.remove(order);

如果删除User，将会因为外键关系而无法删除，除非先把使用这个user的order删掉

User user = entityManager.find(User.class, 1);
entityManager.remove(user);

更新

Order order = entityManager.find(Order.class, 3);
order.getUser().setName("my user name");

使用find查询出来后，不需要执行update操作，再提交事务时，将会自动更新到数据库