Hibernate学习笔记7（一对多关系的配置与操作）

于 2019-08-02 10:46:42 发布
阅读量243 收藏
点赞数
分类专栏： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40817827/article/details/97398159
版权
本文详细介绍了在Hibernate框架中如何配置一对多关系，并演示了如何进行一对多关系的保存、更新、删除等操作，包括级联操作的配置与应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据库表与表之间的关系

这个在mysql中有写过，这里再写一遍https://blog.csdn.net/qq_40817827/article/details/90637303

  • 一对多关系

    • 什么样关系属于一对多？
      一个部门对应多个员工，一个员工只能属于某一个部门。
      一个客户对应多个联系人，一个联系人只能属于某一个客户。
    • 一对多的建表原则：
      在这里插入图片描述

  • 多对多关系

    • 什么样关系属于多对多？
      一个学生可以选择多门课程，一门课程也可以被多个学生选择。
      一个用户可以选择多个角色，一个角色也可以被多个用户选择。
    • 多对多的建表原则：
    • 在这里插入图片描述

  • 一对一关系

    • 什么样关系属于一对一？
      一个公司只能有一个注册地址，一个注册地址只能被一个公司注册。
    • 一对一的建表原则：
      在这里插入图片描述

Hibernate一对多的关系配置

1.创建项目，引入jar包
2.创建数据库和表

CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

CREATE TABLE `cst_linkman` (
  `lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
  `lkm_name` varchar(16) DEFAULT NULL COMMENT '联系人姓名',
  `lkm_cust_id` bigint(32) DEFAULT NULL COMMENT '客户id',
  `lkm_gender` char(1) DEFAULT NULL COMMENT '联系人性别',
  `lkm_phone` varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
  `lkm_mobile` varchar(16) DEFAULT NULL COMMENT '联系人手机',
  `lkm_email` varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
  `lkm_qq` varchar(16) DEFAULT NULL COMMENT '联系人qq',
  `lkm_position` varchar(16) DEFAULT NULL COMMENT '联系人职位',
  `lkm_memo` varchar(512) DEFAULT NULL COMMENT '联系人备注',
  PRIMARY KEY (`lkm_id`),
   KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
  CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

在这里插入图片描述
在这里插入图片描述
3.创建实体

一的一方实体，放置多的一方集合

public class Customer {
	private Long cust_id;
	private String cust_name;
	private String cust_source;
	private String cust_industry;
	private String cust_level;
	private String cust_phone;
	private String cust_mobile;
	//通过ORM方式表示；一个客户对应多个联系人
	//放置的多的一方的集合，Hibernate默认使用Set集合
	private Set<LinkMan> LinkMans = new HashSet<LinkMan>();

多的一方实体，放置一的一方对象

public class LinkMan {
	private Long lkm_id;
	private String lkm_name;
	private String lkm_cust_id;
	private String lkm_gender;
	private String lkm_phone;
	private String lkm_mobile;
	private String lkm_email;
	private String lkm_qq;
	private String lkm_position;
	private String lkm_memo;
	//通过ORM方式表示：一个联系人只能属于某一个客户
	//放置的是一的一方的对象
	private Customer customer;

4创建映射文件

  • 多的一方的映射的创建
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
    <class name="domain.LinkMan"  table="cst_linkman">
    <!-- 建立OID和主键映射 -->
    <id name="lkm_id" column="lkm_id" >
    <!-- 主键生成策略 -->
    <generator class="native"/>
    </id>
    <!-- 建立普通属性与表字段映射 -->
      <property name="lkm_name"  />
		<property name="lkm_gender"  />
		<property name="lkm_phone" />
		<property name="lkm_mobile" />
		<property name="lkm_email" />
		<property name="lkm_qq" /> 
        <property name="lkm_position" /> 
        <property name="lkm_memo" /> 
   		<!-- 配置多对一的关系：放置的是一的一方的对象 -->
   		<!-- 
   			many-to-one标签
   			* name : 一的一方的对象的属性名称
   			*class ：一的一方的类的全路径
   			*column ：在多的一方的表的外键的名称
   		 -->
   		 <many-to-one name="customer" class="domain.Customer" column="lkm_cust_id"/>
    </class>
    </hibernate-mapping>
  • 一的一方的映射的创建
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<!-- 建立类与表的映射 -->
<class name="domain.Customer.java" table="cst_customer">
<!-- 建立类中的属性与表中的主键对应 -->
<id name="cust_id" column="cust_id" >
<!-- 主键生成策略 -->
			<generator class="native"/>
</id>
<!--  建立普通属性与数据库表字段映射        -->
		<property name="cust_name" column="cust_name"  />
		<property name="cust_source" column="cust_source" />
		<property name="cust_industry" column="cust_industry"/>
		<property name="cust_level" column="cust_level"/>
		<property name="cust_phone" column="cust_phone"/>
		<property name="cust_mobile" column="cust_mobile"/>
		 <!-- 配置一对多的映射：放置的多的一方的集合 -->
		 <!-- set标签   name:多的一方的对象集合的属性名称 -->
		 <set name="linkMans">
		 <!-- key标签    column:多的一方的外键名称 -->
		 <key column="lkm_cust_id"/>
		 <!--one-to-many标签    class:多的一方的类的全路径  -->
		 <one-to-many class="domain.LinkMan"/>
		 </set>
</class>
</hibernate-mapping>

5.创建核心配置
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>
	 		<!-- 连接数据库的基本参数 -->
	 		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
	 		<property name="hibernate.connection.url">jdbc:mysql:///hibernateday02</property>
		    <property name="hibernate.connection.username">root</property>
		    <property name="hibernate.connection.password">root</property>
		<!-- 配置Hibernate的方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<!-- 可选配置================ -->
		<!-- 打印SQL -->
		<property name="hibernate.show_sql">true</property>
		<!-- 格式化SQL -->
		<property name="hibernate.format_sql">true</property>
        <!-- 自动创建表 -->
		<property name="hibernate.hbm2ddl.auto">update</property>
		
		
		<!-- 配置C3P0连接池 -->
		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		<!--在连接池中可用的数据库连接的最少数目 -->
		<property name="c3p0.min_size">5</property>
		<!--在连接池中所有数据库连接的最大数目  -->
		<property name="c3p0.max_size">20</property>
		<!--设定数据库连接的过期时间,以秒为单位,
		如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
		<property name="c3p0.timeout">120</property>
		 <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
		<property name="c3p0.idle_test_period">3000</property>
		<!-- 设置事务隔离级别 -->
		<property name = "hibernate.connection.isolation">4</property>
		<!-- 配置当前线程绑定的Session -->
		<property name="hibernate.current_session_context_class">thread</property>
		<!-- 引入映射 -->
		<mapping resource="domain/Customer.hbm.xml"/>
		<mapping resource="domain/LinkMan.hbm.xml"/>
		</session-factory>
	</hibernate-configuration>

6.引入工具类

package hibernateUtils;

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

/*
 * 
 * Hibernate工具类
 * 
 * 
 */

public class HibernateUtils {
	public static final Configuration cfg;
	public static final SessionFactory sf;
	
	static {
		cfg=new Configuration().configure();
		sf=cfg.buildSessionFactory();
	}
	
	public static Session openSession() {
		return sf.openSession();
	}
	public static Session getCurrentSession() {
		return sf.getCurrentSession();
		
	}
	
	
}

7.测试类

package demo1;

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

import domain.Customer;
import domain.LinkMan;
import hibernateUtils.HibernateUtils;

/**
 * 
 * 一对多的测试类
 * 
 * 
 * @author ASUS
 *
 */
public class HibernateDemo1 {
@Test
//保存两个客户和三个联系人
public void demo1() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	
	//创建两个客户
	Customer customer1 = new Customer();
	customer1.setCust_name("张二");
	Customer customer2 = new Customer();
	customer2.setCust_name("张三");
	
	//创建三个联系人
	LinkMan linkman1 = new LinkMan();
	linkman1.setLkm_name("孙一");
	LinkMan linkman2 = new LinkMan();
	linkman2.setLkm_name("孙二");
	LinkMan linkman3 = new LinkMan();
	linkman3.setLkm_name("孙三");
	
	//设置关系
	linkman1.setCustomer(customer1);
	linkman2.setCustomer(customer1);
	linkman3.setCustomer(customer2);
	
	//保存数据
	session.save(customer1);
	session.save(customer2);
	session.save(linkman1);
	session.save(linkman2);
	session.save(linkman3);
	
	tx.commit();
}
}

在这里插入图片描述
可以看见数据已经插入数据库中

Hibernate的一对多相关操作

1. 一对多关系只保存一边是否可以

@Test
public void demo2() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	
	Customer customer = new Customer();
	customer.setCust_name("如花");
	
	LinkMan linkMan = new LinkMan();
	linkMan.setLkm_name("岁月");
	customer.getLinkMans().add(linkMan);
	linkMan.setCustomer(customer);
	//只保存一边是否可以，不可以，报一个瞬时对象异常：持久态对象关联了一个瞬时态对象
	//session.save(customer);
	session.save(linkMan);
	
	tx.commit();
}

在这里插入图片描述
瞬时对象异常
customer本来是瞬时的，sava()后变持久了，但联系人还是瞬时的，然后客户与之做了关联，现在就不能保存客户了

2.一对多的级联操作

  • 什么叫级联操作
    级联指的是，操作一个对象的时候，是否会操作其他关联对象
  • 级联是有方向性的
    操作一的一方的时候，是否操作到多的一方
    操作多的一方的时候，是否操作到一的一方

3.级联保存或更新

  • 保存客户级联联系人
@Test
/*
 * 级联保存或更新操作
 * 保存客户级联联系人，操作主体是客户对象，需要在Customer.hbm.xml中进行配置
 *  <set name="linkMans" cascade="save-update">
 * 
 */
public void demo3() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	
	Customer customer = new Customer();
	customer.setCust_name("如花");
	
	LinkMan linkMan = new LinkMan();
	linkMan.setLkm_name("岁月");
	customer.getLinkMans().add(linkMan);
	linkMan.setCustomer(customer);
	//只保存一边是否可以，不可以，报一个瞬时对象异常：持久态对象关联了一个瞬时态对象
	session.save(customer);
	//session.save(linkMan);
	
	tx.commit();
}
  • 保存联系人级联客户
/*
 * 级联保存或更新操作
 * 保存联系人级联客户，操作的主体是联系人对象，需要在LinkMan.hbm.xml中进行配置
 *  <many-to-one name="customer" cascade="save-update" class="domain.Customer" column="lkm_cust_id"/>
 */
@Test
public void demo4() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	
	Customer customer = new Customer();
	customer.setCust_name("如花2");
	
	LinkMan linkMan = new LinkMan();
	linkMan.setLkm_name("岁月2");
	customer.getLinkMans().add(linkMan);
	linkMan.setCustomer(customer);
	//只保存一边是否可以，不可以，报一个瞬时对象异常：持久态对象关联了一个瞬时态对象
	//session.save(customer);
	session.save(linkMan);
	
	tx.commit();
}

在这里插入图片描述
在这里插入图片描述
4.测试对象导航

/*
 
 * 测试对象的导航
 * 前提：一对多的双方都设置cascade="save-uodate"
 * 
 */
@Test
public void demo5() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	
	Customer customer = new Customer();
	customer.setCust_name("如花3");
	
	LinkMan linkMan1 = new LinkMan();
	linkMan1.setLkm_name("岁月3");
	LinkMan linkMan2 = new LinkMan();
	linkMan2.setLkm_name("岁月4");
	LinkMan linkMan3 = new LinkMan();
	linkMan3.setLkm_name("岁月5");
	
	linkMan1.setCustomer(customer);
	customer.getLinkMans().add(linkMan2);
	customer.getLinkMans().add(linkMan3);
	
	//双方都设置了cascade
	//session.save(linkMan1);//发送了几条insert语句 4条
	//首先保存联系人1，进入数据库，一条，联系人1又关联客户，客户进去，两条，客户又带进去2.3.一共4条
	session.save(customer);//发送几条 3条 客户和所关联的两个联系人
	session.save(linkMan2);//发送几条数据 1条
	
	tx.commit();
}

插入4条，后面同理
在这里插入图片描述
5.级联删除
删除一边的时候，同时将另一方的数据也一并删除。

  • 删除客户级联删除联系人
@Test
/*
 * 
 * 级联删除
 * 删除客户级联删除联系人，删除的主题是客户，需要在Customer.hbm.xml中配置
 * 
 * 
 * 
 * 删除客户，级联删除联系人，之前删除有联系的，jdbc是不能删除的，但hibernate可以
 *  <set name="linkMans" cascade="save-update,delete">
 */
public void demo6() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	
	//没有设置级联删除，默认情况,修改联系人的外键，删除客户
	//Customer customer = session.get(Customer.class,1l);
	//session.delete(customer);
	
	//删除客户，同时删除联系人
	Customer customer = session.get(Customer.class,1l);
	session.delete(customer);
	
	tx.commit();

}
  • 删除联系人级联删除客户（基本不用）
@Test
/*
 * 级联删除：删除联系人级联删除客户，删除的主体是联系人，需要在LinkMan.hbm.xml中配置
 * many-to-one name="customer" cascade="delete" 
 * 
 * 
 */
public void demo7(){
	
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	
	//删除客户，同时删除联系人
	LinkMan linkman = session.get(LinkMan.class, 3l);
	session.delete(linkman);
	
	tx.commit();
	
}

6.一对多设置了双向关联产生多余的sql语句
在这里插入图片描述

  • 解决多余的SQL语句
    单向维护：
    使一方放弃外键维护权：
    一的一方放弃。在set上配置inverse=”true”
    一对多的关联查询的修改的时候。

7.区分cascade和inverse

@Test
/*区分cascade和inverse区别 
 * 
 */
public void demo9() {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	
	Customer customer = new Customer();
	customer.setCust_name("李冰");
	
	LinkMan linkman = new LinkMan();
	linkman.setLkm_name("凤姐");
	
	customer.getLinkMans().add(linkman);
	//条件是在Customer.hbm.xml的set配置了cascade="save-update" inverse="true"
	
	session.save(customer);//客户和联系人都会插入到数据库，但外键null
	
	tx.commit();
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值