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

最新推荐文章于 2020-11-24 17:15:00 发布
最新推荐文章于 2020-11-24 17:15:00 发布
阅读量565 收藏
点赞数 1
文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuebing1995/article/details/72896338
版权

注意：我使用的是Hibernate5.2版本。

一、关联关系映射

单向关联:一对一、一对多、多对一。
使用连接表单向:一对一、一对多、多对一、多对多。
双向关联:一对一、一对多。
使用连接表的双向关联:一对一、一对多、多对多。

二、自动生成表

这里介绍一下Schema自动生成（Automatic schema generation）
可以从你的映射文件使用一个Hibernate工具生成DDL。 生成的schema包含有对实体和集合类表的完整性引用约束（主键和外键）。涉及到的标示符生成器所需的表和sequence也会同时生成。

在使用这个工具的时候，你必须 通过hibernate.dialet属性指定一个SQL方言(Dialet)，因为DDL是与供应商高度相关的。

首先，要定制你的映射文件，来改善生成的schema。

注意：以前的版本生成方法不同请查看具体API

前提配置好classname.hbm.xml和hibernate.xml

public void testCreadDB(){
        ServiceRegistry serviceRegistry=new StandardServiceRegistryBuilder().configure().build();
        Metadata metadataImplementor=new MetadataSources(serviceRegistry).buildMetadata();
     SchemaExport schemaExport=new SchemaExport();
     schemaExport.create(EnumSet.of(TargetType.DATABASE), metadataImplementor);
    }

三、单向一对多

Grade.java

package com.pojo;

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

import javassist.expr.NewArray;

public class Grade {
    private int id;
    private String name;
    private Set<Student> students=new HashSet<Student>(0);
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

Student.java

package com.pojo;
public class Student {
    private int id;
    private String name;
    private int age;
    //private Grade grade;

    // private int gradeId;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }


}

Grade.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.pojo">

    <class name="Grade" >
    <id name="id">
    <generator class="native" />
    </id>
    <property name="name" />
    <!-- set是grade中集合的属性    name属性名称-->
    <set name="students" table="student">
    <!-- key表示外键  colume外键列名  not-null外键不能空-->
    <key column="grade_id" not-null="true"></key>
    <!-- 一对多 -->
    <one-to-many  class="com.pojo.Student"/>
    </set>
    </class>

    </hibernate-mapping>

Student.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.pojo">

    <class name="Student" >
    <id name="id">
    <generator class="native" />
    </id>
    <property name="name" />
    <property name="age" />

    </class>

    </hibernate-mapping>

SessionFactoryUtil.java 单例创建sessionfactory

package com.util;

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

public class SessionFactoryUtil {
    private static SessionFactory  sessionfactory;
    private SessionFactoryUtil(){

    }
    public static SessionFactory getSessionFactory(){
        if(sessionfactory==null)
        {
            Configuration configuration=new Configuration();
            configuration.configure();

            sessionfactory=configuration.buildSessionFactory();
        }
        return sessionfactory;
    }

}

测试代码：

package com.test;

import java.util.Iterator;

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

import com.pojo.Grade;
import com.pojo.Student;
import com.util.SessionFactoryUtil;
public class StudentDemo {
    public static void main(String[] args) {
        StudentDemo studentDemo = new StudentDemo();
        studentDemo.oneTomany();
    }

    public void oneTomany() {
        // 单向一对多
        SessionFactory sessionFactory = SessionFactoryUtil.getSessionFactory();// 单例创建sessionfactory
        Session session = sessionFactory.openSession();// 创建session对象
        Transaction transaction = session.beginTransaction();// 开始事务
        // 添加数据
        Grade grade = new Grade();
        grade.setName("基础部");

        Student student = new Student();
        student.setName("沈雪冰");
        student.setAge(23);

        Student student2 = new Student();
        student2.setName("李四");
        student2.setAge(19);
        // 关联，建立单向关系
        grade.getStudents().add(student);
        grade.getStudents().add(student2);
        // 保存顺序根据外键来决定的，如果外键不能为null 那么先保存一的一端，否则随意保存
        session.save(grade);

        session.save(student);
        session.save(student2);

        transaction.commit(); // 提交事务

        // 取数据
        Grade gradetemp = session.get(Grade.class, 1);// 取出id为1的grade对象
        System.out.println("gradeName=" + gradetemp.getName());
        System.out.println("grade所对应的一对多数据为：");

        Iterator<Student> iterator = gradetemp.getStudents().iterator(); // 通过gradetemp获取student集合
        while (iterator.hasNext()) {
            // 取出student集合信息
            Student temp = iterator.next(); // 取到一个数据
            System.out.println("name=" + temp.getName() + ",age=" + temp.getAge());
        }

        session.close(); // 关闭session
    }

}

运行结果：

gradeName=基础部
grade所对应的一对多数据为：
name=沈雪冰,age=23
name=李四,age=19

四、单向多对一

Grade.java

package com.pojo;

public class Grade {
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

Studnet.java

package com.pojo;

public class Student {
    private int id;
    private String name;
    private int age;
    private Grade grade;
  // private int gradeId;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Grade getGrade() {
        return grade;
    }
    public void setGrade(Grade grade) {
        this.grade = grade;
    }
}

Grade.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.pojo">

    <class name="Grade" >
    <id name="id">
    <generator class="native" />
    </id>
    <property name="name" />

    </class>

    </hibernate-mapping>

Student.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.pojo">

    <class name="Student" >
    <id name="id">
    <generator class="native" />
    </id>
    <property name="name" />
    <property name="age" />
    <!--
        many-to-one属性:
        * name:关联映射的（一那方的）属性名字。
        * column:和一那方关联的表的外键。数据库字段
        * class:name属性对应持久化类的全路径。
        * not-null:是否允许为空。
      -->
    <many-to-one name="grade" class="Grade" 
    column="grade_id"  not-null="true" foreign-key="FKgrade"
    ></many-to-one>
    </class>





    </hibernate-mapping>

测试代码：

package com.test;

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

import com.pojo.Grade;
import com.pojo.Student;
import com.util.SessionFactoryUtil;

public class StudentDemo {
    public static void main(String[] args) {
        StudentDemo studentDemo=new StudentDemo();
        studentDemo.manytoOne();
    }
    public void manytoOne(){
        //单向多对一
                SessionFactory sessionFactory=SessionFactoryUtil.getSessionFactory();//单例创建
                Session session=sessionFactory.openSession();//创建一个session
                Transaction transaction=session.beginTransaction();//开始事务
                //添加数据
                Grade grade=new Grade();
                grade.setName("基础部");


                Student student=new Student();
                student.setName("沈雪冰");
                student.setAge(23);
                student.setGrade(grade);
                Student student2=new Student();
                student2.setName("李四");
                student2.setAge(19);
                student2.setGrade(grade);

                Student student3=new Student();
                student3.setName("王麻子");
                student3.setAge(30);
                student3.setGrade(grade);
                //保存数据
                session.save(grade);
                session.save(student);
                session.save(student2);
                session.save(student3);

                transaction.commit();//提交数据
                session.close();//关闭数据


                //取数据
                Grade temp=new Grade();             
                Grade temp2=new Grade();
                Grade temp3=new Grade();
                System.out.println("多对一：");
                System.out.println("每位学生所对应数据：");
                temp=student.getGrade();//取出student对应的grade
                System.out.println("name="+student.getName()+"，age="+student.getAge()+"，grade="+temp.getName());
                temp2=student2.getGrade();//取出student3对应的grade
                System.out.println("name="+student2.getName()+"，age="+student2.getAge()+"，grade="+temp2.getName());
                temp3=student3.getGrade();//取出student3对应的grade
                System.out.println("name="+student3.getName()+"，age="+student3.getAge()+"，grade="+temp3.getName());

    }


}

运行结果：

多对一：
每位学生所对应数据：
name=沈雪冰，age=23，grade=基础部
name=李四，age=19，grade=基础部
name=王麻子，age=30，grade=基础部

五、双向一对多

Grade.java

package com.pojo;

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

import javassist.expr.NewArray;

public class Grade {
    private int id;
    private String name;
    private Set<Student> students=new HashSet<Student>(0);
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

Student.java

package com.pojo;
/**
***********************************
*
*@类名    Student
*@时间    2017年6月5日下午3:11:28
*@作者    沈雪冰
*@描述    
*
***********************************
*/
public class Student {
    private int id;
    private String name;
    private int age;
    private Grade grade;
  // private int gradeId;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
     public Grade getGrade() {
            return grade;
        }
        public void setGrade(Grade grade) {
            this.grade = grade;
        }

}

Grade.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.pojo">

    <class name="Grade" >
    <id name="id">
    <generator class="native" />
    </id>
    <property name="name" />
    <!-- set是grade中集合的属性    name属性名称
    -->
    <set name="students" table="student" >
    <!-- key表示外键  colume外键列名  not-null外键不能空-->
    <key column="grade_id" not-null="true"></key>
    <!-- 一对多 -->
    <one-to-many  class="com.pojo.Student"/>
    </set>
    </class>

    </hibernate-mapping>

Student.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.pojo">

    <class name="Student" >
    <id name="id">
    <generator class="native" />
    </id>
    <property name="name" />
    <property name="age" />

    </class>

    </hibernate-mapping>

测试代码：

package com.test;

import java.util.Iterator;

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

import com.pojo.Grade;
import com.pojo.Student;
import com.util.SessionFactoryUtil;


public class StudentDemo {
    public static void main(String[] args) {
        StudentDemo studentDemo = new StudentDemo();
        studentDemo.oneTomany();
    }

    public void oneTomany() {
        // 双向一对多
        SessionFactory sessionFactory = SessionFactoryUtil.getSessionFactory();// 单例创建sessionfactory
        Session session = sessionFactory.openSession();// 创建session
        Transaction transaction = session.beginTransaction();// 开始事务

        Grade grade = new Grade();
        grade.setName("基础部");

        Student student = new Student();
        student.setName("沈雪冰");
        student.setAge(23);

        Student student2 = new Student();
        student2.setName("李四");
        student2.setAge(19);
        // 建立双向关系
        grade.getStudents().add(student);
        grade.getStudents().add(student2);
        student.setGrade(grade);
        student2.setGrade(grade);
        // 保存顺序根据外键来决定的，如果外键不能为null 那么先保存一的一端，否则随意保存
        session.save(grade);

        session.save(student);
        session.save(student2);

        transaction.commit(); // 提交事务

        // 取数据
        Grade gradetemp = session.get(Grade.class, 1); // 获取id为1grade对象
        System.out.println("gradeName=" + grade.getName());
        System.out.println("grade所对应的一对多数据为：");
        Iterator<Student> iterator = gradetemp.getStudents().iterator();// 这里的学生信息是根据gradetemp信息获取的

        while (iterator.hasNext()) {
            Student temp = iterator.next(); // 取到一个数据
            System.out.println("name=" + temp.getName() + ",age=" + temp.getAge() + "" + ",gradename="
                    + temp.getGrade().getName());// 这里的grade信息是通过student信息获取的
        }

        session.close(); // 关闭session
    }

}

运行结果：
要注意和上边单向一对多的区别

gradeName=基础部
grade所对应的一对多数据为：
name=沈雪冰,age=23,gradename=基础部
name=李四,age=19,gradename=基础部
离水的鱼儿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
hibernate一对多关联映射（单向关联）
03-01
博文链接：https://llying.iteye.com/blog/220809
Hibernate - 单向一对多关联关系映射
小小默：进无止境
10-10 504
上篇博文描述了Hibernate - 单向多对一关联关系映射，本篇博文继续学习单向一对多关系映射。 【1】修改Customer和Order Customer修改如下： public class Customer { private Integer customerId; private String customerName; private Set&amp;amp;lt;Order&amp;amp;gt; orde...
Hibernate一对多(单向)
乐在其中/Leo在其中
09-09 145
[正文]:    Hibernate一对多关联，例如一个用户有多张银行卡(只考虑用户到银行卡的单向一对多关联)。由于是学习Hibernate原理，并没有使用工具自动生成代码等。    单向一对多关联只需要在"一方"进行配置即可，"多方"无需额外配置。a.Java程序中所要做的一对多:public class User{    ...    private Set&lt;Card&gt; cards...
hibernate单向一对多关联
yangsong158的专栏
03-14 179
有这样一个应用场景，有一张用户表(APM_USER），一张部门表(APM_DEPT)。用户和部门之间的关系是多对一（many to one)。考虑到其他一些特殊情况。虽然实际情况，部门对用户是多对一（many to one)。实际上，删除一个部门的时候，为保险起见，不需要级联删除用户信息，查出部门对联时，也不需要查出部门内的所有员工。因此做成了单向多对一关联。 具体建表SQL如下：   -...
单向关联和双向关联
Mark_Eleven的学习笔记
10-22 6823
单向和双向关联的区别 单向和双向关联的区别就在于，两个类是否需要互相知道。 如果类A需要知道类B，而类B也需要知道类A，那么这两个类就应该是双向关联的； 而如果只需要类A知道类B，而不需要类B知道类A，那么就是单向关联。 参见 关联与依赖的对比： 相似之处： 关联暗示了依赖，二者都用来表示无法用聚合和组合表示的关系。 区别： 发生依赖关系的两个类都不会增加属性。其中的一个类作为另一个类的方...
hibernate一对多关联映射学习小结
08-29
在Hibernate中，一对多关联映射和多对一关联映射的区别在于维护的关系不同。多对一关联映射中，多的一端维护一的一端的关系，在加载多的一端时，可以将一的一端加载上来。一对多关联映射中，一的一端维护多的一端的...
JSP开发之hibernate之单向多对一关联的实例
10-19
要实现单向多对一关联，我们需要在Hibernate映射文件中进行定义，同时在Java代码中体现这种关联关系。具体步骤如下： 1. **映射文件配置**：在映射文件中，需要为多的一方配置`<many-to-one>`元素，来指定它与另...
hibernate多对一单向关联关系实现源码
10-08
在Java的持久化框架Hibernate中，多对一（ManyToOne）关联关系是一种常见的对象关系映射（ORM）场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录，而另一个实体类可能只有一条对应的记录。例如...
Java的Hibernate框架中一对多的单向和双向关联映射
09-02
在Java的Hibernate框架中，一对多关联映射是一种常见的数据模型关系，用于表示一个实体（如班级）可以与多个其他实体（如学生）相关联。这种关系映射可以帮助简化数据库操作，使得在Java代码中处理这些关系变得更加...
Hibernnate单向一对多映射，多对一映射
silence2015的专栏
02-04 1974
我们大家都知道，在域模型(实体域)中，关联关系是类与类之间最普遍的关系，他是指通过一个对象持有另一个对象的实例根据UML语言，关系是有方向的。实质上关联映射的本质：将关联关系映射到数据库，所谓的关联关系是对象模型在内存中的一个或多个引用。搞清关联映射的的关键就在于搞清实体之间的关系。 单向一对多： 所谓单向一对多，就是实体之间的关系由“一” 的一端加载“多” 的一端，关系由“一”的一端
hibernate 多对多全注解（单向关联、双向关联）
09-13
hibernate关联映射注解多对多单向关联、
Hibernate之单向一对多映射(使用maven构建)
躺着写代码的博客
10-08 318
在实际开发中，一对多的例子有很多，比如一个部门对应多个员工，这就是一种典型一对多的关系，在Hibernate中使用一对多映射可以使用一方来管理多方，这显然是很方便的。在本例中，使用了2个实体，一是员工employee，另外一个是部门department。 首先创建2张表： 接下来就是创建一个project了，整个工程的骨架如下图所示： 先看pom.xml: <project
Hibernate中单向一对多，单向多对一，双向一对多 inverse="true" casecade="save-update"的理解
myitsite的博客
10-18 854
Customer类：  Java代码   public class Customer {        private int id;        private String name;   private Set orders = new HashSet();   •••   }   即Customer类具有一个set集合属性orders，其中Or
Hibernate的一对多映射的单向关联和双向关联(九)
两个蝴蝶飞
02-16 1150
非常对不起，老蝴蝶由于生活和工作上的事情太忙，无法及时更新，造成了将近三个月的停更。以后，会更加努力的。为了IT,加油。 上一章简单介绍了Hibernate的一对一映射(八),如果没有看过，[请观看上一章](https://blog.csdn.net/yjltx1234csdn/article/details/83241189) ...
hibernate之单向一对多关系
皮蛋小粥的博客
05-25 411
hibernate中单向一对多关系：    做留言板项目的发现自己hibernate种对表之间的关系有些陌生，之前一段时间，粗略的复习和se的东西以及数据结构的知识，想尽量让自己知道的东西更多一点，希望能在暑假可以找到一份实习的工作，让自己大四能彻底来一次接触社会。    我学习过的hibernate中有单向一对多关联，单向多对一关联，以及多对多的关联。    单向一对多，我理解是数据库中，
Hibernate单向一对多关联
了凡
04-12 764
如何在数据库中表示一个班级有多个学生？或者说一个学生属于某个班级？ 在数据库中，可以通过添加主外键的关联，表现一对多的关系。如何在Java或者Hibernate中表示如上的关系？ 通过在一方持有多方的集合实现，即在”一”的一端中使用<set>元素表示持有”多”的一端的对象。单向一对多关联在数据库创建grade班级表，student学生表，并添加外键约束。SQL语句为：create table g
Hibernate单向一对多对象关系模型映射
光何
11-24 198
1 hibernate的对象关系映射 Orm: 类-----表 属性------字段 对象------记录 表：在数据库中存在主外键的关系，反向工厂类是由表生成，在由表生成类的时候，类和类之间存在者某个关系。将数据库的主外键关系，在java类型进行体现和维护(建立数据之间的关系和断开关系)。 2 单向的one-to-many 家庭和成员(家庭和成员之间的关系，是由家庭进行体现，成员不体现) 父亲和子女 班级和学生 …… 2.1 单向one-to-m...
Hibernate实现单向一对多
ahliu9613123的博客
12-22 120
hibernate可以很简单的实现数据库中的各种关系 下面是一个单向一对多的例子 假设一个渣男有多个女朋友 一个简单的单向一对多的例子 首先需要在配置文件中配置两个pojo <mapping class="qdm.entity.onetomany.GarbageMan" /> <mapping class="qdm.e...
Hibernate中的单向一对多关联
梦空间
05-19 2777
源自 imooc 中的学习        Hibernate中的单向一对多关联，这里举例 班级对学生 的单向一对多关联，即一个班级可以有多个学生。        那么在Hibernate中实体对象间如何体现出单向一对多的关联关系呢？如 班级对学生 这个例子而言，单向一对多关联，可以在“一方”添加 一个集合，如 Set集合，其中集合中保存“多”方的信息，如 班级类 中添加 一个集合，这里采用Se
Hibernate映射详解：单向多对一关联关系
"这篇文稿主要介绍了Hibernate中的各种映射关系，特别强调了单向多对一关联映射（many-to-one）。" 在 Hibernate 中，映射关系是数据模型到对象模型的转换，有助于处理数据库中的关联。这篇文章简单概述了 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

离水的鱼儿

一分也是爱

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值