Hibernate值关联映射

一.关联关系  

在软件开发中，类与类中之间最普遍的关系就是关联关系，而且关联是有方向的。

以部门(Dept)和员工(Emp)为例：

一个部门下可以有多个员工，而一个员工只能属于一个部门。所以从Emp到Dept的关联是一对多的关联关系，这就意味着每个Emp对象只会引用一个Dept对象。

从Dept到Emp是一对多的关联关系，这意味着Dept对象会引用一组Emp对象，因此在Dept类中应该定义一个集合类型的属性，来引用所关联的Emp对象。

如果仅有从Emp到Dept对象的关联，或者仅有从Dept到Emp的关联，就称为单向关联。如果同时包含两种关联，就称为双向关联。

二.配置单向多对一关联

在Emp类中定义一个Dept属性，而在Dept类中无须定义用于存放Emp对象的集合属性

01.Dept.java

package cn.zhang.entity;

//部门实体类
public class Dept {

    private Integer deptid;//编号

    private String deptname;//名称

    public Integer getDeptid() {
        return deptid;
    }

    public void setDeptid(Integer deptid) {
        this.deptid = deptid;
    }

    public String getDeptname() {
        return deptname;
    }

    public void setDeptname(String deptname) {
        this.deptname = deptname;
    }

}

02.Emp.java

package cn.zhang.entity;
//员工实体类
public class Emp {

    private Integer empno;//编号

    private String empname;//姓名

    private Dept dept;//所属部门

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public Integer getEmpno() {
        return empno;
    }

    public void setEmpno(Integer empno) {
        this.empno = empno;
    }

    public String getEmpname() {
        return empname;
    }

    public void setEmpname(String empname) {
        this.empname = empname;
    }

}

03.Dept.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zhang.entity">
<class name="Dept" table="DEPT">
<!--主键生成策略-->
<id name="deptid" column="DEPTID">
   <generator class="sequence">
   <param name="sequence">SQ_Num</param>
   </generator>
</id>
<property name="deptname" type="string" column="deptname"/>
</class>
</hibernate-mapping>

04.Emp.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zhang.entity">
<class name="Emp" table="EMP">
<!-- 主键生成策略 -->
<id name="empno" column="empno">
    <generator class="sequence">
   <param name="sequence">SQ_Num</param>
   </generator>
</id>
<property name="empname" type="string" column="empname"/>
<!-- 多对一（员工对部门） -->
 <many-to-one name="dept" column="deptid" class="Dept"></many-to-one>
</class>
</hibernate-mapping>

05.hibernate.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>
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
        <property name="connection.username">zhangzong</property>
        <property name="connection.password">123</property>

        <!-- SQL dialect (SQL 方言)-->
        <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>

        <!-- Drop and re-create the database schema on startup -->
         <property name="hbm2ddl.auto">create</property> 

        <!-- Echo all executed SQL to stdout  在控制台打印后台的SQL语句-->
        <property name="show_sql">true</property>

        <!-- 格式化显示SQL -->
        <property name="format_sql">true</property>    

        <!-- JDBC connection pool (use the built-in) -->
        <!-- <property name="connection.pool_size">1</property> -->

        <!-- Enable Hibernate‘s automatic session context management 指定当前session范围和上下文-->
        <!--  <property name="current_session_context_class">thread</property> -->

        <!-- Disable the second-level cache -->
        <!-- <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>-->

        <mapping resource="cn/zhang/entity/Dept.hbm.xml" />
        <mapping resource="cn/zhang/entity/Emp.hbm.xml" />

    </session-factory>

</hibernate-configuration>

06.用于获得session对象和关闭session对象的工具类HibernateUtil

package cn.zhang.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    //初始化一个ThreadLocal对象，有get和set方法
    private static final ThreadLocal<Session> sessionTL=new ThreadLocal<Session>();

    private static Configuration configuration;

    private final static SessionFactory sessionFactory;
    static{

        configuration=new Configuration().configure();
        sessionFactory=configuration.buildSessionFactory();
    }
    //获得session对象
    public static Session currentSession() {
        //sessionTL的get方法根据当前线程返回其对应的线程内部变量，即Session对象，多线程情况下共享数据库连接是不安全的。
        //ThreadLocal保证了每个线程都有自己的session对象
        Session session=(Session)sessionTL.get();
        if (session==null) {
            session=sessionFactory.openSession();
            sessionTL.set(session);
        }

        return session;
    }
    //关闭session对象
    public static void closeSession() {
        Session session=(Session)sessionTL.get();
        sessionTL.set(null);
        session.close();
    }

}

07.测试类

@Test //多对一的单向关联关系
    public void TestOne(){

        Session session = HibernateUtil.currentSession();

        Transaction tx = session.beginTransaction();
        Dept dept=new Dept();
        dept.setDeptname("开发部");

        Emp emp=new Emp();
        emp.setDept(dept);
        emp.setEmpname("张总");

        session.save(dept);
        session.save(emp);

        tx.commit();

        HibernateUtil.closeSession();
    }

三.配置双向的一对多关联

在上一个例子中，已经建立Emp类到Dept类的多对一关联，下面再增加Dept到Emp类的一对多关联，

在Dept类中增加一个集合类型的emps属性：

    private Set<Emp> emps=new HashSet<Emp>();//员工集合

    public Set<Emp> getEmps() {
        return emps;
    }

    public void setEmps(Set<Emp> emps) {
        this.emps = emps;
    }

在Dept.hbm.xml中也会改变为：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zhang.entity">
<class name="Dept" table="DEPT">
<id name="deptid" column="DEPTID">
   <generator class="sequence">
   <param name="sequence">SQ_Num</param>
   </generator>
</id>
<property name="deptname" type="string" column="deptname"/>
<!-- 映射集合类型的emps属性 -->
<!-- name属性：设定持久化类的属性名。此处为Dept类的emps -->
<set name="emps" cascade="save-update" inverse="true">
<!-- column属性设定与所关联的持久化类对应的表的外键，此处为EMP表的deptid字段 -->
<key column="deptid"></key>
<!-- class属性设定与所关联的持久化类，此处为Emp类 -->
<one-to-many class="Emp"></one-to-many>
</set>
</class>
</hibernate-mapping>

补充：cascade属性和inverse属性（会新写一篇博客）

01."cascade"属性

　 　"cascade"-直译过来就是"级联、串联"的意思，书面化的解释为"该属性会使我们在操作主对象时，同时Hibernate帮助我们完成从属对象 相应的操作（比如，有Customer和Order这两张表，关系为一对多，只使用JDBC删除Customer表中的一行记录时，我们还需要手动的将 Order表中与之关联的记录全都删除，使用Hibernate的‘cascade‘属性后，当我们删除一条Customer记录时，Hibernate 会帮助我们完成相应Order表记录的删除工作，方便了我们的工作）"。

02."inverse"属性

"inverse" -直译过来就是"反转，使颠倒"的意思，书面化的解释为"是否将关系维护的权力交给对方"（这个解释真够蛋疼的-_-!!，就是理解不了）。 Hibernate中的"inverse"属性只有两个值"true"和"false"。"true"表示将关系维护的权力交给对方，"false"表示不交出维护权力（默认值）。

推荐博客:http://www.cnblogs.com/o-andy-o/archive/2012/03/26/2418235.html

测试：

    @Test
    public void TestThree(){
        //获得session对象
        Session session = HibernateUtil.currentSession();
        //开启事务
        Transaction tx = session.beginTransaction();
        //建立一个Dept对象和Emp对象

        Dept dept=new Dept();
        dept.setDeptname("就业部");

        Emp emp=new Emp();
        emp.setEmpname("坤坤");
        //建立Dept和Emp对象的一对多双向关联关系
        emp.setDept(dept);
        dept.getEmps().add(emp);
        //保存Dept对象
        session.save(dept);

        //提交事务
        tx.commit();
        //关闭session连接
        HibernateUtil.closeSession();

    }

时间： 2025-01-01 02:24:36

Hibernate值关联映射的相关文章

Hibernate注解----关联映射注解以及课程总结详解----图片版本

上一篇,记录了Hibernate注解----类级别注解以及属性注解详解 ,我们这一节主要讲解的是Hibernate注解----关联映射注解以及课程总结详解. 本节的主要内容: 第3章 关联映射注解 3-1 本章简介 3-2 实体之间的关系 3-3 一对一单向外键关联(一) 3-4 一对一单向外键关联(二) 3-5 一对一双向外键关联 3-6 一对一单向外键联合主键 3-7 多对一单向外键关联(一) 3-8 多对一单向外键关联(二) 3-9 一对多单向外键关联 3-9 一对多双向外键关联 3-10

006——hibernate一对一关联映射

一对一关联映射有两种方式:主键关联和外键关联 以夫妻为例(Husband----Wife) 单向关联实体类: Husband.java package com.java.hibernate; public class Husband { private int id; private String name; private Wife wife; public Wife getWife() { return wife; } public void setWife(Wife wife) { thi

9、Hibernate之关联映射(hibernate映射)

回顾Hibernate: 1. hibernate开发环境搭建 --> 引入jar: hibernate.jar + required + jpa + 驱动包 -> hibernate.cfg.xml -> javabean/*.hbm.xml -> Application 测试 2.hibernate api --> Configuration --> SessionFactory --> Session -> Transaction --->Que

Hibernate的关联映射之1-1关联映射

二.1-1 无论是单向1-1映射关联,还是双休1-1映射关联,都有三种映射策略:基于主键.基于外键.采用连接表. 1.单向1-1映射关联 1.1.基于主键的单向1-1映射关联 对于基于主键的单向1-1关联,基于主键关联的持久化类不能拥有自己的主键生成器策略,它的主键由关联实体来负责生成. 是根据他自己的person属性来获得的.即他通过自身的一个getPerson()方法来获得Person对象.然后通过Person对象中的getID()方法获得id,然后赋值给自身id.这样就可以不需要自己来生成

Hibernate的关联映射之1-N关联映射

三.1-N 对于1-N而言,它的持久化类发生了一点改变,持久化类里需要使用集合属性.因为1的一端需要访问N的一端,而N的一端将以集合(Set)形式表现. 1.单向1-N关联 对于单向的1-N关联关系,只需要在1的一端增加Set类型的属性,该属性记录当前实体的关联实体. 同样以员工-部门为例(Employee-->Department).两个持久化类如下: Department [java] view plain copy print? public class Department { priv

hibernate 之 关联映射的基于外键的双向一对一关联

1. 人和身份证是一个一对一的关系,他们的表结构为: 2. 类结构:Person.java public class Person { private int id; private String name; private int age; private IdCard idCard; public Person() { } public Person(String name, int age) { super(); this.name = name; this.age = age; } pu

hibernate 之 关联映射的双向一对多关联

1. 考虑学生表 和 教师表,表结构和单向的表结构一样. 2. 类结构:Teacher.java public class Teacher { private int id; private String name; private Set<Student> students = new HashSet<Student>(); public Teacher() { } public Teacher(String name) { super(); this.name = name;

hibernate 之 关联映射的基于外键的单向一对一映射

1. 人和身份证是一个一对一的关系,他们的表结构为: 2. 类结构:IdCard.java : public class IdCard { private String id; private String address; public IdCard() { } public IdCard(String id, String address) { super(); this.id = id; this.address = address; } public String getId() { r

hibernate+mysql关联映射师遇到java.lang.StackOverflowError异常

原因在进行关联映射时在多的一方的toString方法中有对属性对应的一的一方的输出 比如: 一的一方: @Entity@Table(name = "app",schema = "", catalog = "game")public class AppEntity { @Id @Column(name = "appId") private String appId; @Basic @Column(name = "app