JPA学习(八)双向一对多

╰半夏微凉° 2023-05-31 06:46 23阅读 0赞

双向一对多

# 1.双向一对多 #

## 1.双向一方的代码 以及配置 ##

@Entity
    @Table(name = "t_work")
    public class Work {
    
        @Id
        @GeneratedValue
        private Long wid;
    
        @Column(name = "w_name")
        private String wname;
    
        //配置 双向一对多  mappedBy 以及 cascade 用于级联保存
         @OneToMany(fetch = FetchType.LAZY,mappedBy = "pwork",cascade = CascadeType.PERSIST)
        //级联删除
    //    @OneToMany(fetch = FetchType.LAZY,mappedBy = "pwork",cascade = CascadeType.REMOVE)
        //删除多方外键 然后再删除一方 不影响多方数据  可以从一方解出关系的多方
        // @OneToMany(mappedBy = "pwork", orphanRemoval = true)
    //    @JoinColumn(name = "p_wid")
        //双向一对多 外键必须一样的
        private List<Person> wperson = new ArrayList<Person>();
    
    
        public Long getWid() {
            return wid;
        }
    
        public void setWid(Long wid) {
            this.wid = wid;
        }
    
        public String getWname() {
            return wname;
        }
    
        public void setWname(String wname) {
            this.wname = wname;
        }
    
        public List<Person> getWperson() {
            return wperson;
        }
    
        public void setWperson(List<Person> wperson) {
            this.wperson = wperson;
        }
    
        @Override
        public String toString() {
            return "Work{" +
                    "wid=" + wid +
                    ", wname='" + wname + '\'' +
                    '}';
        }
    }

第一个级联保存 也就是存入一个单方 多方数据就对应保存了

mappedBy ="pwork" 是用于 多方设置的一方对象名称。

可以看下面的多方的代码

## 2.多方的代码和配置 ##

@Entity
    @Table(name = "t_person")
    public class Person {
    
        @Id
        @GeneratedValue
        @Column(name = "p_id")
        private Long pid;
    
    
        @Column(name = "p_name")
        private String pname;
    
    
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "p_wid")
        //双向一对多 外键必须一样的
        private Work pwork;
    
        public Long getPid() {
            return pid;
        }
    
        public void setPid(Long pid) {
            this.pid = pid;
        }
    
        public String getPname() {
            return pname;
        }
    
        public void setPname(String pname) {
            this.pname = pname;
        }
    
        public Work getPwork() {
            return pwork;
        }
    
        public void setPwork(Work pwork) {
            this.pwork = pwork;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "pid=" + pid +
                    ", pname='" + pname + '\'' +
                    '}';
        }
    }

可以看到 多方的一方属性名称 和 一方的mappedBy是一致的

## 3.测试类 ##

public class EachTest {
    
        @Before //级联保存
        public void initTest() {
    
            EntityManager entityManager = JPAUtil.getEntityManager();
            entityManager.getTransaction().begin();
    
            Person person1 = new Person();
            person1.setPname("Person1");
    
            Person person2 = new Person();
            person2.setPname("Person2");
    
            Work work = new Work();
            work.setWname("Work1");
    
            person1.setPwork(work);
            person2.setPwork(work);
    
            //级联保存 建立双向关系
            work.getWperson().add(person1);
            work.getWperson().add(person2);
    
            //只需保存一方就可以携带多方数据存入数据库
            entityManager.persist(work);
    
            //非级联保存得用这个  级联保存就注释掉
            entityManager.persist(person1);
            entityManager.persist(person2);
    
            entityManager.getTransaction().commit();
            entityManager.close();
        }
    
        //级联删除
        @Test
        public void delete1() {
            EntityManager entityManager = JPAUtil.getEntityManager();
            entityManager.getTransaction().begin();
    
            Work work = entityManager.find(Work.class, 1L);
            entityManager.remove(work);
    
            entityManager.getTransaction().commit();
            entityManager.close();
        }
    
        @Test //删除一方 不删除多方
        public void delete2() {
            EntityManager entityManager = JPAUtil.getEntityManager();
            entityManager.getTransaction().begin();
    
            Work work = entityManager.find(Work.class, 1L);
    
            String jpql = "update Person set pwork = null where pwork.id = ?";
            Query query = entityManager.createQuery(jpql);
            //设置参数 JPA参数和jdbc的参数索引都是从1 开始 直接使用hibernatec从0开始
            //为查询语句的指定位置参数赋值。Position 指定参数序号，value 为赋给参数的值。
            query.setParameter(1, work.getWid());
            int i = query.executeUpdate();
            System.out.println("受影响行数:" + i);
    
            jpql = "delete from Work where wid = ?";
            Query query1 = entityManager.createQuery(jpql);
            query1.setParameter(1, work.getWid());
            int i1 = query1.executeUpdate();
            System.out.println("删除影响行数:" + i1);
            entityManager.getTransaction().commit();
            entityManager.close();
        }
    
        @Test //删除多方  先获取多方 再删除多方
        public void delete3() {
            EntityManager entityManager = JPAUtil.getEntityManager();
            entityManager.getTransaction().begin();
    
            Person person = entityManager.find(Person.class, 1L);
            entityManager.remove(person);
    
            entityManager.getTransaction().commit();
            entityManager.close();
        }
    
        //从一方删除 一个解出关系的多方，先获取一方，再删除一个多方
        @Test
        public void delete4() {
            EntityManager entityManager = JPAUtil.getEntityManager();
            entityManager.getTransaction().begin();
    
            //一方
            Work work = entityManager.find(Work.class, 1L);
    
            //多方
            Person person = entityManager.find(Person.class, 2L);
    
            System.out.println(work.getWperson().size());
            work.getWperson().remove(person); //脏数据  提交的时候发出delete的语句删除
    
            entityManager.getTransaction().commit();
            entityManager.close(); //游离转改
        }
    
        @Test //从一方删除所有接触关系的多方，先获取一方，再删除所有多方
        public void delete5() {
            EntityManager entityManager = JPAUtil.getEntityManager();
            entityManager.getTransaction().begin();
    
            //一方
            Work work = entityManager.find(Work.class, 1L);
            System.out.println(work.getWperson().size());
            //清理多方数据
            work.getWperson().clear(); //脏数据  提交的时候发出delete的语句删除
            //删除一方
            entityManager.remove(work);
    
            entityManager.getTransaction().commit();
            entityManager.close(); //游离转改
        }
    }

## 4.执行结果 ##

### 1.级联保存 ###

级联保存  
只留一个Persistence的方法  
必须让一方和多方关系都建立关系  
通过一方的集合存入多方的数据，并且配置一个cascade

@OneToMany(fetch = FetchType.LAZY,mappedBy = "pwork",cascade = CascadeType.PERSIST)
        private List<Person> wperson = new ArrayList<Person>();

就是当前的多方配置信息。

测试的时候 是先将一方对象work 先new出来，再将多方的person对象new出来

person对象添加work

work对象得到set集合添加work对象

最后保存一方的work对象就可以了

（参考的是initTest()方法）

![20191023140932953.png][]

### 2.删除 ###

**1.删除一方 然后 级联删除多方**  巨提莫危险操作：

配置Work的地方

WORK：//级联删除
    @OneToMany(fetch = FetchType.LAZY,mappedBy = "pwork",cascade = CascadeType.REMOVE)
    private List<Person> wperson = new ArrayList<Person>();

先将init（）方法进行修改，将多方对象也保存到数据库

![20191023141314286.png][]

参考测试的delete1()方法

![20191023141200736.png][]

这样删除的是一方的work表中的数据，也会把一方关联的多方也删除掉

**2.删除一方 不删除多方**  
把一方关联到多方外键设置为null 再删除一方  
只能使用jpql来修改完成  和 update 实现

@OneToMany(mappedBy = "pwork")      
        private List<Person> wperson = new ArrayList<Person>();

删除方法参考delete2()方法

核心地方：

Work work = entityManager.find(Work.class, 1L);
    String jpql = "update Person set pwork = null where pwork.id = ?";
               Query query = entityManager.createQuery(jpql);
               //设置参数 JPA参数和jdbc的参数索引都是从1 开始 直接使用hibernatec从0开始
               //为查询语句的指定位置参数赋值。Position 指定参数序号，value 为赋给参数的值。
               query.setParameter(1, work.getWid());
               int i = query.executeUpdate();
               System.out.println("受影响行数:" + i);
    
               jpql = "delete from Work where wid = ?";
               Query query1 = entityManager.createQuery(jpql);
               query1.setParameter(1, work.getWid());
               int i1 = query1.executeUpdate();
               System.out.println("删除影响行数:"+i1);

3.**删除多方**

先获取多方 再删除多方

参考delete3()方法，就和单独删除一个多方数据一样

Person person = entityManager.find(Person.class, 1L);
            entityManager.remove(person);

**4.从一方删除 一个解出关系的多方，先获取一方，再删除一个多方**

参考delete4()方法  orphanRemoval=true

如果orphanRemoval = true，那么这个操作会删除wpreson对象中的person属性，如果为false，则会删除他们的关系，将对peson的引用设置为null 为true 就是删除掉这个参数

@OneToMany(mappedBy = "pwork", orphanRemoval = true)//这样的话不是级联保存 需要 把work 和 person 都保存一次
        private List<Person> wperson = new ArrayList<Person>();

核心地方:

//一方
            Work work = entityManager.find(Work.class, 1L);
    
            //多方
            Person person = entityManager.find(Person.class, 2L);
    
    
            System.out.println(work.getWperson().size());
            work.getWperson().remove(person); //脏数据  提交的时候发出delete的语句删除

5.**从一方删除所有接触关系的多方**，先获取一方，再删除所有多方

@OneToMany(mappedBy = "pwork", orphanRemoval = true)//这样的话不是级联保存 需要 把work 和 person 都保存一次
        private List<Person> wperson = new ArrayList<Person>();

参考delete5() 原理和 delete4()是一致的 不过说delete是清理掉所有的数据

//一方
            Work work = entityManager.find(Work.class, 1L);
    
            //清理多方数据
            work.getWperson().clear(); //脏数据  提交的时候发出delete的语句删除
            //删除一方
            entityManager.remove(work);

# 2.注意点 #

支持级联操作 支持级联保存  
CascadeType.

ALL，  
    PERSIST,  
    MERGE,  
    REMOVE,  
    REFRESH,  
    DETACH;

一般很少配置cascade  级联操作

如果要配置 尽量配置成 级联保存  
如果配置包含级联删除的 是比较危险操作  
组合关系必须用  
**CascadeType.REMOVE, orphanRemoval = true**

[20191023140932953.png]: /images/20230531/0da151554f7d46c185d42696dc8516e9.png
[20191023141314286.png]: /images/20230531/8ab3cb2fcf0f4332a688e3f97f30a25a.png
[20191023141200736.png]: /images/20230531/a57b6be932cd4a00991ce81b017b28f4.png