Hibernate 多对多 一对多 多对一 配置解析案例

最新推荐文章于 2018-08-09 12:01:00 发布
最新推荐文章于 2018-08-09 12:01:00 发布
阅读量183 收藏
点赞数
分类专栏： java 文章标签： oracle hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aa953629866/article/details/81213742
版权


  - 多对多
  - 一对多
  - 多对一
  - many-to-many
  - many-to-one
  - one-to-many
  - 关系映射
  - Hibernate
  - 关系映射
---

# 此案例用于理解脏检查,以及Hibernate关系映射的配置

 pom.xml```XML

 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com</groupId>
    <artifactId>HibernateCase</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.12.Final</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.hynnet/oracle-driver-ojdbc -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>12.1.0.2</version>
        </dependency>
    </dependencies>

</project>


## 数据库的关系

```SQL
--部门
CREATE TABLE depa(
    ID NUMBER NOT NULL,
    NAME NVARCHAR2 (50) NOT NULL
);

--职员
CREATE TABLE emp(
    ID NUMBER NOT NULL,
    NAME NVARCHAR2 (50) NOT NULL,
    depa_id NUMBER NOT NULL
);

--职位
CREATE TABLE post(
    ID NUMBER NOT NULL,
    NAME NVARCHAR2 (50) NOT NULL
);

--职员职位
CREATE TABLE emp_post(
    emp_id NUMBER NOT NULL,
    post_id NUMBER NOT NULL
);
```

`emp_post` 职员职位表为中间表,实体类可以不存在

## 实体类

### Depa

```java
package com.entity;

import java.util.HashSet;
import java.util.Set;

public class Depa {
    private Integer id;
    private String name;
    private Set<Emp> emps = new HashSet<Emp>();

    @Override
    public String toString() {
        return "Depa{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

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

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

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```

### Emp

```java
package com.entity;

import java.util.HashSet;
import java.util.Set;

public class Emp {
    private Integer id;
    private String name;
    private Depa depaid;
    private Set<Post> posts = new HashSet<Post>();

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public Set<Post> getPosts() {
        return posts;
    }

    public void setPosts(Set<Post> posts) {
        this.posts = posts;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Depa getDepaid() {
        return depaid;
    }

    public void setDepaid(Depa depaid) {
        this.depaid = depaid;
    }
}
```

### Post

```java
package com.entity;

import java.util.HashSet;
import java.util.Set;

public class Post {
    private Integer id;
    private String name;
    private Set<Emp> emps = new HashSet<Emp>();

    @Override
    public String toString() {
        return "Post{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

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

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

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```

 

`Emp` 实体类 和 `Post` 实体类 都有对方的 `Set<?>` 集合,这也是操作中间表 `emp_post` 的关键属性

## 对实体类关系映射配置

 depa.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="com.entity">
    <class name="Depa" table="depa">
        <id name="id">
            <generator class="increment"/>
        </id>
        <property name="name"/>


        <!--一对多 name为实体类属性名 class为对应外键对应实体类-->
        <!--table 实体类对象数据来源数据库表名 cascade维护方式-->
        <!--inverse 指定由哪一方来维护之间的关联关系 当一方中指定了"inverse=false"(默认),那么那一方就有责任负责之间的关联关系-->
   

     <set name="emps" table="emp" cascade="all" inverse="true">
            <!--column 为emp数据库关联depa的外键名-->
            <key column="depa_id"></key>
            <!--class emps的单个实体数据为哪个实体类-->
            <one-to-many class="Emp"/>
        </set>
    </class>


 

 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">
<!--package为命名空间 子节点有多个类的全在com.entity包里-->
<!--(如果不写,下面 <class name="Emp" name值"Emp"需要改成"com.entity.Emp")-->
<hibernate-mapping package="com.entity">
    <class name="Emp" table="emp">
        <!--主键-->
        <id name="id">
            <!--自增方式-->
            <generator class="increment"/>
        </id>
        <!--普通数据列-->
        <property name="name"/>
        <!--多对一 name为实体类属性名 class为对应外键对应实体类 column为数据库外键名(如果与name值一样可以忽略)-->
        <many-to-one name="depaid" class="Depa" column="depa_id"/>
        <!--多对多 name为实体类属性名 table 关联的中间表 cascade 维护方式 save-update 为维护方式是新增或修改-->
        <set name="posts" table="emp_post" cascade="save-update">
            <!--中间表emp_post 对应emp的外键-->
            <key column="emp_id"></key>
            <!--class 多对多的实体类 column 中间表emp_post 对应Post的外键-->
            <many-to-many class="Post" column="post_id"/>
        </set>
    </class>
</hibernate-mapping>


 

 post.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="com.entity">
    <class name="Post" table="post">
        <id name="id">
            <generator class="increment"/>
        </id>
        <property name="name"/>


        <!--多对多 name为实体类属性名 table 关联的中间表 cascade 维护方式 save-update 为维护方式是新增或修改-->
     

   <set name="emps" table="emp_post" cascade="save-update">
            <!--中间表emp_post 对应post的外键-->
            <key column="post_id"></key>
            <!--class 多对多的实体类 column 中间表emp_post 对应Emp的外键-->
            <many-to-many class="Emp" column="emp_id"/>
        </set>
    </class>

将实体类的 `XML` 映射到 hibernate.cfg.xml 配置

### hibernate.cfg.xml```XML

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
        <property name="connection.username">system</property>
        <property name="connection.password">simon</property>
        <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="current_session_context_class">thread</property>
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>

        <mapping resource="com/entity/depa.hbm.xml"/>
        <mapping resource="com/entity/emp.hbm.xml"/>
        <mapping resource="com/entity/post.hbm.xml"/>
    </session-factory>
</hibernate-configuration>


```

 Hibernate工具类 HibernateUtil

```java
package com.util;

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

public class HibernateUtil {
    private static Configuration configuration;
    private static final SessionFactory factory;

    static {
        configuration = new Configuration().configure("hibernate.cfg.xml");
        factory = configuration.buildSessionFactory();
    }

    public static Session getSession() {
        return factory.getCurrentSession();
    }
}
```

## 测试类 Test

package com.test;

import com.entity.Depa;
import com.entity.Emp;
import com.entity.Post;
import com.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class Test {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();

        System.out.println("查询ID为1的职员数据");
        Emp emp = session.get(Emp.class, 1);
        System.out.println(emp);

        System.out.println("通过职员得到中间表emp_post数据");
        for (Post post : emp.getPosts()) {
            System.out.println(post);
        }

        System.out.println("清除职员中间表emp_post的数据");
        emp.getPosts().clear();

        System.out.println("查询ID为2的职位数据");
        Post post = session.get(Post.class, 2);
        System.out.println(post);

        System.out.println("将查到的职位给职员新增中间表emp_post数据");
        emp.getPosts().add(post);

        System.out.println("查询ID为1的职员数据");
        emp = session.get(Emp.class, 1);
        System.out.println(emp);

        System.out.println("通过职员得到中间表emp_post数据");
        for (Post temp : emp.getPosts()) {
            System.out.println(temp);
        }

        System.out.println("通过职员得到部门表depa数据");
        System.out.println(emp.getDepaid());

        System.out.println("查询ID为1的部门数据");
        Depa depa = session.get(Depa.class, 1);
        System.out.println(depa);

        System.out.println("将查到的部门depa给职员emp利用脏检查修改");
        emp.setDepaid(depa);

        System.out.println("查询ID为1的职员数据");
        emp = session.get(Emp.class, 1);
        System.out.println(emp);

        System.out.println("通过职员得到部门表depa数据");
        System.out.println(emp.getDepaid());

        System.out.println("查询ID为2的部门数据");
        depa = session.get(Depa.class, 2);
        System.out.println(depa);

        System.out.println("得到部门对象所属职员");
        for (Emp e : depa.getEmps()) {
            System.out.println(e);
        }

        System.out.println("利用脏检查删除部门对象所属的ID为1的职员");
        depa.getEmps().remove(emp);

        System.out.println("查询ID为2的部门数据");
        depa = session.get(Depa.class, 2);
        System.out.println(depa);

        System.out.println("得到部门对象所属职员");
        for (Emp e : depa.getEmps()) {
            System.out.println(e);
        }

        //不提交,则上面的结果不会对数据库执行操作
//        transaction.commit();
    }
}
```

 控制台输出

看看测试类代码对数据库的数据进行了哪些操作

```
查询ID为1的职员数据

Hibernate:
    select
        emp0_.id as id1_1_0_,
        emp0_.name as name2_1_0_,
        emp0_.depa_id as depa_id3_1_0_
    from
        emp emp0_
    where
        emp0_.id=?
Emp{id=1, name='张三'}


通过职员得到中间表emp_post数据

Hibernate:
    select
        posts0_.emp_id as emp_id1_2_0_,
        posts0_.post_id as post_id2_2_0_,
        post1_.id as id1_3_1_,
        post1_.name as name2_3_1_
    from
        emp_post posts0_
    inner join
        post post1_
            on posts0_.post_id=post1_.id
    where
        posts0_.emp_id=?
Post{id=1, name='职员'}


清除职员中间表emp_post的数据
查询ID为2的职位数据

Hibernate:
    select
        post0_.id as id1_3_0_,
        post0_.name as name2_3_0_
    from
        post post0_
    where
        post0_.id=?
Post{id=2, name='主管'}


将查到的职位给职员新增中间表emp_post数据
查询ID为1的职员数据
Emp{id=1, name='张三'}
通过职员得到中间表emp_post数据
Post{id=2, name='主管'}
通过职员得到部门表depa数据

Hibernate:
    select
        depa0_.id as id1_0_0_,
        depa0_.name as name2_0_0_
    from
        depa depa0_
    where
        depa0_.id=?
Depa{id=2, name='美工部'}


查询ID为1的部门数据

Hibernate:
    select
        depa0_.id as id1_0_0_,
        depa0_.name as name2_0_0_
    from
        depa depa0_
    where
        depa0_.id=?
Depa{id=1, name='销售部'}


将查到的部门depa给职员emp利用脏检查修改
查询ID为1的职员数据
Emp{id=1, name='张三'}
通过职员得到部门表depa数据
Depa{id=1, name='销售部'}
查询ID为2的部门数据
Depa{id=2, name='美工部'}
得到部门对象所属职员

Hibernate:
    select
        emps0_.depa_id as depa_id3_1_0_,
        emps0_.id as id1_1_0_,
        emps0_.id as id1_1_1_,
        emps0_.name as name2_1_1_,
        emps0_.depa_id as depa_id3_1_1_
    from
        emp emps0_
    where
        emps0_.depa_id=?
Emp{id=1, name='张三'}


利用脏检查删除部门对象所属的ID为1的职员
查询ID为2的部门数据
Depa{id=2, name='美工部'}
得到部门对象所属职员
```

[点击下载案例] [1]

 https://gitee.com/admin-simon/HibernateCase/repository/archive/master.zip

Waiting for the wind
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate之多对多配置
小白的逆袭的博客
07-18 1722
在实际开发中，多对多的配置情况很少，一般都将多对多的情况拆分为两种一对多的情况，在此只做简单的配置。 以角色Role和用户User为例。 1，实体类配置        User: package com.myself.domain; import java.util.HashSet; import java.util.Set; public class User { private...
Hibernate之一对多配置
小白的逆袭的博客
07-17 358
在实际开发中，大部分表之间的关系为一对多的关系，在这里简单介绍下Hibernate在一对多的情况下mapping映射文件该怎么配置。 以客户Customer和联系人Linkmanwe为例：客户和联系人为一对多的关系。 1，实体类之间的配置 Customer: private Set&lt;Linkman&gt; linkmans = new HashSet&lt;Linkman&gt;(...
Hibernate多对一配置
yenairong的博客
11-17 82
Hibernate单向多对一配置： 多对一它的思想是在多的一方设置一的对象作为其属性。 比如学生和所在的班级为例。学生是多的一方，班级是一的一方。只要在学生类里面设置班级类的对像就完成了学生与班级之间的关联关系。   以学生和所在班级为例，这两个类是这样的： 班级类（是一的一方）：   package com.ye.models; /** * 类功能简单描述：这个是单向的多...
Hibernate1对多1对1多对多关联映射例子源码含xml配置
11-05
在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，这个是xml配置的例子
hibernate 多对一映射关联配置
03-16
NULL 博文链接：https://yinxiaoyong.iteye.com/blog/425782
hibernate一对多、多对一、一对一、多对多配置实例
08-02
NULL 博文链接：https://lichaobao.iteye.com/blog/1977048
Hibernate关联关系配置(一对多、一对一和多对多)
devlgdg1924的博客
05-08 186
第一种关联关系：一对多（多对一） “一对多”是最普遍的映射关系，简单来讲就如消费者与订单的关系。 一对多：从消费者角的度来说一个消费者可以有多个订单，即为一对多。 多对一：从订单的角度来说多个订单可以对应一个消费者，即为多对一。 一对多关系在hbm...
一对多单向关联关系实现元源码
10-08
在本案例中，我们将深入探讨如何实现一对多单向关联关系，并通过提供的源码进行分析。 首先，我们定义两个实体：一个是"一"端的实体，我们称它为`Parent`，另一个是"多"端的实体，我们称之为`Child`。在Hibernate中...
Hibernate双向一对多
03-12
通过这个项目，学习者可以深入理解Hibernate双向一对多关系的配置、使用及其实现细节，从而提升数据库操作和对象持久化的技能。实践中遇到的问题和解决方法也会帮助巩固理论知识，提升实际开发能力。
hibernate一对多，多对一，一对多双向关联
03-22
标题"hibernate一对多，多对一，一对多双向关联"指涉的是Hibernate框架中常见的关系映射概念。在数据库设计中，实体间的关系通常包括一对一（One-to-One）、一对多（One-to-Many）和多对一（Many-to-One）关系，而在...
hibernate 映射-一对多双向
04-22
标题中的“hibernate 映射-一对多双向”指的是在Java Hibernate框架中处理数据库关系映射中的一对多关联关系，并且这种关联是双向的。...在实际项目中，可以通过分析此类数据来设计和实现Hibernate的一对多双向映射。
hibernate4.3.8的annotation及xml的一对多的双向案例
01-18
本案例主要探讨的是Hibernate 4.3.8版本中如何使用注解和XML配置实现一对多的双向关联关系。这种关系在实际的业务场景中十分常见，例如一个用户可以有多个订单，一个订单对应一个用户。 首先，我们来看一下注解的...
Hibernate注解-多对一关系映射注解，一对多关系映射注解，多对多关系映射注解
litengbin的博客
02-01 746
多对一注解 把多对一改成用注解来实现 1. 把Category的id和name字段改为支持注解 注： 分类的getName上并没有加上@Column(name="name")，也可以达到映射的效果。 因为getName方法默认会被认为是字段映射。 除非加上了@Transient 才表示不进行映射 2. 把Product的getCategory进行多对一映射 @ManyToOne
Hibernate知识点小结(三)-->一对多与多对多配置
weixin_34375054的博客
08-09 88
一、多表关系与多表设计 1、多表关系 一对一： 表的设计原则(分表原则)： 优化表的性能 基于语意化分表 一对一的两张表 之间的关系怎么维护？ 主外键 相同主键值 ...
Hibernate 多对一配置
qishubiao的博客
10-06 486
Hibernate 多对一关联关系 many-to-one基本使用
Hibernate数据关联映射之一对多和多对一配置
自知的博客
05-19 312
Hibernate数据关联映射1.一对多关系配置以Emp（员工）表和Dept（部门）表为例，一个部门中有多个员工（一对多映射），多个员工可以同属于一个部门（多对一），一对多和多对一中，可以只配置其中一方。 在一对多中，需要在Dept类中添加Emp类所属的员工信息,首先定义实体类，此处省略set和get方法,Hibernate必须给实体类提供不带参数的构造方法，所以可不生成构造方法以下省略Hiber
hibernate中的一对多与多对一的配置参考
hello
07-15 2629
1.Employeepackage cn.itcast.b_one2Many; public class Employee { private int empId; private String empName; private double salary; //员工与部门（多对一） private Dept dept; public int getEmpId() { return empId;...
hibernate中的一对多与多对一的详细配置解析
mischen520的博客
08-10 1万+
1.Employee package cn.itcast.b_one2Many; public class Employee { private int empId; private String empName; private double salary; //员工与部门（多对一） private Dept dept; public int getEmpId() { r
resultMap中association的各个属性
热门推荐
念心的博客
07-08 2万+
resultMap中association的各个属性的含义： property:映射数据库列的字段或属性。 colum:数据库的列名或者列标签别名。 javaTyp:完整java类名或别名。 jdbcType支持的JDBC类型列表列出的JDBC类型。这个属性只在ins...
J2EE整合实战：Eclipse、Struts、Hibernate与Spring案例解析
"本书是关于J2EE开发的深度指南，特别关注Eclipse、Struts...这本书不仅是对J2EE开发的一次深入探索，也是提高实践技能的宝贵资源。通过跟随书中的步骤，读者可以深入了解这些技术的实际运用，从而提升自己的开发能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值