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

左手的ㄟ右手 2022-08-04 00:59 189阅读 0赞

# 多对一关联关系 #

两个实体类，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表

![这里写图片描述][20150814192332312]

JPA建的T\_USER表

![这里写图片描述][20150814192408317]

JPA帮我们建立关联关系

![这里写图片描述][20150814192236940]

测试一下：

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语句，这是毋庸置疑的。

![这里写图片描述][20150814192955047]

但是有两个问题：

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);

结果

![这里写图片描述][20150814193238526]

结论：如果先插入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());

![这里写图片描述][20150814194255283]

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

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

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

运行结果：

![这里写图片描述][20150814194501168]

使用懒加载，你会发现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操作，再提交事务时，将会自动更新到数据库

[20150814192332312]: /images/20220731/b329590740a74c1ea287dc90264c004f.png
[20150814192408317]: /images/20220731/3cebfdbaf6f942febfbb8820e31f9e80.png
[20150814192236940]: /images/20220731/40443922a46148ff9000f55483375197.png
[20150814192955047]: /images/20220731/ba31bd38201e4c669d4da6f614e27b6d.png
[20150814193238526]: /images/20220731/f14f35e82b1d41c98b4955e68377df8a.png
[20150814194255283]: /images/20220731/6daff40c7d9b458eb7fcc5e755bcb55b.png
[20150814194501168]: /images/20220731/9fadc0e1628443818c1073664b9bcc20.png