一:多对一单向关联

首先我们必须创建两个实体类

例如: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 ename;

     private  Dept dept;

 

现在我们可以在配置文件里面配置了

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.entity">
    <class name="Dept" table="Dept">
        <id name="deptNo" column="deptNo">
            <generator class="native"/>
        </id>
        <property name="dName" type="string" column="dName"/>
           <property name="loc" type="string" column="loc"/>
           <!--cascade:级联     inverse:反转 -->
           <set name="emps" cascade="save-update" inverse="true" >
           <key column="deptNo"></key>
           <!--一对多  -->
           <one-to-many class="Employee"/>
           </set>
    </class>
</hibernate-mapping>

Employee.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.entity">
    <class name="Employee" table="Employee">
        <id name="empno" column="empno">
            <generator class="native"/>
        </id>
        <property name="ename" type="string" column="ename"/>
        <!--多对一  -->
        <many-to-one name="dept" column="deptNo" class="Dept"></many-to-one>

        <set name="projects" inverse="true" table="proemp">
        <key column="rempNo"></key>
        <many-to-many class="Project" column="rproNo"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

到这里,一对多 和多对一的关联 配置已经完成!!

我们一起来看看测试类

// 添加数据
    private static void addDeptAndEmployee() {
        Session currentSession = HibernateUtil.currentSession();
        currentSession.beginTransaction();
        Dept dept = new Dept();
        //dept.setDeptNo(deptNo)
        dept.setdName("质管部22");
        dept.setLoc("北京22");
        Employee emp = new Employee();
        emp.setEname("龙龙");
        emp.setDept(dept);//建立dept 到employee 对象的 关联
        currentSession.save(emp);
        currentSession.save(dept);
        currentSession.getTransaction().commit();
        HibernateUtil.closeSessio();
        System.out.println("add  ok");

    }

 

// 级联保存   cascade:级联
    private static void addDeptAndEmployeeTocascade() {
        Session currentSession = HibernateUtil.currentSession();
        currentSession.beginTransaction();
        Dept dept = new Dept();
        // dept.setDeptNo(deptNo)
        dept.setdName("质管部22");
        dept.setLoc("北京22");
        Employee emp = new Employee();
        emp.setEname("龙龙");
        // 建立Dept对象 和Employee 对象的 一对多 双向关系
        emp.setDept(dept);
        dept.getEmps().add(emp);//
        currentSession.save(dept);
        currentSession.getTransaction().commit();
        HibernateUtil.closeSessio();
        System.out.println("add  ok");

    }

 

我们谈到关联映射的多对多配置呢,有一种挺不好配置的,所以呢,就放到了这里给大家参考

第一种:建立多对多双向关联 拆成两个一对多

三个实体类

Employee

 private Integer empno;
     private String ename;

     private  Dept dept;
     );//集合 类 employee的属性
     );

Project

private Integer proNo;//项目的编号
private  String proName;//项目名称
private  Set<Employee> employees=new  HashSet<Employee>(0);//集合 类 employee的属性
private Set<ProEmp> pe=new HashSet<ProEmp>(0);

中间表

ProEmp

private Integer id;
    private Project pro;
    private Employee emp;

映射文件

Employee.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.three.entity">
    <class name="Employee" table="Employee">
        <id name="empno" column="empno">
            <generator class="native"/>
        </id>
        <property name="ename" type="string" column="ename"/>
    </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.three.entity">
    <class name="Project" table="Project">
        <id name="proNo" column="proNo">
            <generator class="native"/>
        </id>
        <property name="proName" type="string" column="proName"/>
    </class>
</hibernate-mapping>

ProEmp.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.three.entity">
    <class name="ProEmp" table="ProEmp">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
          <!-- 与员工关联 -->
        <many-to-one name="emp" column="empno" class="Employee"></many-to-one>
   <!-- -与project关联 -->
     <many-to-one name="pro" class="Project" column="proNo"></many-to-one>
    </class>
</hibernate-mapping>

大配置文件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.driver.OracleDriver
        </property>
        <property name="connection.url">
            jdbc:oracle:thin:@localhost:1521:orcl
        </property>
        <property name="connection.username">wgy</property>
        <property name="connection.password">jpp</property>

        <!-- JDBC connection pool (use the built-in) -->

        <property name="connection.pool_size">1</property>

        <!-- SQL dialect --><!-- SQL 方言 -->

        <property name="dialect">
            org.hibernate.dialect.Oracle10gDialect
        </property>

        <!-- Enable Hibernate's automatic session context management -->
        <!-- <property name="current_session_context_class">thread</property>
        -->
        <!-- Disable the second-level cache -->
        <!-- <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
        -->
        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <!--序列化  -->
        <property name="hbm2ddl.auto">create</property>
        <!-- <property name="hbm2ddl.auto">update</property> -->
        <!-- sql语句格式化 -->
        <property name="format_sql">true</property>
        <!-- 资源 -->

        <<mapping resource="cn/three/entity/Dept.hbm.xml" />
         <mapping resource="cn/three/entity/Employee.hbm.xml" />
         <mapping resource="cn/three/entity/Project.hbm.xml" /> 

    </session-factory>
</hibernate-configuration>

测试类看一下效果

package cn.main;

import org.hibernate.Session;

import cn.three.entity.ProEmp;
import cn.three.entity.Employee;
import cn.three.entity.Project;
import cn.util.HibernateUtil;

public class ThreeTest {
public static void main(String[] args) {
    //三表一起
        threeAddEmpAndProAndProEmp();
}
private static void threeAddEmpAndProAndProEmp() {
    Session session = HibernateUtil.currentSession();
    session.beginTransaction();
    Employee emp=new Employee();
    Project pro=new Project();
    emp.setEname("李四");
    pro.setProName("一号项目");
    ProEmp pe=new ProEmp();
    pe.setEmp(emp);
    pe.setPro(pro);
    session.save(pro);
    session.save(emp);
    session.save(pe);
    session.getTransaction().commit();
    HibernateUtil.closeSessio();
    System.out.println("add ok");

}
}

第二种:不用拆成两个一对多

只需要两个映射文件,即可

Employee.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.entity">
    <class name="Employee" table="Employee">
        <id name="empno" column="empno">
            <generator class="native"/>
        </id>
        <property name="ename" type="string" column="ename"/>
        <!--多对一  -->
        <many-to-one name="dept" column="deptNo" class="Dept"></many-to-one>
        <!--多对多双向关联  -->
        <set name="projects" inverse="true" table="proemp">
        <key column="rempNo"></key>
        <many-to-many class="Project" column="rproNo"></many-to-many>
        </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.entity">
    <class name="Project" table="Project">
        <id name="proNo" column="proNo">
            <generator class="native"/>
        </id>
        <property name="proName" type="string" column="proName"/>
      <!--配置单向多对多关联  -->
        <!-- 映射project 类的employees的属性 -->
        <!--cascade="save-update":表名保存或更新project对象时,会级联保存或更新与它关联的Employee对象  -->
        <set name="employees" table="proemp" cascade="save-update">
         <key column="rproNo"></key>
         <many-to-many class="Employee" column="rempNo"></many-to-many>
        </set>
    </class>
</hibernate-mapping>
测试类


复制代码
private static void addProToEmpAndEmpToPro() {
    Session session = HibernateUtil.currentSession();
    session.beginTransaction();
    Employee emp=new Employee();

    Project pro=new Project();

    emp.setEname("李四");

    pro.setProName("一号项目");

    pro.getEmployees().add(emp);
    session.save(pro);
    session.getTransaction().commit();
    HibernateUtil.closeSessio();
    System.out.println("add ok");

这样就可以了,有问题在线解答!!!!!

Hibernate关联映射 映射文件的配置的更多相关文章

  1. hibernate关联非主键注解配置

    现在有两张表:一张t_s_user用户表和t_s_user_serial_number用户序号表 CREATE TABLE `t_s_user` ( `id` ) NOT NULL, `email` ...

  2. hibernate映射xml文件配置之一对多,多对多

    一对多配置 [1]班级和学生模型 --->班级可容纳多个学生 --->学生只能属于一个班级 [2]一对多配置中的关系维护(inverse) --->一端放弃关系的维护 ---> ...

  3. Java三大框架之——Hibernate关联映射与级联操作

    什么是Hibernate中的关联映射? 简单来说Hibernate是ORM映射的持久层框架,全称是(Object Relational Mapping),即对象关系映射. 它将数据库中的表映射成对应的 ...

  4. Hibernate 配置文件与映射文件 总结

    hibernate是一个彻底的ORM(Object Relational Mapping,对象关系映射)开源框架. 一.Hibernate配置文件详解 Hibernate配置文件有两种形式:XML与p ...

  5. Hibernate关联映射及高级查询

    一.Hibernate中的关联关系 1.1.单向一对多关联关系 按照以下步骤配置hibernate中持久化类的一对多对象关联: (1).持久化类添加关联类的相关属性及getter/setter方法. ...

  6. 第六章 Hibernate关联映射

    第六章 hibernate关联映射一.本章知识点分为2部分:1.关联关系:单向多对一关联关系,双向一对多关联关系(含一对多关联关系),多对多关联关系2.延迟加载:类级别加载策略,一对多加载策略,多对一 ...

  7. 第三章Hibernate关联映射

    第三章Hibernate关联映射 一.关联关系 类与类之间最普通的关系就是关联关系,而且关联是有方向的. 以部门和员工为列,一个部门下有多个员工,而一个员工只能属于一个部门,从员工到部门就是多对一关联 ...

  8. 【转】hibernate中的映射文件xxx.hbm.xml详解总结

    一.Hibernate映射文件的作用: Hibernate映射文件是Hibernate与数据库进行持久化的桥梁 二,Hibernate映射文件主要内容:     (1).映射内容的定义: Hibern ...

  9. 分享知识-快乐自己:Hibernate 关联映射

    关联关系映射--概念: 关联关系是使用最多的一种关系,非常重要.在内存中反映为实体关系,映射到DB中为主外键关系. 实体间的关联,即对外键的维护.关联关系的发生,即对外键数据的改变. 外键:外面的主键 ...

随机推荐

  1. 茂名石化BPM应用实践 ——业务协同及服务共享平台建设和应用

    一.茂名石化简介 茂名石化隶属于中国石油化工集团公司,创建于1955年,是国家"一五"期间156项重点项目之一.经过50多年的发展,茂名石化已成为我国生产规模最大的炼油化工企业之一 ...

  2. TCP/IP之Nagle算法与40ms延迟

    Nagle算法是针对网络上存在的微小分组可能会在广域网上造成拥塞而设计的.该算法要求一个TCP连接上最多只能有一个未被确认的未完成的小分组,在该分组确认到达之前不能发送其他的小分组.同时,TCP收集这 ...

  3. .NET Core 1.0.1 升级汇总

    ASP.NET Core BUG fix: ASP.NET Routing Port fix for "Request not matching route with defaults&qu ...

  4. [Xamarin] 透過Native Code呼叫 JavaScript function (转帖)

    今天我們來聊聊關於如何使用WebView 中的Javascript 來呼叫 Native Code 的部分 首先,你得先來看看這篇[Xamarin] 使用Webview 來做APP因為這篇文章至少講解 ...

  5. 开始mono开发

    使用mono框架开发android程序,第一步当然是构建开发环境,严格意义上说是使用 mono for android开发android程序. 参考Mono for Android安装配置破解  mo ...

  6. 【初探Spring】------Spring IOC(一)

    IOC:Inversion of Control(控制反转).IOC它所体现的并不是一种技术,而是一种思想,一种将设计好的对象交给容器来管理的思想.IOC的核心思想就体现在控制.反转这两个词上面,要理 ...

  7. ABP(现代ASP.NET样板开发框架)系列之18、ABP应用层——权限验证

    点这里进入ABP系列文章总目录 ABP(现代ASP.NET样板开发框架)系列之18.ABP应用层——权限验证 ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目 ...

  8. 同步与异步 & 阻塞与非阻塞

    在进行网络编程时,我们常常见到同步(Sync)/异步(Async),阻塞(Block)/非阻塞(Unblock)四种调用方式: 一.同步 所谓同步,就是在发出一个功能调用时,在没有得到结果之前,该调用 ...

  9. Python初学者之网络爬虫

    声明:本文内容和涉及到的代码仅限于个人学习,任何人不得作为商业用途. 本文将介绍我最近在学习Python过程中写的一个爬虫程序,将力争做到不需要有任何Python基础的程序员都能读懂.读者也可以先跳到 ...

  10. .net 分布式架构之分布式锁实现

    分布式锁 经常用于在解决分布式环境下的业务一致性和协调分布式环境. 实际业务场景中,比如说解决并发一瞬间的重复下单,重复确认收货,重复发现金券等. 使用分布式锁的场景一般不能太多. 开源地址:http ...