`
wx1568844008
  • 浏览: 5399 次
文章分类
社区版块
存档分类
最新评论

Hibernate 关系映射、多对多many to many

 
阅读更多

many-to-many

在操作和性能方面都不太理想，所以多对多的映射使用较少，实际使用中最好转换成一对多的对象模型；hibernate会为我们创建中间关联表，转换成两个一对多

<one-to-many>中，建议inverse=”true”，由“many”方来进行关联关系的维护
<many-to-many>中，只设置其中一方inverse=”false”，或双方都不设置

 

新建学生

         private int sid;

         private String sname;.

新建老师

         private int tid;

         private String tname;

新建Stud.hbm.xml文件

      <class name="com.tfsoft.manytomany.Stud" table="stud">

        <id name="sid">

          <generator></generator>

        </id>

        <property name="sname" length="20"></property>

       

        <set name="teacs" table="st"><!-- 中间表名称 -->

           <key column="s_id" not-null="true"></key><!-- 学生主键在中间表中的字段名称 -->

           <many-to-many column="t_id" class="com.tfsoft.manytomany.Teac"></many-to-many>

                         <!-- 老师主键在中间表中的字段名称 -->

        </set>

      </class>

新建Teac.hbm.xml文件

      <class name="com.tfsoft.manytomany.Teac" table="teac">

        <id name="tid">

          <generator></generator>

        </id>

       

        <property name="tname" length="20"></property>

       

        <set name="studs" table="st"><!-- 中间表名称 -->

           <key column="t_id" not-null="true"></key><!-- 学生主键在中间表中的字段名称 -->

           <many-to-many column="s_id" class="com.tfsoft.manytomany.Stud"></many-to-many>

        </set>

      </class>

新建测试类

public class Many {

         private static Configuration cf = null;

         private static SessionFactory sf = null;

         static{

                   cf = new Configuration().configure();

                   sf = cf.buildSessionFactory();

         }

        

         //新增老师

         public void saveOrUpdateTeac(Teac teac){

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   session.saveOrUpdate(teac);

                   ts.commit();

                   session.close();

         }

        

         //修改老师

         public void saveOrUpdateTeac(int tid){

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   Teac teac = (Teac)session.get(Teac.class, tid);

                  

                   Set studs = teac.getStuds();

                   studs.add(getStudById(1));

                  

                   teac.setStuds(studs);

                  

                   session.saveOrUpdate(teac);

                   ts.commit();

                   session.close();

         }

        

         //拿老师对象

         public Teac getTeacById(int tid){

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   Teac teac = (Teac)session.get(Teac.class, tid);

                   ts.commit();

                   session.close();

                   return teac;

         }

        

        

         //新增学生

         public void saveOrUpdateStud(Stud stud){

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   session.saveOrUpdate(stud);

                   ts.commit();

                   session.close();

         }

        

         //拿学生对象

         public Stud getStudById(int sid){

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   Stud stud = (Stud)session.get(Stud.class, sid);

                   ts.commit();

                   session.close();

                   return stud;

         }

        

        

 

 

         public static void main(String[] args) {

                   // TODO Auto-generated method stub

                   Many m = new Many();

                  

/*               Teac t = new Teac();                   新增老师

                   t.setTname("老师A");

                   m.saveOrUpdateTeac(t);

                  

                   Stud s = new Stud();          新增学生

                   s.setSname("学生A");

                   m.saveOrUpdateStud(s);*/

                  

/*               Teac t = m.getTeacById(1);               通过Id获取老师对象

 

                   Set studs = new HashSet();               新建集合

                   Stud stud = m.getStudById(2);                  通过Id获取学生

                   studs.add(stud);                将获取的学生放入集合

 

                   t.setStuds(studs);             将集合放入学生类

                   m.saveOrUpdateTeac(t);*/               执行方法

                  

       m.saveOrUpdateTeac(1);

                  

         }

}

多对多转换成一对多使用

 

新建学生

         private int sid;

         private String sname;

 

         //中间表集合

         private Set sts = new HashSet();

新建老师

         private int tid;

         private String tname;

 

         private Set sts = new HashSet();

新建中间表

         private int id;

         private Teac teac;

         private Stud stud;

 

新建Stud.hbm.xml

      <class name="com.tfsoft.manytomany2.Stud" table="stud">

        <id name="sid">

          <generator></generator>

        </id>

       

        <property name="sname" length="20"></property>

       

        <set name="sts" inverse="true">

           <key column="s_id" not-null="true"></key><!-- 学生主键在中间表中的字段名称 -->

           <one-to-many class="com.tfsoft.manytomany2.St"/>

        </set>

       

      </class>

新建Teac.hbm.xml

      <class name="com.tfsoft.manytomany2.Teac" table="teac">

        <id name="tid">

          <generator></generator>

        </id>

       

        <property name="tname" length="20"></property>

       

        <set name="sts" inverse="true">

           <key column="t_id" not-null="true"></key><!-- 学生主键在中间表中的字段名称 -->

           <one-to-many class="com.tfsoft.manytomany2.St"/>

        </set>

      </class>

新建St.hbm.xml

      <class name="com.tfsoft.manytomany2.St" table="st">

        <id name="id">

          <generator></generator>

        </id>

       

        <many-to-one name="teac" class="com.tfsoft.manytomany2.Teac" column="t_id" not-null="true">

        </many-to-one>

       

        <many-to-one name="stud" class="com.tfsoft.manytomany2.Stud">

           <column name="s_id" not-null="true"></column>

        </many-to-one>

       

      </class>

测试类

public class Many {

         private static Configuration cf = null;

         private static SessionFactory sf = null;

         static {

                   cf = new Configuration().configure();

                   sf = cf.buildSessionFactory();

         }

 

         // 新增老师

         public void saveOrUpdateTeac(Teac teac) {

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   session.saveOrUpdate(teac);

                   ts.commit();

                   session.close();

         }

 

         // 拿老师对象

         public Teac getTeacById(int tid) {

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   Teac teac = (Teac) session.get(Teac.class, tid);

                   ts.commit();

                   session.close();

                   return teac;

         }

 

         // 新增学生

         public void saveOrUpdateStud(Stud stud) {

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   session.saveOrUpdate(stud);

                   ts.commit();

                   session.close();

         }

 

         // 拿学生对象

         public Stud getStudById(int sid) {

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   Stud stud = (Stud) session.get(Stud.class, sid);

                   ts.commit();

                   session.close();

                   return stud;

         }

 

         // 新增中间表

         public void saveOrUpdateSt(St st) {

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   session.saveOrUpdate(st);

                   ts.commit();

                   session.close();

         }

 

         // 通过两个外键取一个对象

         public St getStById(int sid, int tid) {

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

 

                   Query query = session.createQuery("from St where stud.sid=" + sid

                                     + " and teac.tid=" + tid);

                   List list = query.list();

                   St st = (St) list.get(0);

 

                   ts.commit();

                   session.close();

                   return st;

         }

 

         // 删除老师

         public void deleteTeac(Teac teac) {

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   session.delete(teac);

                   ts.commit();

                   session.close();

         }

 

         public static void main(String[] args) {

                   Many m = new Many();

         /*     St st = new St();

                   Teac t = m.getTeacById(1);               //获取老师

                   Stud s =m.getStudById(2);                //获取学生

                   st.setStud(s);                              放到中间表

                   st.setTeac(t);

                   m.saveOrUpdateSt(st);*/                 新增

                  

 

                  

                   /*  St st = m.getStById(2, 1);          修改中间表，通过Id获取对象

                     Teac t = m.getTeacById(2);          通过Id获取老师对象

                     st.setTeac(t);                          将老师添加到中间表中

                     m.saveOrUpdateSt(st);*/             修改

                    

                  

                   m.deleteTeac(m.getTeacById(2));            通过Id获取老师，再删除

 

         }

}


转载于:https://my.oschina.net/u/2353689/blog/476085

分享到：
| Hibernate 关系映射、多向关联
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate one-to-many / many-to-one关系映射

    "Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型，用于表示实体间的关联。在这个主题中，我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一（one-to-one）与一对多（one-to-...

    hibernate关系映射多对多关系

    本资料包主要关注的是Hibernate中的关系映射，特别是多对多（ManyToMany）关系，这对于理解和实现复杂的数据库模型至关重要。在Spring+Hibernate+Struts框架下，这种映射关系的应用更是常见。 首先，我们需要了解在...

    Hibernate关系映射

    "多对一"关系映射是Hibernate支持的四种基本关联类型之一，包括一对一、一对多、多对一和多对多。本篇将深入探讨“多对一”关系映射的概念、配置以及在实际web系统中的应用。 **一、“多对一”关系映射概念** 在...

    Hibernate关系映射 收藏

    本篇文章主要探讨了四种常见的关系映射：多对一、一对多、一对一和多对多，并以Oracle数据库为例，通过代码实例来说明它们的实现方式。 1. 多对一（Many-to-One） 多对一关系意味着一个实体（如`Room`）可以被多个...

    hibernate关系映射网址

    本文将详细介绍Hibernate中的关系映射机制，包括一对一、一对多、多对一以及多对多等不同类型的映射方式，并探讨其背后的原理及最佳实践。 #### 二、Hibernate关系映射基础 ##### 2.1 映射文件简介 在Hibernate中...

    Hibernate 两种方式映射many to many

    在Java的持久化框架Hibernate中，处理多对多（Many-to-Many）关系映射是一项常见的任务。这种关系类型在数据库设计中很常见，比如学生和课程的关系，一个学生可以选修多门课程，一门课程也可以被多个学生选修。在...

    hibernate many-to-many级联保存，级联更新，级联删除

    在数据库设计中，Many-to-Many关系意味着两个实体之间存在多对多的关系。例如，学生可以选修多门课程，而一门课程也可以被多名学生选修。在Hibernate中，这种关系通过中间关联表（也称为连接表或联合表）来实现，该...

    hibernate关系映射

    多对多（Many-to-Many）关系映射在Hibernate中稍微复杂一些，因为它涉及一个关联表（也称为中间表）。例如，学生可以选择多门课程，而课程也可以被多个学生选修。使用`@ManyToMany`注解，可以定义这种关系。在映射...

    hibernate（多对多关系映射）

    在Java的持久化框架Hibernate中，多对多（Many-to-Many）关系映射是一种常见的数据库交互模式，它用于表示两个实体之间复杂的关系。在这个场景中，一个实体可以与多个其他实体相关联，反之亦然。例如，在学生和课程...

    hibernate的多种映射关系

    4. **多对多映射 (Many-to-Many)** 多对多关系表示两个实体之间存在多个关联，如学生可以选择多门课程，课程也可以被多个学生选修。这种关系需要一个中间表来存储双方的关联信息，通常通过 `@ManyToMany` 注解实现...

    Hibernate应用例子many-to-many

    本示例将详细讲解如何在Hibernate中实现多对多（many-to-many）的关系映射。 在数据库设计中，多对多关系是指两个实体之间存在多个关联，比如学生和课程的关系，一个学生可以选修多门课程，一门课程也可以被多个...

    Hibernate映射一对多关联关系

    ### Hibernate映射一对多关联关系 #### 知识点概览 - **概念解析**：一对多（One-to-Many）关联关系的概念及其在Hibernate中的实现方式。 - **域模型设计**：创建具有一个实体与多个实体关联的域模型。 - **关系...

    hibernate 关联映射（一） many to one

    本篇文章将深入探讨Hibernate中的关联映射，特别是"Many to One"关系的映射。在数据库设计中，Many to One是一种常见的关系，即一个实体（表）可以与多个其他实体相关联，而另一个实体则只与一个实体相关联。 首先...

    [原]Hibernate集合映射

    6. **多对多（Many-to-Many）映射** 多对多关系相对复杂，例如，学生和课程之间的关系。它通常需要一个中间表来存储两个实体的关联。在Hibernate中，我们使用`@ManyToMany`注解，同时通过`@JoinTable`指定中间表的...

    hibernate(一对多，多对一映射)操作

    本文将深入探讨Hibernate中的一对多和多对一映射关系，并通过一个实际的demo演示它们在增删查改操作中的应用。 首先，我们要理解什么是数据库的关联关系。在数据库设计中，我们经常遇到一种情况，即一个实体可能与...

    hibernate关联映射的作用和常用属性解释

    其中，“关联映射”是Hibernate中的一个重要概念，用于处理实体之间的关联关系，例如一对一、一对多、多对一以及多对多等。 #### 常用属性解析 为了更好地理解和运用Hibernate中的关联映射机制，我们需要深入了解...

    Hibernate 多表映射关系配置

    以下是如何配置 Hibernate 的多对多映射关系。 1. 数据库建表 假设我们有两张表，`users` 和 `roles`，它们通过 `user_roles` 这个中间表进行关联。 ```sql CREATE TABLE users ( user_id INT AUTO_INCREMENT ...

Magicbox
Global site tag (gtag.js) - Google Analytics