Hibernate关联映射关系

一.双向一对多关联映射关系:当类与类之间建立了关联，就可以方便的从一个对象导航到另一个或另一组与它关联的对象（一对多双向关联和多对一双向关联是完全一样的）

1.1创建实体类(Emp(员工),Dept(部门))

/* * 员工实体类 */public class Emp
{
    private Integer empId;    //员工编号
    private String empName;      //员工姓名
    private Dept dept;      //所处部门
    //get(),set()方法省略
}
/*
 * 部门实体类
 */
public class Dept
{
  private Integer deptNo;  //部门编号
  private String deptName;  //部门姓名
  private Set<Emp> emps=new HashSet<Emp>();  //员工集合
 //get(),set()方法省略
}

1.2创建小配置文件

　　　　Emp.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.a.entity">
    <class name="Emp" table="Emp">
    <id name="empId">
        <generator class="sequence">
        <param name="sequence">SEQ_Student</param>
        </generator>
    </id>
    <property name="empName"></property>
    <!-- 植入一个Dept对象           多对一 -->
    <many-to-one name="dept" class="Dept" column="deptNo"></many-to-one>
    </class>
</hibernate-mapping>

　　　　Dept.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.a.entity">
    <class name="Dept" table="Dept">
    <id name="deptNo">
        <generator class="sequence">
        <param name="sequence">SEQ_Student</param>
        </generator>
    </id>
    <property name="deptName"></property>
    <set name="sets" inverse="true" cascade="save-update">
    <key column="deptNo"></key>        <!-- 多的一方的外建 -->
    <one-to-many class="Emp" />
    </set>
    </class>
</hibernate-mapping>

set元素：

<set>元素的name属性：设定持久化类名,此处为Dept类的emps属性

<set>元素的子元素<key>:column属性设定与所关联的持久化类对应的表的外键，此处为Emp表的外键DepeNo字段

<set>元素的子元素<one-to-many>:class属性设定与所关联的持久化类，此处为Emp类

那么,Hibernate会根据以上映射代码获得以下信息:

1.<set>元素表明Dept类的emps属性为java.util.Set集合类型

2.<one-to-many>子元素表明emps集合中存放的是一组Emp对象

3.<key>子元素表明Emp表通过外键DeptNo参照DEPT表

1.3.创建bibernate.cfg.xml大配置文件,关联两个小配置文件

<?xml version=‘1.0‘ encoding=‘utf-8‘?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings 数据库连接设置 -->
        <!-- 驱动类 -->
        <property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
        <!-- url地址 -->
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
        <property name="connection.username">Hibernate</property>
        <property name="connection.password">orcl</property>
        <!-- SQL dialect (SQL 方言) -->
        <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
        <!--在控制台打印后台的SQL语句 -->
        <property name="show_sql">true</property>
        <!-- 格式化显示SQL -->
        <!-- <property name="format_sql">true</property> -->
        <!-- 自动生成表 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 关联小配置 -->
        <mapping resource="cn/a/entity/Dept.hbm.xml" />
        <mapping resource="cn/a/entity/Emp.hbm.xml" />
    </session-factory>
</hibernate-configuration>

1.4编写测试类oneTomanyTest

@Test
    public void onetomany()
    {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //构建一个部门
        Dept dept=new Dept();
        dept.setDeptName("就業部");
        //构建一个员工
        Emp emp=new Emp();
        emp.setEmpName("彪哥");
        //指定员工所隶属的部门
        emp.setDept(dept);
        dept.getSets().add(emp);
        //save()
        session.save(dept);
        //提交事务
        tx.commit();
        HibernateUtil.CloseSession();
    }

补充:inverse属性和cascade属性

inverse：决定是否把对象中集合的改动反映到DB中，所以inverse只对集合起作用，也只有one-to-many和many-to-many有效，因为只有这两种关系有集合(而many-to-one和one-to-one只含有关系对方的一个引用)。

cascade:决定是否把对象的改动反映到DB中，所以，cascade对所有的关联关系都起作用。

2:inverse:inverse所描述的是对象之间关联关系的维护方式。

inverse：只存于集合标记的元素中。

inverse的作用是：把对象中对集合的改动反映到DB中

inverse的默认值是：false，表示集合的改动反映到DB中，inverse：false为主动方，由主动方负责维护关联关系。

inverse为true：表示不将改动过的集合反映到数据库中。

一对多：该属性在多的一方。应在少的一方设置inverse属性：true，而多的一方设置为false，这说明关联关系由多的一方来维护，如果

要少的一方维护，就会使插入或删除时一方去update多的一方每一个与这个对象有关系的对象，如果交给多的一方来维护，则会大大提高

了效率（因为关系就是在多的一方中，直接插入或删除就好了嘛）

多对多：属性存在独立表中。inverse属性默认为false；在多对多的关系中，关系两端的inverse不能都设置为false，如果都设置为false，则在插入操作时会导致关系表中插入两    次关系，也不能都设置成true（任何操作都不会影响到关系表中的数据）

，因此在任意一方设置为true，另一方设置为false;

二.双向关联多对多

1.创建是实体类(Emp,Project)

public class Emp {
    private Integer eid;
    private String ename;
    private Set<Project> pros=new HashSet<Project>();
    public Integer getEid() {
        return eid;
    }
    public void setEid(Integer eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public Set<Project> getPros() {
        return pros;
    }
    public void setPros(Set<Project> pros) {
        this.pros = pros;
    }

}
/*
 * 项目实体类
 */
public class Project {
    private Integer pid;
    private String pname;
    private Set<Emp> emps=new HashSet<Emp>();
    public Integer getPid() {
        return pid;
    }
    public void setPid(Integer pid) {
        this.pid = pid;
    }
    public String getPname() {
        return pname;
    }
    public void setPname(String pname) {
        this.pname = pname;
    }
    public Set<Emp> getEmps() {
        return emps;
    }
    public void setEmps(Set<Emp> emps) {
        this.emps = emps;
    }

}

2.编写配置文件

　　Emp.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="cn.a.entity">
    <class name="Emp" table="Emp">
    <id name="eid">
        <generator class="native">

        </generator>
    </id>
    <property name="ename"></property>
    <set name="pros" table="EmpPro">
    <key column="eid"></key>        <!-- 多的一方的外建 -->
    <many-to-many class="Project" column="pid"/>
    </set>
    </class>
</hibernate-mapping>

　　Project.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="cn.a.entity">
    <class name="Project" table="Project">
    <id name="pid">
        <generator class="sequence">
        <param name="sequence">SEQ_Student</param>
        </generator>
    </id>
    <property name="pname"></property>
    <set name="emps" table="EmpPro">
    <key column="pid"></key>        <!-- 多的一方的外建 -->
    <many-to-many class="Emp" column="eid"/>
    </set>
    </class>
</hibernate-mapping>

3.创建大配置文件

<?xml version=‘1.0‘ encoding=‘utf-8‘?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings 数据库连接设置-->
        <!-- 驱动类 -->
        <property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
        <!-- url地址 -->
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
        <property name="connection.username">Hibernate</property>
        <property name="connection.password">orcl</property>
        <!-- SQL dialect  (SQL 方言) -->
        <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
        <!--在控制台打印后台的SQL语句 -->
        <property name="show_sql">true</property>
        <!-- 格式化显示SQL -->
        <!-- <property name="format_sql">true</property> -->
        <!-- 自动生成表 -->
         <property name="hbm2ddl.auto">update</property>
        <!-- 关联小配置 -->
        <mapping resource="cn/a/entity/Project.hbm.xml" />
        <mapping resource="cn/a/entity/Emp.hbm.xml" />
        <!--<mapping resource="cn/a/entity/Dept.hbm.xml" />
        <mapping resource="cn/a/entity/Emp.hbm.xml" />  -->
    </session-factory>
    </hibernate-configuration>

4.编写测试类

@Test
    public void manyTomanyTest()
    {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        //构建一个部门
        Project pro=new Project();
        pro.setPname("技术部");
        //构建一个员工
        Emp emp=new Emp();
        emp.setEname("迟明洋");
        //指定员工所隶属的部门
        emp.getPros().add(pro);
        pro.getEmps().add(emp);
        //save()
        session.save(pro);
        session.save(emp);
        //提交事务
        tx.commit();
        HibernateUtil.CloseSession();
    }

运行结果Oracle数据库端

时间： 2024-08-05 23:19:09

Hibernate关联映射关系的相关文章

Hibernate基数映射关系

Hibernate基数映射关系 一.基数映射——一对一关系映射 每个账户对应一个地址的数据库关系为例: 1.SQL脚本:    -- 一对一(唯一外键)    drop table t_addr;    drop table t_act;    create table t_act(       id int primary key auto_increment,       actNo varchar(50) not null unique,       passwd varchar(50)

第六章 Hibernate关联映射

第六章 hibernate关联映射一.本章知识点分为2部分:1.关联关系:单向多对一关联关系,双向一对多关联关系(含一对多关联关系),多对多关联关系2.延迟加载:类级别加载策略,一对多加载策略,多对一加载策略二.关联关系1.单向多对一关联关系1.1.概念(什么是单向多对一关联关系,举例说明)  以部门(Dept).Emp(员工)为例: 从员工角度看部门,是多个员工都在一个部门,这就叫单向 如部门编号为20的部门下可以有n个员工(如scott账户下emp表 empno 为7369,7566,778

hibernate关联映射

本文可作为北京尚学堂马士兵hibernate课程的学习笔记. hibernate的映射,主要分为一对一,一对多,多对一,多对多,同时还要单向与双向的区别. OK,不要纠结于名字,我们开始看例子. 一对一单向 老公是一个实体,老婆也是一个实体. 一个老公只有一个老婆,同时一个老婆也只有一个老公. 上面的关系就叫做一对一. 什么叫单向呢. 看代码: package com.bjsxt.hibernate; @Entity public class Husband { private int id;

hibernate关联映射【一对一主键】

从三个部分介绍Hibernate一对一主键关联映射. 1.基本介绍2.代码展示3.总结注意  1.基本介绍 一对一关联有两种情况: 单向一对一主键关联.双向一对一主键关联.一对一主键关联: 是指两个表之间通过主键形成一对一的映射,例如,每个公民只允许拥有一个身份证,公民与身份证就是一对一的关系,定义两张表,一张People表,一张IdCard表,People表的id既是该表的主键也是该表的外键,并且People的id也就是IdCard的id, 2.代码 单向一对一主键关联:people表的id既

Hibernate关联映射 映射文件的配置

一:多对一单向关联 首先我们必须创建两个实体类 例如:Dept类 public class Dept { private Integer deptNo; private String dName; private String loc; private Set<Employee> emps=new HashSet<Employee>(); Employee类 public class Employee { private Integer empno; private String

java框架篇---hibernate(一对一)映射关系

对象-关系映射(Object/Relation Mapping,简称ORM),是随着面向对象的软件开发方法发展而产生的,是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术,本质上就是将数据从一种形式转换到另外一种形式. 面向对象的开发方法是当今企业级应用开发环境中的主流开发方法,关系数据库是企业级应用环境中永久存放数据的主流数据存储系统.对象和关系数据是业务实体的两种表现形式,业务实体在内存中表现为对象,在数据库中表现为关系数据.内存中的对象之间存在关联和继承关系,而在数据库中,关系数

Hibernate 关联映射

ORM(Object Relational Mapping)对象/关系映射 说到Hibernate的关联映射就必须要提一提ORM了.那么ORM是什么呢,其是一种持久化技术,他在对象模型和关系型数据库之间建立对象关系,通过操作JavaBean对象来完成对数据库的操作! 注意:ORM是概念化的并不是实际存在的,可以理解为其是一种编程思想,而Hibernate框架就是该思想的实现产品! 配置Po对象(和数据表绑定的持久化对象)的关联关系 从上面说到ORM可以在对象模型和数据库之间建立对应关系而在Hib

Hibernate关联映射（单项多对一和一对多、双向一对多）

最近总是接触着新的知识点来扩展自己的知识面:不停的让自己在原地接触天空的感觉真的很美好!!!革命没有成功,程序员的我们怎么能不努力呢...... 一.用员工和部门来剖析关联映射的原理. 1)从这张截图可以看出我会站在员工的角度讲述:(单向关联) 关系:(多个员工对应一个部门)多对一的关系 意味:多个Emp对象只会引用一个Dept对象 方法:在Emp类中定义一个Dept类型属性,来引用所有关联的Dept对象 eg. 第一步建立两个实体类省略 第二步建立大配置 <?xml version='1.0'

hibernate关联映射(一对多)

这篇博客将会给大家带来hibernate的关联映射的学习.在现实生活中,不仅只是一对一的映射关系,更多的是一对多,多对多等. 一对多单项关联映射 这里我以网盘为例,一个用户可以拥有多个文件,及用户和文件之间是一对多的关系. user实体类: public class Users { private int uid; private String uname; //用户上传的所有文件 // one方 可以获取 many方 private Set<UpFile> files = new HashS