`

单向多对多关系映射

阅读更多
          多对多其实是个很复杂的关系,hibernate在进行处理的时候借助中间表或者中间类。中间表是在映射文件的关联标签(比如集合标签<set>)中由table属性指定的由hibernate自动生成的表,它只有两个字段,分别由<key>和<many-to-many>标签的table属性指定,作为外键分别用来指向关联双方表的主键。中间类就是把我们的中间表抽象生成一个实体类,在映射的时候分别和两个关联类构成一对多的关系,即演变成两个一对多来处理。
          以下用中间表的例子来说明单向多对多关系映射:运动员(player)与角色(role)就是典型的多对多关系。
          首先创建player,role类分别对应的表格:sxt_hibernate_player,sxt_hibernate_role,和中间表sxt_hibernate_player_role(在MySQL环境中)代码如下:

          create table sxt_hibernate_player(
                      id    int(11)  not null auto_increatement,
                      name  varchar(16),
                      primary key(id)
         )ENGINE=InnoDB DEFAULT CHARSET=gbk;

         create table sxt_hibernate_role(
                      id    int(11)  not null auto_increatement,
                      name  varchar(16),
                      primary key(id)
         )ENGINE=InnoDB DEFAULT CHARSET=gbk;

         create table sxt_hibernate_player_role(
                      player_id    int(11),
                      role_id      int(11)
         )ENGINE=InnoDB DEFAULT CHARSET=gbk;

              Player实体类:
          
              public class Player {

                           private Integer id;
                           private String name;
                           private Set<Role> roles;
                           //...省去一系列的setter.getter方法
                               @Override
                           public String toString() {
                           return "Player:" + name;
                           }
            }
             Role实体类:
       
             public class Role {

                            private Integer id;
                            private String name;
                            //...省去一系列的setter.getter方法
                                 @Override
                            public String toString() {
                            return "Role:" + name;
                            }
           }
             映射文件:

             Role.hbm.xml
  <class name="com.sxt.hibernate.many2many.entity.Role" table="sxt_hibernate_role">
    <id name="id" length="4">
      <generator class="native"></generator>
    </id>
    <property name="name" length="10"></property>
  </class>
   Player.hbm.xml
  <class name="com.sxt.hibernate.many2many.entity.Player" table="sxt_hibernate_player">
    <id name="id" length="4">
      <generator class="native"></generator>
    </id>
    <property name="name" length="10"></property>
    <!--table="sxt_hibernate_user_role"含义,用来指定中间表    -->
    <set name="roles" table="sxt_hibernate_player_role" cascade="save-update">
      <!--<key column="user_id">含义,指定中间表中用来指向本表的外键    -->
      <key column="player_id"></key>
      <!-- column含义,用来指定中间表中用来指向另一端表的外键 -->
      <many-to-many class="com.sxt.hibernate.many2many.entity.Role" column="role_id"></many-to-many>
    </set>
  </class>

              测试类Test:

              public class Test{

              public static void main(String[] args) {
    Session session = HibernateUtils.getSession();
    Transaction t = session.beginTransaction();
    try {
      /**
        * 测试插入数据
         */
      Role role1=new Role();
      role1.setName("后卫");
       
      Role role2=new Role();
      role2.setName("前锋");
       
      Role role3=new Role();
      role3.setName("中锋");
       
      Player player1=new Player();
      player1.setName("姚明");
      Set<Role> roles1=new HashSet<Role>();
      roles1.add(role3);
      player1.setRoles(roles1);
       
      Player player2=new Player();
      player2.setName("詹姆斯");
      Set<Role> roles2=new HashSet<Role>();
      roles2.add(role1);
      roles2.add(role2);
      roles2.add(role3);
      player2.setRoles(roles2);
      //能正确保存.每保存player后,都要级联保存它的role,并且级联插入中间表记录.
      session.save(player1);
      session.save(player2);*/
       
      /**
        * 测试加载数据
        */
      Player player=(Player)session.load(Player.class, 1);
      System.out.println(player);
      for(Iterator<Role> iterator=player.getRoles().iterator();iterator.hasNext();){
        System.out.println(iterator.next());
      }
      t.commit();
    } catch (HibernateException e) {
      e.printStackTrace();
      t.rollback();
    } finally {
      HibernateUtils.closeSession(session);
    }
  }
}
分享到:
评论

相关推荐

    hibernate单向多对多映射(XML版)

    在Java世界中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者将数据库操作转换为面向对象的方式,从而提高开发效率。本主题聚焦于"hibernate单向多对多映射",特别是在XML配置文件中的实现。在这...

    hibernate 单向多对多关联映射练习

    在Java世界中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者将数据库操作与业务逻辑层解耦,提高开发效率。本练习主要关注的是Hibernate中的单向多对多关联映射,这是一种常见的关系数据库设计...

    hibernate单向多对多映射(注解版)

    在Java的持久化框架Hibernate中,单向多对多映射是一种常见的关系映射方式,尤其在处理数据库中两个实体间复杂关联时显得尤为重要。在注解版的Hibernate中,我们不再需要传统的XML配置文件,而是直接在实体类上使用...

    Hibernate教程04_关系映射之一对一单向外键关联

    **标题详解:**“Hibernate教程04_关系映射之一对一单向外键关联” 在Hibernate框架中,关系映射是数据库表之间的关联在对象模型中的体现。本教程重点讲解了一对一(One-to-One)单向外键关联的实现方法。在数据库...

    一对多单向和双向映射

    在IT领域,尤其是在Java开发中,关系型数据库的映射是至关重要的,特别是在对象关系映射(ORM)框架如Hibernate的使用中。本篇将详细探讨"一对多单向和双向映射"这一主题,结合标签中的"源码"和"工具",我们将深入...

    Hibernate教程11_关系映射之一对多单向关联

    本教程主要探讨的是Hibernate中的一种重要关系映射类型:一对多单向关联。在关系型数据库中,一对多关联是最常见的关系类型,一个实体可以与多个其他实体相关联。在Hibernate中,这种关系可以通过配置XML映射文件或...

    hibernate多对一单向关联关系实现源码

    在Java的持久化框架Hibernate中,多对一(ManyToOne)关联关系是一种常见的对象关系映射(ORM)场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录,而另一个实体类可能只有一条对应的记录。例如...

    Hibernate教程10_关系映射之多对一单向关联

    本教程主要聚焦于Hibernate中的一个关键概念——关系映射,特别是多对一单向关联的实现。这种关联类型常出现在数据库设计中,比如一个部门可以有多名员工,但一个员工只属于一个部门。 首先,我们要理解多对一关系...

    hibernate核心,一对多,多对多映射讲解,看了就完全搞明白了

    1. 配置并创建单向多对一关联,如“区县”和“街道”的关系。 2. 创建双向一对多关联,如“街道”和“区县”的双向关系。 3. 实现多对多关联,例如OA系统中项目和人员的对应关系管理。 在实体类中,我们可以使用...

    Hibernate教程13_关系映射之多对多单向关联

    在本教程中,我们将深入探讨Hibernate中的一个关键概念——关系映射,特别是多对多单向关联。在数据库设计中,多对多关系是两个实体之间最复杂的关系类型,允许一个实体实例与多个其他实体实例相关联,反之亦然。在...

    hibernate单向一对多关联映射(注解版)

    Hibernate通过注解使得对象关系映射(ORM)更加简洁明了,避免了传统的XML配置文件。 首先,让我们理解一下“单向一对多”关联的基本概念。在数据库设计中,如果一个实体(比如部门)可以与多个其他实体(比如员工...

    Hibernate学习:单向多对一关联 工程

    本项目“Hibernate学习:单向多对一关联 工程”专注于讲解Hibernate中的单向多对一关联映射,这是数据库设计中常见的关系类型,尤其在处理具有层次结构的数据时。 单向多对一关联指的是在一个实体类中有一个引用,...

    jpa的实体映射关系7种

    在Java Persistence API (JPA) 中,实体映射关系是数据库关系模型与Java对象模型之间的桥梁,用于在ORM(对象关系映射)框架下管理数据。JPA 提供了多种映射关系,使得开发者能够方便地处理不同类型的关联。下面我们...

    Hibernate一对多单向关联映射

    Hibernate是一个开源的对象关系映射(ORM)框架,它允许开发者用Java对象来操作数据库,通过将Java类与数据库表进行映射,简化了数据库操作。ORM的主要优势在于它可以减少数据库访问的复杂性,提高开发效率。 **二...

    Hibernate教程06_关系映射之一对一单向主键关联

    **标题详解:** "Hibernate教程06_关系映射之一对一单向主键关联" 在Hibernate框架中,关系映射是将数据库中的表关系映射到对象模型上的过程。本教程聚焦于一对一(One-to-One)单向主键关联,这是一种特定类型的...

    ORM映射关系配置

    3. **多对多关系映射** - 单向:通常会创建一个关联中间表,通过`@ManyToMany`注解和`@JoinTable`指定关联信息。 - 双向:双方实体都可以访问对方的集合,通过`@ManyToMany`注解并设置`mappedBy`来区分维护端。 ...

Global site tag (gtag.js) - Google Analytics