首页 > 代码库 > Hibernate5--课程笔记5

Hibernate5--课程笔记5

关联关系映射:

  关联关系,是使用最多的一种关系,非常重要。在内存中反映为实体关系,映射到DB中为主外键关系实体间的关联,即对外键的维护。关联关系的发生,即对外键数据的改变。

  外键:外面的主键,即,使用其它表的主键值作为自已的某字段的取值。

  (1) 基本概念:

    关联属性:Java代码的实体类定义中,声明的另一个实例类类型或其集合类型的属性,称为关联属性。

    关联关系维护:关联关系的维护,也称为外键维护,即为外键字段赋值。Hibernate默认情况下,关联的双方都具有维护权。即在代码中均可通过调用自己关联属性的set方法来建立关联关系反映到数据库中,即是为外键字段赋值

           不过,由于外键是建立在多方表中的,所以对于外键的维护方式,即为外键字段赋值的方式,一方维护与多方维护,其底层执行是不同的
           若关联关系由一方维护,只能通过update语句来完成。若关联关系由多方维护,通过insert语句来完成。
           虽然双方均具有维护权,但一方同时具有放弃维护权的能力。通过对一方关联属性inverse=“true”设置,即可放弃关联关系维护权,将维护权完全交给多方。

    预处理语句:所谓预处理语句,即当前先不执行,等后面条件成熟,或程序运行完毕再执行的语句。

          当一方具有关联关系的维护权,并且执行save(一方对象)时会产生一条update预处理语句,用于维护外键值。当多方具有关联关系的维护权,并且执行save(多方对象)时,会产生一条insert预处理语句,用于维护外键值。

    级联关系:当对某一类的对象a进行操作,如增加、删除、修改时,同时会自动对另一类的某对象b进行相同的操作。此时称,对象a、b具有级联关系,对象b为对象a的级联对象。

         级联操作是通过映射文件的cascade属性设置的。该属性的值较多,其介绍如下:

          none:在保存、更新或删除当前对象时,忽略其他关联的对象,即不使用级联。它是默认值。
          save-update:当通过Session的save()、update()、saveOrUpdate()方法来保存或更新当前对象时,将级联到其他DB中的相关联的表。
            delete:当通过Session的delete()方法删除当前对象时,将级联删除所有关联的对象。

          all:包含save-update及delete级联的所有行为。另外,当对当前对象执行lock()操作时,也会对所有关联的持久化对象执行lock()操作。
          delete-orphan:删除所有和当前对象解除关联关系的对象。

          all-delete-orphan:包含all和delete-orphan级联的所有行为。

    关联方向:(1)单向关联:指具有关联关系的实体对象间的加载与访问关系是单向的。即,只有一个实体对象可以加载和访问对方,但对方是看不到另一方的。
         (2)双向关联 :指具有关联关系的实体对象间的加载与访问关系是双向的。即,任何一方均可加载和访问另一方。

    关联数量:实体对象间的关系,从数量上可以划分为:1:1,1:n,n:1,m:n

    总结底层执行一对多关系中,一方维护关联关系,先插入多方数据,后插入一方数据,最后update多方表中的外键值(???是否正确);多方维护关联关系,先插入一方数据,后插入多方数据,再插入多方数据的同时插入外键值;

           多对多关系中,哪一方维护关联关系,就是哪一方数据先插入,再插入关联方数据,最后插入中间表数据。

  (2) 1:n单向关联(由一方维护关联关系):

    一方实体类代码:

 1 package com.tongji.beans;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 public class Country {
 7     private Integer cid;
 8     private String cname;
 9     private Set<Minister> ministers;  //关联属性
10     
11     public Country() {
12         super();
13         ministers = new HashSet<Minister>();
14     }
15 
16     public Country(String cname) {
17         this();
18         this.cname = cname;
19     }
20 
21     public Integer getCid() {
22         return cid;
23     }
24 
25     public void setCid(Integer cid) {
26         this.cid = cid;
27     }
28 
29     public String getCname() {
30         return cname;
31     }
32 
33     public void setCname(String cname) {
34         this.cname = cname;
35     }
36 
37     public Set<Minister> getMinisters() {
38         return ministers;
39     }
40 
41     public void setMinisters(Set<Minister> ministers) {
42         this.ministers = ministers;
43     }
44 
45     @Override
46     public String toString() {
47         return "Country [cid=" + cid + ", cname=" + cname + ", ministers=" + ministers + "]";
48     }
49     
50 }

    一方映射文件代码:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5   
 6 <hibernate-mapping package="com.tongji.beans">
 7     <class name="Country">
 8         <id name="cid">
 9             <generator class="native"/>
10         </id>
11         <property name="cname"/>
12         <!-- 对关联属性的映射,inverse=true,表示一方放弃关联关系的维护权 -->
13         <set name="ministers" cascade="save-update" inverse="true">
14             <key column="countryId"/>
15             <one-to-many class="Minister"/>
16         </set>
17     </class>
18 </hibernate-mapping>

     其中,column是外键的名称

     测试代码:

 1 @Test
 2 public void test03() {
 3     //1. 获取Session
 4     Session session = HbnUtils.getSession();
 5     try {
 6         //2. 开启事务
 7         session.beginTransaction();
 8         //3. 操作
 9         Minister minsiter1 = new Minister("aaa");
10         Minister minsiter2 = new Minister("bbb");
11         Minister minsiter3 = new Minister("ccc");
12         
13         Country country = new Country("USA");
14         //关联的建立在这里完成
15         country.getMinisters().add(minsiter1);
16         country.getMinisters().add(minsiter2);
17         country.getMinisters().add(minsiter3);
18         
19         session.save(country);
20         //4. 事务提交
21         session.getTransaction().commit();
22     } catch (Exception e) {
23         e.printStackTrace();
24         //5. 事务回滚
25         session.getTransaction().rollback();
26     }
27 }

  (2) 1:n双向关联:

    一方实体类代码和一方映射文件代码同上;

    多方实体类代码:

 1 package com.tongji.beans;
 2 
 3 public class Minister {
 4     private Integer mid;
 5     private String mname;
 6     private Country country;  //关联属性
 7     
 8     public Minister() {
 9         super();
10     }
11 
12     public Minister(String mname) {
13         super();
14         this.mname = mname;
15     }
16 
17     public Integer getMid() {
18         return mid;
19     }
20 
21     public void setMid(Integer mid) {
22         this.mid = mid;
23     }
24 
25     public String getMname() {
26         return mname;
27     }
28 
29     public void setMname(String mname) {
30         this.mname = mname;
31     }
32     
33     public Country getCountry() {
34         return country;
35     }
36 
37     public void setCountry(Country country) {
38         this.country = country;
39     }
40 
41     @Override
42     public String toString() {
43         return "Minister [mid=" + mid + ", mname=" + mname + "]";
44     }
45     
46 }

    多方映射文件代码:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5   
 6 <hibernate-mapping package="com.tongji.beans">
 7     <class name="Minister">
 8         <id name="mid">
 9             <generator class="native"/>
10         </id>
11         <property name="mname"/>
12         <!-- 关联属性名 -->
13         <many-to-one name="country" cascade="save-update" 
14             class="Country" column="countryId"/>
15     </class>
16 </hibernate-mapping>

    测试代码:

 1 package com.tongji.test;
 2 
 3 import org.hibernate.Session;
 4 import org.junit.Test;
 5 
 6 import com.tongji.beans.Country;
 7 import com.tongji.beans.Minister;
 8 import com.tongji.utils.HbnUtils;
 9 
10 public class MyTest {
11     @Test
12     public void test00() {
13         //1. 获取Session
14         Session session = HbnUtils.getSession();
15         try {
16             //2. 开启事务
17             session.beginTransaction();
18             //3. 操作
19             Minister minister = new Minister("aaa");
20             
21             Country country = new Country("USA");
22             //Country方在维护关联关系
23             country.getMinisters().add(minister);
24             
25             session.save(country);
26             //4. 事务提交
27             session.getTransaction().commit();
28         } catch (Exception e) {
29             e.printStackTrace();
30             //5. 事务回滚
31             session.getTransaction().rollback();
32         }
33     }
34     
35     @Test
36     public void test01() {
37         //1. 获取Session
38         Session session = HbnUtils.getSession();
39         try {
40             //2. 开启事务
41             session.beginTransaction();
42             //3. 操作
43             Minister minister = new Minister("aaa");
44             
45             Country country = new Country("USA");
46             //Minister方在维护关联关系
47             minister.setCountry(country);
48             
49             //谁在维护关联关系,就save()谁
50             session.save(minister);
51             //4. 事务提交
52             session.getTransaction().commit();
53         } catch (Exception e) {
54             e.printStackTrace();
55             //5. 事务回滚
56             session.getTransaction().rollback();
57         }
58     }
59 }

  (3) 自关联:

    实体类代码:

 1 package com.tongji.beans;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 //新闻栏目
 7 public class NewsLabel {
 8     private Integer id;
 9     private String name;  //栏目名称
10     private String content;  //栏目内容
11     private NewsLabel parentNewsLabel;  //父栏目
12     private Set<NewsLabel> childNewsLabels;  //子栏目
13     
14     public NewsLabel() {
15         childNewsLabels = new HashSet<NewsLabel>();
16     }
17 
18     public NewsLabel(String name, String content) {
19         this();
20         this.name = name;
21         this.content = content;
22     }
23 
24     public Integer getId() {
25         return id;
26     }
27 
28     public void setId(Integer id) {
29         this.id = id;
30     }
31 
32     public String getName() {
33         return name;
34     }
35 
36     public void setName(String name) {
37         this.name = name;
38     }
39 
40     public String getContent() {
41         return content;
42     }
43 
44     public void setContent(String content) {
45         this.content = content;
46     }
47 
48     public NewsLabel getParentNewsLabel() {
49         return parentNewsLabel;
50     }
51 
52     public void setParentNewsLabel(NewsLabel parentNewsLabel) {
53         this.parentNewsLabel = parentNewsLabel;
54     }
55 
56     public Set<NewsLabel> getChildNewsLabels() {
57         return childNewsLabels;
58     }
59 
60     public void setChildNewsLabels(Set<NewsLabel> childNewsLabels) {
61         this.childNewsLabels = childNewsLabels;
62     }
63 
64     @Override
65     public String toString() {
66         return "NewsLabel [id=" + id + ", name=" + name + ", content=" + content + "]";
67     }
68     
69 }

    映射文件代码:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5   
 6 <hibernate-mapping package="com.tongji.beans">
 7     <class name="NewsLabel">
 8         <id name="id">
 9             <generator class="native"/>
10         </id>
11         <property name="name"/>
12         <property name="content"/>
13         <!-- 站在一方角度 -->
14         <set name="childNewsLabels" cascade="save-update">
15             <key column="pid"/>
16             <one-to-many class="NewsLabel"/>
17         </set>
18         <!-- 站在多方角度 -->
19         <many-to-one name="parentNewsLabel" cascade="save-update" 
20             class="NewsLabel" column="pid"/>
21     </class>
22 </hibernate-mapping>

    测试代码:

 1 package com.tongji.test;
 2 
 3 import org.hibernate.Session;
 4 import org.junit.Test;
 5 
 6 import com.tongji.beans.NewsLabel;
 7 import com.tongji.utils.HbnUtils;
 8 
 9 public class MyTest {
10     //让父方栏目维护关联关系,即一方维护
11     @Test
12     public void test00() {
13         //1. 获取Session
14         Session session = HbnUtils.getSession();
15         try {
16             //2. 开启事务
17             session.beginTransaction();
18             //3. 操作
19             NewsLabel footballNews = new NewsLabel("足球新闻","国足国足国足国足");
20             NewsLabel basketballNews = new NewsLabel("篮球新闻","登哥登哥登哥登哥");
21             
22             NewsLabel sportsNews = new NewsLabel("体育新闻","奥运奥运奥运奥运");
23             
24             sportsNews.getChildNewsLabels().add(footballNews);
25             sportsNews.getChildNewsLabels().add(basketballNews);
26             
27             session.save(sportsNews);
28             
29             //4. 事务提交
30             session.getTransaction().commit();
31         } catch (Exception e) {
32             e.printStackTrace();
33             //5. 事务回滚
34             session.getTransaction().rollback();
35         }
36     }
37     
38     //让子方栏目维护关联关系,即多方维护
39     @Test
40     public void test01() {
41         //1. 获取Session
42         Session session = HbnUtils.getSession();
43         try {
44             //2. 开启事务
45             session.beginTransaction();
46             //3. 操作
47             NewsLabel basketballNews = new NewsLabel("篮球新闻","登哥登哥登哥登哥");
48             
49             NewsLabel sportsNews = new NewsLabel("体育新闻","奥运奥运奥运奥运");
50             
51             basketballNews.setParentNewsLabel(sportsNews);
52             
53             session.save(basketballNews);
54             
55             //4. 事务提交
56             session.getTransaction().commit();
57         } catch (Exception e) {
58             e.printStackTrace();
59             //5. 事务回滚
60             session.getTransaction().rollback();
61         }
62     }
63 }

  (4) n:1单向关联(由多方来维护关联关系):

    一方实体类代码和一方映射文件代码为原来不考虑关联时候的样子,多方实体类代码和多方映射文件代码同(3)1:n双向关联,测试代码同(3)1:n双向关联的多方维护部分。

  (5)n:m单向关联:

    维护关联关系的一方的实体类代码:

 1 package com.tongji.beans;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 public class Student {
 7     private Integer sid;
 8     private String sname;
 9     private Set<Course> courses;
10     
11     public Student() {
12         courses = new HashSet<Course>();
13     }
14 
15     public Student(String sname) {
16         this();
17         this.sname = sname;
18     }
19 
20     public Integer getSid() {
21         return sid;
22     }
23 
24     public void setSid(Integer sid) {
25         this.sid = sid;
26     }
27 
28     public String getSname() {
29         return sname;
30     }
31 
32     public void setSname(String sname) {
33         this.sname = sname;
34     }
35 
36     public Set<Course> getCourses() {
37         return courses;
38     }
39 
40     public void setCourses(Set<Course> courses) {
41         this.courses = courses;
42     }
43 
44     @Override
45     public String toString() {
46         return "Student [sid=" + sid + ", sname=" + sname + "]";
47     }
48     
49 }

    维护关联关系的一方的映射文件代码:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5   
 6 <hibernate-mapping package="com.tongji.beans">
 7     <class name="Student">
 8         <id name="sid">
 9             <generator class="native"/>
10         </id>
11         <property name="sname"/>
12         <!-- 关联属性的映射 -->
13         <set name="courses" cascade="save-update" table="middle">  <!-- table指定多对多关系的中间表  -->
14             <key column="studentId"/>  <!-- 指定当前类在中间表中对应的外键 -->
15             <many-to-many class="Course" column="courseId"/>  <!-- 指定关联类在中间表中对应的外键 -->
16         </set>
17     </class>
18 </hibernate-mapping>

    测试代码:

 1 package com.tongji.test;
 2 
 3 import org.hibernate.Session;
 4 import org.junit.Test;
 5 
 6 import com.tongji.beans.Course;
 7 import com.tongji.beans.Student;
 8 import com.tongji.utils.HbnUtils;
 9 
10 public class MyTest {
11     //第一种解决方案
12     @Test
13     public void test00() {
14         //1. 获取Session
15         Session session = HbnUtils.getSession();
16         try {
17             //2. 开启事务
18             session.beginTransaction();
19             //3. 操作
20             Course course1 = new Course("Struts2");
21             Course course2 = new Course("Hibernate5");
22             Course course3 = new Course("Sring4");
23         
24             Student student1 = new Student("张三");
25             Student student2 = new Student("李四");
26             
27             student1.getCourses().add(course1);
28             student1.getCourses().add(course2);
29             
30             student2.getCourses().add(course1);
31             student2.getCourses().add(course3);
32             
33             session.save(student1);
34             session.save(student2);
35             //4. 事务提交
36             session.getTransaction().commit();
37         } catch (Exception e) {
38             e.printStackTrace();
39             //5. 事务回滚
40             session.getTransaction().rollback();
41         }
42     }
43     
44 }

   (6)n:m双向关联:

      上述另一方实体类代码:

 1 package com.tongji.beans;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 public class Course {
 7     private Integer cid;
 8     private String cname;
 9     private Set<Student> students;
10     
11     public Course() {
12         students = new HashSet<Student>();
13     }
14 
15     public Course(String cname) {
16         this();
17         this.cname = cname;
18     }
19 
20     public Integer getCid() {
21         return cid;
22     }
23 
24     public void setCid(Integer cid) {
25         this.cid = cid;
26     }
27 
28     public String getCname() {
29         return cname;
30     }
31 
32     public void setCname(String cname) {
33         this.cname = cname;
34     }
35     
36     public Set<Student> getStudents() {
37         return students;
38     }
39 
40     public void setStudents(Set<Student> students) {
41         this.students = students;
42     }
43 
44     @Override
45     public String toString() {
46         return "Course [cid=" + cid + ", cname=" + cname + "]";
47     }
48     
49 }

    上述另一方映射文件代码:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5   
 6 <hibernate-mapping package="com.tongji.beans">
 7     <class name="Course">
 8         <id name="cid">
 9             <generator class="native"/>
10         </id>
11         <property name="cname"/>
12         <!-- 关联属性映射-->
13         <set name="students" cascade="save-update" table="middle">
14             <key column="courseId"/>
15             <many-to-many class="Student" column="studentId"/>
16         </set>
17     </class>
18 </hibernate-mapping>

    测试代码:

 1 package com.tongji.test;
 2 
 3 import org.hibernate.Session;
 4 import org.junit.Test;
 5 
 6 import com.tongji.beans.Course;
 7 import com.tongji.beans.Student;
 8 import com.tongji.utils.HbnUtils;
 9 
10 public class MyTest {
11     @Test
12     public void test00() {
13         //1. 获取Session
14         Session session = HbnUtils.getSession();
15         try {
16             //2. 开启事务
17             session.beginTransaction();
18             //3. 操作
19             Course course1 = new Course("Struts2");
20             Course course2 = new Course("Hibernate5");
21             Course course3 = new Course("Sring4");
22         
23             Student student1 = new Student("张三");
24             Student student2 = new Student("李四");
25             
26             student1.getCourses().add(course1);
27             student1.getCourses().add(course2);
28             
29             student2.getCourses().add(course1);
30             student2.getCourses().add(course3);
31             
32             session.save(student1);
33             session.save(student2);
34             //4. 事务提交
35             session.getTransaction().commit();
36         } catch (Exception e) {
37             e.printStackTrace();
38             //5. 事务回滚
39             session.getTransaction().rollback();
40         }
41     }
42     
43     @Test
44     public void test01() {
45         //1. 获取Session
46         Session session = HbnUtils.getSession();
47         try {
48             //2. 开启事务
49             session.beginTransaction();
50             //3. 操作
51             Course course1 = new Course("Struts2");
52             Course course2 = new Course("Hibernate5");
53             Course course3 = new Course("Sring4");
54         
55             Student student1 = new Student("张三");
56             Student student2 = new Student("李四");
57             
58             course1.getStudents().add(student1);
59             course1.getStudents().add(student2);
60             
61             course2.getStudents().add(student2);
62             
63             course3.getStudents().add(student1);
64             
65             session.save(course1);
66             session.save(course2);
67             session.save(course3);
68             //4. 事务提交
69             session.getTransaction().commit();
70         } catch (Exception e) {
71             e.printStackTrace();
72             //5. 事务回滚
73             session.getTransaction().rollback();
74         }
75     }
76     
77 }

Hibernate5--课程笔记5