Hibernate关联映射之一对多，多对一以及双向一对多

原創 甲如没有乙后 2020-02-21 16:35

在上篇博客我们讲了hibernate对单表的操作，本篇博客就来讲讲对多表的关联映射操作。首先我们拿来做例子的表为班级表1---n学生表，在这次的测试主键我用的是序列，创建代码如下：

--班级表
drop table classes;
create table classes(
       cid int primary key,
       cname varchar2(50)
);

drop sequence seq_classes_cid;
create sequence seq_classes_cid
       START WITH 1000    -- 从1000开始计数 
       INCREMENT BY 1     -- 每次加1个

--学生表
drop table student;
create table student(
       sid int primary key,
       sname varchar2(50),
       cid int constraint FK_student_cid references classes(cid)
);

drop sequence seq_student_sId;
create sequence seq_student_sId
       START WITH 1000    -- 从1000开始计数 
       INCREMENT BY 1     -- 每次加1个


对于使用hibernate我们都需要配置cfg文件，所以在此贴出我的cfg文件
<?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.username">hibernate</property>
		<property name="connection.password">a</property>
		<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
		<property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
		<!-- 方言 -->
		<property name="dialect">org.hibernate.dialect.OracleDialect</property>

		<!-- 是否在运行的时候显示sql语句 -->
		<property name="show_sql">true</property>
		<!-- 显示的sql语句是否进行排版 -->
		<property name="format_sql">true</property>
		<!-- 表结构生成策略 -->
		<property name="hbm2ddl.auto">update</property>
		<!-- getCurrentSession所需的参数(本地事务) -->
		<property name="hibernate.current_session_context_class">thread</property>

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

一对多的关联关系

1.首先我们需要编写学生和班级的实体类
package com.yc.entity;

import java.io.Serializable;

public class Student implements Serializable{
	private static final long serialVersionUID = 3914237588346266940L;

	private int sid;
	private String sname;

	public Student() {
	}
	public Student(String sname) {
		this.sname = sname;
	}
	public Student(int sid, String sname) {
		this.sid = sid;
		this.sname = sname;
	}

	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}

	public String toString() {
		return "Student [sid=" + sid + ", sname=" + sname + "]";
	}
}
package com.yc.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

public class Classes implements Serializable {
	private static final long serialVersionUID = 948637569053708320L;

	private int cid;
	private String cname;
	//在一方定义一个多方的集合 一对多
	private Set<Student> students=new HashSet<Student>();

	public Classes() {

	}
	public Classes(String cname) {
		this.cname = cname;
	}
	public Classes(int cid, String cname, Set<Student> students) {
		this.cid = cid;
		this.cname = cname;
		this.students = students;
	}

	public int getCid() {
		return cid;
	}
	public void setCid(int cid) {
		this.cid = cid;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}

	public String toString() {
		return "Classes [cid=" + cid + ", cname=" + cname + ", students="
				+ students + "]";
	}
}

2.根据实体类创建对应的hbm文件
Student.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-8-12 19:33:30 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.yc.entity.Student" table="STUDENT">
        <id name="sid" type="int">
            <column name="SID" />
            <generator class="sequence" >
            	<param name="sequence">seq_student_sId</param>
            </generator>
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" />
        </property>
    </class>
</hibernate-mapping>
Classes.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-8-12 19:33:30 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.yc.entity.Classes" table="CLASSES">
        <id name="cid" type="int">
            <column name="CID" />
            <generator class="sequence" >
            	<param name="sequence">seq_classes_cid</param>
            </generator>
        </id>
        <property name="cname" type="java.lang.String">
            <column name="CNAME" />
        </property>
        <!-- 配置单向的一对多关联关系 -->
        <set name="students" table="STUDENT" inverse="false" lazy="true">
        	<!-- 指定关联的外键列 -->
            <key>
                <column name="CID" />
            </key>
            <one-to-many class="com.yc.entity.Student" />
        </set>
    </class>
</hibernate-mapping>

3.在cfg文件中加入映射路径
<!-- 测试一对多 -->
<mapping resource="Classes.hbm.xml" />
<mapping resource="Student.hbm.xml" />

4.编写测试类测试
package com.yc.test;

import java.util.Collections;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.yc.entity.Classes;
import com.yc.entity.Student;
import com.yc.utils.HibernateUtil;

public class MyTest {

	@Test
	//插入数据的测试
	public void testAdd() {
		Classes c=new Classes("龙宫");

		Student s1=new Student("龙太子");
		Student s2=new Student("玄彩娥");

		//如果希望在学生表中添加对应的班级编号，需要在班级中添加学生，建立关联关系
		Collections.addAll(c.getStudents(), s1,s2);

		Session session=HibernateUtil.getSession();
		Transaction transaction=session.beginTransaction();

		session.save(c);
		session.save(s1);
		session.save(s2);

		transaction.commit();
		HibernateUtil.closeSession(session);
	}

	@Test
	//查询班级中包含的学生
	public void testFind() {
		Session session=HibernateUtil.getSession();
		Classes c=(Classes) session.get(Classes.class, 1000);
		//建立关联关系后，可以方便的从一个对象导航到另一个对象
		System.out.println(c);
	}

	@Test
	//修改学生信息
	public void testUpdate() {
		Classes c=new Classes("普陀山");

		Session session=HibernateUtil.getSession();
		Transaction transaction=session.beginTransaction();

		Student s=(Student) session.get(Student.class, 1001);
		c.getStudents().add(s);

		session.save(c);

		transaction.commit();
		HibernateUtil.closeSession(session);
	}

	@Test
	//删除
	public void testDelete() {
		Session session=HibernateUtil.getSession();
		Transaction transaction=session.beginTransaction();

		Student s=(Student) session.get(Student.class, 1000);
		session.delete(s);

		transaction.commit();
		HibernateUtil.closeSession(session);
	}
}

5.测试结果，在这里我只贴出testAdd方法的测试结果，其余方法小伙伴门可以自己尝试


多对一的关联关系

在这里其实我们只需改变实体类中的属性以及对应的hbm文件即可，其实多对一更加符合我们的数据库表的设计
1.实体类
package com.yc.entity;

public class Student {
	private int sid;
	private String sname;
	private Classes cid; //多对一
	//在此就不贴出对应的set，get方法以及构造函数，toString方法
}
package com.yc.entity;

public class Classes {
	private int cid;
	private String cname;
	//在此就不贴出对应的set，get方法以及构造函数，toString方法
}

2.hbm文件
Student.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-8-12 20:59:00 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.yc.entity.Student" table="STUDENT">
        <id name="sid" type="int">
            <column name="SID" />
            <generator class="sequence" >
            	<param name="sequence">seq_student_sId</param>
            </generator>
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" />
        </property>
        <many-to-one name="cid" class="com.yc.entity.Classes" fetch="join">
            <column name="CID" />
        </many-to-one>
    </class>
</hibernate-mapping>
Classes.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-8-12 20:59:00 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.yc.entity.Classes" table="CLASSES">
        <id name="cid" type="int">
            <column name="CID" />
            <generator class="sequence" >
            	<param name="sequence">seq_classes_cid</param>
            </generator>
        </id>
        <property name="cname" type="java.lang.String">
            <column name="CNAME" />
        </property>
    </class>
</hibernate-mapping>

3.编写测试类运行
package com.yc.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.yc.entity.Classes;
import com.yc.entity.Student;
import com.yc.utils.HibernateUtil;

//测试多对一
public class MyTest2 {

	@Test
	//测试多对一
	public void testSave(){
		Classes ct=new Classes();
		ct.setCname("阴曹地府");

		Student st1=new Student();
		st1.setSname("杀破狼");

		Student st2=new Student();
		st2.setSname("骨精灵");

		//设置关联关系
		st1.setCid(ct);
		st2.setCid(ct);

		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();

		session.save(ct);
		session.save(st1);
		session.save(st2);

		tx.commit();
		HibernateUtil.closeSession(session);
	}

	@Test
	//测试多对一
	public void testFind(){
		Session session=HibernateUtil.getSession();

		Student s=(Student) session.get(Student.class,1002);
		System.out.println(s);

		HibernateUtil.closeSession(session);
	}
}

4.测试运行，同样在这里我只测试testSave方法

          

双向的一对多

其实双向的一对多就是将上述两种方法结合，以便于之后的操作
1.实体类
package com.yc.test3;

import java.io.Serializable;

public class Student3 implements Serializable{
	private static final long serialVersionUID = 4829740592306007293L;

	private int sid;
	private String sname;
	private Classes3 cid;
	//在此同样省略相应的方法
}




package com.yc.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

public class Classes implements Serializable {
	private static final long serialVersionUID = 948637569053708320L;

	private int cid;
	private String cname;
	//在一方定义一个多方的集合
	private Set<Student> students=new HashSet<Student>();

	//在此同样省略相应的方法
}



2.hbm文件


Student.hbm.xml


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-8-13 10:41:54 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.yc.entity.Student" table="STUDENT">
        <id name="sid" type="int">
            <column name="SID" />
            <generator class="sequence" >
            	<param name="sequence">seq_student_sId</param>
            </generator>
        </id>
        <property name="sname" type="java.lang.String">
            <column name="SNAME" />
        </property>
        <many-to-one name="cid" class="com.yc.entity.Classes" fetch="join">
            <column name="CID" />
        </many-to-one>
    </class>
</hibernate-mapping>

Classes.hbm.xml


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-8-13 10:41:54 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.yc.entity.Classes" table="CLASSES">
        <id name="cid" type="int">
            <column name="CID" />
            <generator class="sequence" >
            	<param name="sequence">seq_classes_cid</param>
            </generator>
        </id>
        <property name="cname" type="java.lang.String">
            <column name="CNAME" />
        </property>
        <set name="students" table="STUDENT" inverse="false" lazy="true" >
        	<!-- 指定关联的外键列 -->
            <key>
                <column name="CID" />
            </key>
            <one-to-many class="com.yc.entity.Student" />
        </set>
    </class>
</hibernate-mapping>



3.测试类


package com.yc.test;

import java.util.Collections;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.yc.entity.Classes;
import com.yc.entity.Student;
import com.yc.utils.HibernateUtil;

//测试双向一对多
public class MyTest3 {
	@Test
	//测试多对一
	public void testSave(){
		Classes c=new Classes("大唐官府");

		Student s1=new Student("剑侠客");
		Student s2=new Student("飞燕女");

		//设置关联关系
		Collections.addAll(c.getStudents(), s1,s2);
		s1.setCid(c);
		s2.setCid(c);

		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();

		session.save(c);
		session.save(s1);
		session.save(s2);

		tx.commit();

		HibernateUtil.closeSession(session);
	}

	@Test
	public void testFind(){
		Session session=HibernateUtil.getSession();

		Classes c=(Classes) session.get(Classes.class, 1002);
		Student s=(Student) session.get(Student.class, 1003);

		System.out.println(c);
		System.out.println(s);

		HibernateUtil.closeSession(session);
	}

	@Test
	//查询学生所在的班级的信息
	public void testFingStudentClass(){
		Session session=HibernateUtil.getSession();

		Student s=(Student) session.get(Student.class, 1003);

		System.out.println(s.getCid());

		HibernateUtil.closeSession(session);
	}
}



4.测试运行，一样这里只测试testSave方法









写到这里我突然想起一件事情，HibernateUtil的代码忘记贴了，下面是我的代码


package com.yc.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtil {
	private static SessionFactory sessionFactory;
	private static Session session;

	static{
		// 创建配置对象
		Configuration config = new Configuration().configure();
		// 创建服务注册对象
		ServiceRegistry serviceRegistry=new 
				ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
		// 创建会话工厂对象
		sessionFactory = config.buildSessionFactory(serviceRegistry);
	}

	public static Session getSession(){
		//创建会话对象
		session = sessionFactory.openSession();

		return session;
	}

	public static void closeSession(Session session){
		if(session!=null){
			//关闭会话
			session.close();
		}
	}
}





























甲如没有乙后



发布了36 篇原创文章 · 获赞 4 · 访问量 6万+





私信

关注

















發表評論














所有評論



還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.







相關文章








Hibernate的悲观锁、乐观锁介绍






鎖（ locking ） 業務邏輯的實現過程中，往往需要保證數據訪問的排他性。如在金融系統的日終結算處理中，我們希望針對某個 cut-off 時間點的數據進行處理，而不希望在結算進行過程中（可能是幾秒種，也可能是幾個小時），數據再發生變化






iteye_10602

2020-07-06 20:33:29









Hibernateday01学习笔记






Hibernate [冬眠]
   作用：JDBC在訪問數據庫的時候會產生很多的冗餘代碼，影響程序員的開發效率。爲了簡       化訪問數據庫的操作
對於程序而言最重要的是？ 數據
數據有怎麼樣的表現形式?
  1.內存[臨時數據 t






Tyan520

2020-07-08 07:40:42









Hibernate异常归总






使用hql查詢時的異常:Xxx is not mapped
描述：表引用問題
異常原因：沒有這個表的實體類
例如：數據庫表t_sys_menu，實體類Menu，hql編寫：from Menu，但是你可能寫成了from Menu






风流三月1

2020-07-08 06:23:40









NET(C#)连接各类数据库-集锦 --【C#网文收集系列】.






 1.C#連接連接Access程序代碼: -------------------------------------------------------------------------------
using System.Dat






cecoo

2020-07-08 06:13:57









Hibernate UUID生成配置






@Id@GeneratedValue(generator = "uuid")@GenericGenerator(name = "uuid", strategy = "uuid")@Column(name = "ID")private St






sleeper01

2020-07-08 05:28:55









hibernate入门学习记录






    現在做了一個關於hibernate的練習，感覺與寫JDBC最不同的地方就是不要寫sql，不要再把從數據庫中取到的值再一一賦給相應對象，只要填寫相應的配置文件就行，這樣可以減少掉很多工作。
   首先愛你，我們來看下對象關係映射（O






iteye_18095

2020-07-07 22:39:55









hibernate 映射 Map 值对象 简单映射






 接上篇hibernate 映射 List 值對象 簡單映射》
再將User對象做小小得修改，假設我們需要存儲工作過的部門，用map存儲部門作爲key,具體工作作爲value;
package com.ccay.test.valueCol






xyz0101123132

2020-07-07 21:58:45









连mybits工作原理都不懂，你敢说你自己会java？






雲棲號資訊：【點擊查看更多行業資訊】在這裏您可以找到不同行業的第一手的上雲資訊，還在等什麼，快來！
一、相較於Hibernate，mybatis的優勢在哪裏？
Hibernate缺點：
1、運行效率低，內存佔用比較嚴重2、針對單一對象的增






雲棲號資訊小哥

2020-07-07 15:58:51









Hibernate的锁






Hibernate的加鎖模式有：Ø LockMode.NONE ： 無鎖機制。Ø LockMode.WRITE ：Hibernate在Insert和Update記錄的時候會自動獲取。Ø LockMode.READ ： Hibernate在






xiang888

2020-07-07 11:18:53









struts.xml配置,三种调用方法的配置






1.使用method屬性調用方法
         <!-- 註冊請求 -->
         <action name="register" class="com.house.action.UserAction" method="do






wkj888888

2020-07-07 10:01:44









MySQL配置主从复制






初始環境
有一臺機器A安裝了MySQL5.7.20作爲主數據庫服務器，它已經運行了一段時間，具有小規模的數據。一個Web應用使用Spring+JPA+Hibernate來訪問這個數據庫。
目標
在機器B上安裝MySQL作爲slave數據庫






chang_harry

2020-07-07 08:37:58









Hibernate01-入门






一、搭建Hibernate環境
1、Hibernate框架簡介
Hibernate是數據持久化工具，也是一個開放源代碼的ORM解決方案。Hibernate內部封裝了通過JDBC訪問數據庫的操作，向上層應用提供面向對象的數據訪問






琬淇

2020-07-07 00:45:23









项目中遇到的问题以及解决方案（Java后台）






有經驗可以少走點彎路，所以走過的坑要記住，雖然我們不能兩次踏入同一條河流，但我們可能多次掉入同一個坑！
1、最近項目做一個關於批量修改或者增加記錄的功能，爲了方便，就手動寫一個saveOrUpdate（）函數，你可能會說這個hi






深山里的天空

2020-07-06 21:52:27









Hibernate 映射关系（基于注解）






提示：表與表之間的映射關係通過外鍵或中間表建立聯繫：
單向外鍵映射關係：這裏主要是指在兩個映射表對象類（一對一關係）之間只有一方包含另一方的引用，比如映射對象類A與映射表對象B之間，如果只有A中有一個屬性是對B的引用 priva






深山里的天空

2020-07-06 21:52:26









Hibernate中文手册






https://docs.jboss.org/hibernate/orm/3.5/reference/zh-CN/html/index.html






坚持吧骚年

2020-07-06 19:48:20