Hibernate关联关系配置

蔚落 2022-03-01 13:54 349阅读 0赞

1.单向多对一配置
基础配置

  1. <!-- Database connection settings -->
  2.         <property name="connection.driver_class">oracle.jdbc.driver.jdbcDriver</property>
  3.         <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
  4.         <property name="connection.username">scott</property>
  5.         <property name="connection.password">tiger</property>
  7.         <!-- SQL dialect -->
  8.         <property name="dialect">org.hibernate.dialect.OracleDialect</property>
  9.         <!-- Echo all executed SQL to stdout -->
  10.         <property name="format_sql">true</property>
  11.         <property name="show_sql">true</property>
  12.         <!-- Drop and re-create the database schema on startup -->
  13.         <property name="hbm2ddl.auto">update</property>
  15.         <mapping name="hbm/Student.hbm.xml"></mapping>
  16.         <mapping name="hbm/Teacher.hbm.xml"></mapping>

One 配置对象

  1. clas Student
  2.     private int sid;
  3.     private String sname;
  4.     private Teacher teacher;

Many

  1. class Student
  2.     private int tid;
  3.     private String tname;
  4.     private Student student;

Mapping配置文件

many:

  1. <!-- 参考文档 《Hibernate Reference Documentation》 for 3.5.6-Final -->
  2. <hibernate-mapping package="com.hxzy.manyone">
  4.     <!-- 类名 -->
  5.     <class name="com.hxzy.manytoone.entity.Teacher" table="teacher">
  7.         <!-- 生成id主键 -->
  8.         <id name="tid" column="tid">
  9.             <generator class="sequence"><!-- 生成序列 -->
  10.                 <param name="sequence">
  11.                     seq_teacher
  12.                 </param>
  13.             </generator>
  14.         </id>
  16.         <!-- 属性name -->
  17.         <property name="name" not-null="true"></property>
  19.         <many-to-one name="Student" class="com.hxzy.manytoone.entity.Student" column="s_id" cascade="save-update">
  20.         </many-to-one>
  21.         <!-- column（可选）：外键字段的名称。也可以通过嵌套的 <column> 指定 -->
  22.         <!-- class（可选 — 默认是通过反射得到的属性类型）：被关联的类的名字。 -->
  23.         <!--cascade（级联）（可选）表明操作是否从父对象级联到被关联的对象 -->
  24.     </class>
  25. </hibernate-mapping>

one:

  1. <hibernate-mapping package="com.hxzy.manyone">
  2.     <class name="com.hxzy.manytoone.entity.Student" table="student">
  3.         <id name="sid" column="sid">
  4.             <generator class="sequence">
  5.                 <param name="sequence">
  6.                     seq_student
  7.                 </param>
  8.             </generator>
  9.         </id>
  10.         <property name="name" not-null="true"></property>
  11.     </class>
  12. </hibernate-mapping>

dao层

  1. Session session = null;
  3.     /**
  4.      * 获取session
  5.      * */
  6.     public Session getSession() {
  7.         Configuration cfg = new Configuration().configure();
  8.         SessionFactory sessionFactory= cfg.buildSessionFactory();
  9.         Session session = sessionFactory.openSession();
  10.         return session;
  11.     }
  13.     public void addTeacher(Teacher teacher) {
  14.         session = getSession();
  15.         Transaction ts = session.beginTransaction();
  16.         try {
  17.             session.save(teacher);//存入老湿信息
  18.             ts.commit();//提交事务
  19.         }catch(Exception e) {
  20.             e.printStackTrace();
  21.             ts.rollback();//报错则回滚
  22.         }finally {
  23.             session.close();
  24.         }
  25.     }
  26.     测试代码
  28. @Test
  29.     public void test1() {
  30.         DaoImpl daoImpl = new DaoImpl();
  31.         Teacher t1 = new Teacher();
  32.         Teacher t2 = new Teacher();
  33.         Student s1 = new Student();
  34.         s1.setSname("gz1");
  35.         t1.setTname("gt1");
  36.         t1.setStudent(s1);
  37.         t2.setTname("gt2");
  38.         t2.setStudent(s1);
  39.         daoImpl.addObject(s1);
  40.         daoImpl.addObject(t1);
  41.         daoImpl.addObject(t2);
  42.     }

创建的库
百度百度百度
百度百度百度
百度百度百度
框架在数据库中的操作
create table Teacher(Id bigint not null primary key,sid bigint not null )//在teacher中创建主键tid，外键sid并和student中的sid关联
create table Student ( sid bigint not null primary key )//创建sid主键
2.单向一对一配置
基于外键关联的单向一对一关联和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关
联中的外键字段具有唯一性约束。
xml中其他不变仅在多对一节点添加unique=“true”

  1. <!-- 单向一对一关联 -->
  2.         <many-to-one name="student"
  3.             class="com.hxzy.manyone.entity.Student" unique="true"
  4.             column="stu_id" not-null="true" />

3.基于外键关联的单向一对多关联是一种很少见的情况，并不推荐使用。
对于这种关联关系最好使用连接表。

4.使用连接表的一对多
基于连接表的单向一对多关联 应该优先被采用。请注意，通过指定unique=“true”，我们可以把多
样性从多对多改变为一对多。

  1. <!--many-->
  2. student：
  3. <class name="com.hxzy.manymany.entity.Student" table="student">
  4.         <id name="sid" column="sid">
  5.             <generator class="sequence">
  6.                 <param name="seuqence">seq_student</param>
  7.             </generator>
  8.         </id>
  9.         <property name="sname" not-null="true"></property>
  10.     </class>
  12.     <!-- one-->
  13.     teacher：
  14.     <!-- 类，id，name -->
  15.     <class name="com.hxzy.manymany.entity.Teacher" table="teacher">
  16.         <id name="tid" column="tid">
  17.             <generator class="sequence">
  18.                 <param name="sequence">seq_teacher</param>
  19.             </generator>
  20.         </id>
  21.         <property name="tname" not-null="true"></property>
  23.         <!-- 基于连接表的单向一对多 -->
  24.         <set name="set" table="teacher_student"><!-- 新表-->
  25.             <key column="tid" />
  26.             <many-to-many column="sid" unique="true"
  27.                 class="com.hxzy.manymany.entity.Student" />
  28.         </set>
  29.     </class>

teacher类：

  1. private int tid;
  2.     private String tname;
  3.     private Set<Student> set = new HashSet<Student>();

student类

  1. private int sid;
  2.     private String sname;
  3.     private Teacher teacher;

test：

  1. @Test
  2.     public void test1() {
  3.         DaoImpl daoImpl = new DaoImpl();
  4.         Teacher t1 = new Teacher();
  5.         Set<Student> set = new HashSet<Student>();
  6.         Student s1 = new Student();
  7.         Student s2 = new Student();
  8.         s1.setSname("gz1");
  9.         s2.setSname("gz2");
  10.         set.add(s1);
  11.         set.add(s2);
  12.         t1.setTname("gt1");
  13.         t1.setSet(set); 
  14.         daoImpl.addObject(s1);
  15.         daoImpl.addObject(s2);
  16.         daoImpl.addObject(t1);
  17.     }

最终形成的数据库结构
百度百度百度述百度百度百度
百度百度百度
百度百度百度
可以看到，（tid，sid）作为连接表的主键，sid和tid为连接表的外键，从而将student的主键sid化作了teacher的外键

.多对多
单向多对多

  1. <!-- 类名 -->
  2.     <class name="com.hxzy.manyone.entity.Teacher" table="teacher">
  4.         <!-- 生成id主键 -->
  5.         <id name="id" column="id">
  6.             <generator class="sequence">
  7.                 <!-- 生成序列 -->
  8.                 <param name="sequence">
  9.                     seq_teacher
  10.                 </param>
  11.             </generator>
  12.         </id>
  14.         <!-- 属性name -->
  15.         <property name="name" not-null="true"></property>
  17.         <!--生成新表，将id中stu_id关联 -->
  18.         <set name="Student" table="teacher_sutdent">
  19.             <key column="id" />
  20.             <many-to-many column="stu_id"
  21.                 class="com.hxzy.manyone.entity.Student" />
  22.         </set>
  23.     </class>

测试代码

  1. @Test
  2.     public void Test1() {
  3.         DaoImpl daoImpl = new DaoImpl();
  4.         Student student1 = new Student();
  5.         Student student2 = new Student();
  6.         Teacher teacher1 = new Teacher();
  7. //        Teacher teacher2 = new Teacher();
  8.         Set<Student> set1 = new HashSet<Student>();
  9.         student1.setName("a");
  10.         student2.setName("b");
  11.         teacher1.setName("gz");
  12.     //    teacher2.setName("gz1");
  13.         set1.add(student1);
  14.         set1.add(student2);
  15.         teacher1.setSet(set1);
  16.         daoImpl.addObject(student1);
  17.         daoImpl.addObject(student2);
  18.         daoImpl.addObject(teacher1);
  19.     //    daoImpl.addTeacher(teacher2);

效果如下
生成一个新表t_s，其主键为stu_id，外键为（id（来自teacher）,stu_id），与student中的外键stu_id关联,与teacher中的外键stu_id关联
百度百度百度
百度百度百度
teacher表
百度百度百度
百度百度百度
student表
百度百度百度
百度百度百度
5.双向关联
双向多对一关联 是最常见的关联关系

  1. <class name="com.hxzy.manymany.entity.Teacher" table="teacher">
  2.         <id name="tid" column="tid">
  3.             <generator class="sequence">
  4.                 <param name="sequence">seq_teacher</param>
  5.             </generator>
  6.         </id>
  7.         <property name="tname" not-null="true"></property>
  9.         <!-- 基于外键的双向多对一 many -->
  10.         <many-to-one name="student"
  11.             class="com.hxzy.manymany.entity.Student" column="sid"
  12.             cascade="save-update" />
  14. </class>
  16. <class name="com.hxzy.manymany.entity.Student" table="student">
  17.         <id name="sid" column="sid">
  18.             <generator class="sequence">
  19.                 <param name="seuqence">seq_student</param>
  20.             </generator>
  21.         </id>
  22.         <property name="sname" not-null="true"></property>
  24.         <!-- 基于外键的双向多对一 :one -->
  25.         <set name="set" inverse="true">
  26.             <key column="sid" />
  27.             <one-to-many class="com.hxzy.manymany.entity.Teacher" />
  28.         </set>
  30. </class>

Class Many:

  1. public class Teacher {
  2.     private int tid;
  3.     private String tname;
  4.     private Student student;

Class One:

  1. public class Student {
  2.     private int sid;
  3.     private String sname;
  4.     Set<Teacher> set = new HashSet<Teacher>();

Test:

  1. public class Test1 {
  2.     @Test
  3.     public void test1() {
  4.         DaoImpl daoImpl = new DaoImpl();
  5.         Teacher t1 = new Teacher();
  6.         Teacher t2 = new Teacher();
  7.         Set<Teacher> set1 = new HashSet<Teacher>();
  8.         Student s1 = new Student();
  9.         t1.setTname("gt1");
  10.         t2.setTname("gt2");
  11.         set1.add(t1);
  12.         set1.add(t2);
  13.         s1.setSname("gz1");
  14.         s1.setSet(set1);
  15.         daoImpl.addObject(t1);
  16.         daoImpl.addObject(t2);
  17.         daoImpl.addObject(s1);    
  18.     }
  19. }

生成的数据库结构
百度百度百度
百度百度百度
双向一对一关联基于外键关联也很常见

  1. teacher：
  2. <class name="com.hxzy.manymany.entity.Teacher" table="teacher">
  4.         <id name="tid" column="tid">
  5.             <generator class="sequence">
  6.                 <param name="sequence">seq_teacher</param>
  7.             </generator>
  8.         </id>
  9.         <property name="tname" not-null="true"></property>
  11.         <!-- 基于外键关联的双向一对一关联 -->
  12.         <many-to-one name="student" column="sid"
  13.             class="com.hxzy.manymany.entity.Student" unique="true"
  14.             not-null="true" />
  15.     </class>
  17. student:
  18. <class name="com.hxzy.manymany.entity.Student" table="student">
  19.         <id name="sid" column="sid">
  20.             <generator class="sequence">
  21.                 <param name="seuqence">seq_student</param>
  22.             </generator>
  23.         </id>
  24.         <property name="sname" not-null="true"></property>
  26.         <!-- 基于外键的双向一对一 :one -->
  27.         <one-to-one nam="teacher" property-ref="student"
  28.             class="com.hxzy.manymany.entity.Teacher" />
  30.     </class>
  32. teacher:
  33. public class Teacher {
  34.     private int tid;
  35.     private String tname;
  36.     private Student student;
  37.     }
  39. student:
  40. public class Student {
  41.     private int sid;
  42.     private String sname;
  43.     private Teacher teacher;
  45. test:
  46. @Test
  47.     public void test1() {
  48.         DaoImpl daoImpl = new DaoImpl();
  49.         Teacher t1 = new Teacher();
  50.         Teacher t2 = new Teacher();
  51.         Student s1 = new Student();
  52.         Student s2 = new Student();
  53.         t1.setTname("gt1");
  54.         t2.setTname("gt2");
  55.         s1.setSname("gz1");
  56.         s2.setSname("gz2");
  57.         t1.setStudent(s1);
  58.         t2.setStudent(s2);
  59.         daoImpl.addObject(s1);
  60.         daoImpl.addObject(s2);
  61.         daoImpl.addObject(t1);
  62.         daoImpl.addObject(t2);
  63.     }

基于主键关联的一对一关联则需要使用特定的id生成器

  1. teachet:
  2. <class name="com.hxzy.manymany.entity.Teacher" table="teacher">
  3.         <id name="tid" column="tid">
  4.         <generator class="sequence">
  5.         <param name="sequence">seq_teacher</param>
  6.         </generator>
  7.         </id>
  9.         <property name="tname" not-null="true"></property>
  11.         <!-- 基于主键关联的一对一关联需要使用特定的id生成器 -->
  12.         <one-to-one name="student"
  13.             class="com.hxzy.manymany.entity.Student" />
  14. </class>
  16. student:
  17. <class name="com.hxzy.manymany.entity.Student" table="student">
  18.         <!-- 基于主键关联的一对一关联需要使用特定的id生成器 -->
  19.         <id name="sid" column="tid">
  20.             <generator class="foreign">
  21.                 <param name="property">teacher</param>
  22.             </generator>
  23.         </id>
  24.         <property name="sname" not-null="true"></property>
  26.         <!-- 基于主键关联的一对一关联需要使用特定的id生成器 -->
  27.         <one-to-one name="teacher"
  28.             class="com.hxzy.manymany.entity.Teacher" constrained="true" />
  29. </class>

test:

  1. @Test
  2.     public void test1() {
  3.         DaoImpl daoImpl = new DaoImpl();
  4.         Teacher t1 = new Teacher();
  5.         Teacher t2 = new Teacher();
  6.         Student s1 = new Student();
  7.         Student s2 = new Student();
  8.         t1.setTname("gt1");
  9.         t2.setTname("gt2");
  10.         s1.setSname("gz1");
  11.         s2.setSname("gz2");
  12.         s1.setTeacher(t1);//引用他人主键的一方中set他人属性
  13.         s2.setTeacher(t2);
  14.         daoImpl.addObject(t1);
  15.         daoImpl.addObject(t2);
  16.         daoImpl.addObject(s1);
  17.         daoImpl.addObject(s2);
  18.             }

生成的数据库如下：
百度百度百度
百度百度百度
百度百度百度

发表评论

表情：
评论列表 （有 0 条评论，349人围观）

还没有评论，来说两句吧...

相关阅读

    相关 hibernate annotation 关联关系

    在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置

    怼烎@怼烎@/ 0 赞/ 123 阅读

    相关 Hibernate的一对一关联关系

    　　Hibernate的一对一关联关系，分为基于外键的一对一关联关系和基于主键的一对一关联关系。在这篇文章中，我们以部门和部门经理的例子来说明，一个部门对应唯一一个部门经理，一

    悠悠悠悠/ 0 赞/ 339 阅读

    相关 Hibernate 03-配置关联关系映射

    一、了解关联关系 类与类之间最普遍的关系就是关联关系，并且关联是有方向的。以部门（Dept）和员工（Emp）类为例，一个部门下有多个员工，而一个员工只能属于一个部门

    朱雀朱雀/ 0 赞/ 332 阅读