hibernate多表操作

hibernate多表操作

hibernate一对多关联映射

一对多建表原则

hibernate一对多的关系配置

在填写自己详细信息是会要求写到联系人，客户与联系人是一对多关系，一个客户可以有多个联系人，一个联系人只能有一个客户

创建实体类Customer（客户：一的一方）

创建实体类LinkMan（联系人：多的一方）

联系人数据库表

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;

配置映射文件Customer.hbm.xml

<?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="com.itheima.hibernate.domain.Customer" table="cst_customer">
		<!-- 建立OID与主键映射 -->
		<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	：多的一方的对象集合的属性名称。
				* cascade：级联
				* inverse：放弃外键维护权。
		-->
		<set name="linkMans" cascade="save-update" inverse="true">
			<!--
				 key标签
					* column：多的一方的外键的名称。
			 -->
			<key column="lkm_cust_id"/>
			<!-- 
				one-to-many标签
					* class	:多的一方的类的全路径
			 -->
			<one-to-many class="com.itheima.hibernate.domain.LinkMan"/>
		</set>
	</class>
</hibernate-mapping>

配置映射文件LinkMan.hbm.xml

<?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="com.itheima.hibernate.domain.LinkMan" table="cst_linkman">
		<!-- 建立OID与主键映射 -->
		<id name="lkm_id" column="lkm_id">
			<generator class="native"/>
		</id>
		<!-- 建立普通属性与表字段映射 name的值与column一致，则可以省略column-->
		<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="com.itheima.hibernate.domain.Customer" column="lkm_cust_id"/>
	</class>
</hibernate-mapping>

 在核心配置文件中添加映射<mapping>

<mapping resource="com/itheima/hibernate/domain/Customer.hbm.xml"/>
		<mapping resource="com/itheima/hibernate/domain/LinkMan.hbm.xml"/> 

 添加几条记录

// 保存2个客户  和 3个联系人  并且建立好关系
	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);
		customer1.getLinkMans().add(linkMan1);
		customer1.getLinkMans().add(linkMan2);
		customer2.getLinkMans().add(linkMan3);
		
		// 保存数据:
		session.save(linkMan1);
		session.save(linkMan2);
		session.save(linkMan3);
		session.save(customer1);
		session.save(customer2);
		
		tx.commit();
}

 如果只保存一边是否可行？

// 一对多关系只保存一边是否可以
	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.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);
		
		tx.commit();
	}

/**
	 *  级联保存或更新操作：
	 *  * 保存联系人级联客户，操作的主体是联系人对象，需要在LinkMan.hbm.xml中进行配置
	 *  * <many-to-one name="customer" cascade="save-update" class="com.itheima.hibernate.domain.Customer" column="lkm_cust_id"/>
	 */
	public void demo4(){
		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(linkMan);
		
		tx.commit();
	}

 测试一下对象的导航   前提是一对多的双方都设置了：cascade="save-update"

public void demo5(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		customer.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(customer);
		customer.getLinkMans().add(linkMan2);
		customer.getLinkMans().add(linkMan3);
		
		// 双方都设置了cascade
//		session.save(linkMan1); // 发送几条insert语句  4条
//		session.save(customer); // 发送几条insert语句  3条
		session.save(linkMan2); // 发送几条insert语句  1条
		
		tx.commit();
	}

 级联删除

级联删除：删除一边的时候，同时将另一边也删除

删除客户级联删除联系人

/**
	 * 级联删除：
	 * * 删除客户级联删除联系人，删除的主体是客户，需要在Customer.hbm.xml中配置
	 * * <set name="linkMans" cascade="delete">
	 */
	public void demo6(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 没有设置级联删除，默认情况:修改了联系人的外键为null，删除客户
		/*Customer customer = session.get(Customer.class, 1l);
		session.delete(customer);*/
		
		// 删除客户，同时删除联系人
		Customer customer = session.get(Customer.class, 1l);
		session.delete(customer);
		
		tx.commit();
	}

删除联系人级联删除客户（基本不用，这种删除本身就不合理）

/**
	 * 级联删除：
	 * * 删除联系人级联删除客户，删除的主体是联系人，需要在LinkMan.hbm.xml中配置
	 * * <many-to-one name="customer" cascade="delete">
	 */
	public void demo7(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 删除客户，同时删除联系人
		//这里一定要先查询，这样就可以把这个对象中的集合一起 查出来一起删掉，而不要通过new一个对象删除
		LinkMan linkMan = session.get(LinkMan.class, 3l);
		session.delete(linkMan);
		
		tx.commit();
	}

 一对多设置了双向关联产生多余的SQL语句

 解决多余的SQL语句：减轻服务器的负担，增加运行效率

1. 单向维护：即只进行其中一个关联
2. 使一方放弃外键维护权                                                                                                                                                                                       我们一般让一的一方放弃：在映射文件中对set中配置inverse="tiue"
3. 这种情况还经常出现在   一对多的关联查询的修改时。（CRM练习）

区分cascade和inverse

cascade是控制对象的关联与否的，inverse是控制对象维护外键的权限的

因此下面的代码，customer关联了linkMan，customer设置了cascade = "sava-update" 和 inverse="true"，因此customer和linkMan都会插入到数据库，但是customer不具备维护外键的权限，因此执行save(customer)时外键不会赋值，为null

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();
	}

  

hibernate多对多关联映射

多对多建表原则

 可以发现，我们可以用两个一对多来处理多对多，即选课表----学生表   1：n      选课表----课程表   1：n

但是hibernate中不需要通过这种方式

hibernate多对多关系的配置

用户user和角色user是多对多关系

创建实体类User

创建实体类Role

配置映射文件User.hbm.xml

<?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="com.itheima.hibernate.domain.User" table="sys_user">
		<!-- 建立OID与主键的映射 -->
		<id name="user_id" column="user_id">
			<generator class="native"/>
		</id>
		<!-- 建立普通属性与字段映射 -->
		<property name="user_code" column="user_code"/>
		<property name="user_name" column="user_name"/>
		<property name="user_password" column="user_password"/>
		<property name="user_state" column="user_state"/>
		<!-- 建立与角色的多对多的映射关系 -->
		<!-- 
			set标签
				* name		：对方的集合的属性名称。
				* table		：多对多的关系需要使用中间表，放的是中间表的名称。
		 -->
		<set name="roles" table="sys_user_role" cascade="save-update,delete"  >
			<!-- 
				key标签：
					* column	：当前的对象对应中间表的外键的名称。
			 -->
			<key column="user_id"/>
			<!-- 
				many-to-many标签：
					* class		：对方的类的全路径
					* column	：对方的对象在中间表中的外键的名称。
			 -->
			<many-to-many class="com.itheima.hibernate.domain.Role" column="role_id"/>
		</set>
	</class>
</hibernate-mapping>

 配置映射文件Role.hbm.xml

<?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="com.itheima.hibernate.domain.Role" table="sys_role">
		<!-- 建立OID与主键的映射 -->
		<id name="role_id" column="role_id">
			<generator class="native"/>
		</id>
		<!-- 建立普通属性与字段的映射 -->
		<property name="role_name" column="role_name"/>
		<property name="role_memo" column="role_memo"/>
		<!-- 与用户的多对多的映射关系 -->
		<!-- 
			set标签
				* name		：对方的集合的属性名称。
				* table		：多对多的关系需要使用中间表，放的是中间表的名称。
		 -->
		<set name="users" table="sys_user_role" cascade="save-update,delete" inverse="true">
			<!-- 
				key标签：
					* column	：当前的对象对应中间表的外键的名称。
			 -->
			<key column="role_id"/>
			<!-- 
				many-to-many标签：
					* class		：对方的类的全路径
					* column	：对方的对象在中间表中的外键的名称。
			 -->
			<many-to-many class="com.itheima.hibernate.domain.User" column="user_id"/>
		</set>
	</class>
</hibernate-mapping>

在hibernate核心配置中添加<mapping>

保存多个用户和角色

public void demo1(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建2个用户
		User user1 = new User();
		user1.setUser_name("赵洪");
		User user2 = new User();
		user2.setUser_name("李兵");
		
		// 创建3个角色
		Role role1 = new Role();
		role1.setRole_name("研发部");
		Role role2 = new Role();
		role2.setRole_name("市场部");
		Role role3 = new Role();
		role3.setRole_name("公关部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		user1.getRoles().add(role2);
		user2.getRoles().add(role2);
		user2.getRoles().add(role3);
		role1.getUsers().add(user1);
		role2.getUsers().add(user1);
		role2.getUsers().add(user2);
		role3.getUsers().add(user2);
		
		/*保存操作:多对多建立了双向的关系必须有一方放弃外键维护。
		否则会报错，因为向两个表中添加数据，会生成中间表，
		这里设置了双向的关联关系，会向中间表中插入两次相同的数据，
		从而导致出错*/
		// 一般是被动方放弃外键维护权。这里角色是被选的，所以让role对象放弃外键维护权。
		session.save(user1);
		session.save(user2);
		session.save(role1);
		session.save(role2);
		session.save(role3);
		
		tx.commit();
	}

多对多级联保存

若设置了双向关联，只保存一方，也是不可行的，与一对多相同，需要进行级联操作，即设置cascade = "save-update , delete"

user映射中

role映射中

/**
	 * 多对多的级联保存：
	 * * 保存用户级联保存角色。在用户的映射文件中配置。
	 * * 在User.hbm.xml中的set上配置 cascade="save-update"
	 */
	public void demo3(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		User user1 = new User();
		user1.setUser_name("赵洪");
		
		Role role1 = new Role();
		role1.setRole_name("研发部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		role1.getUsers().add(user1);
		// 只保存用户：
		session.save(user1);
		
		tx.commit();
	}

/**
	 * 多对多的级联保存：
	 * * 保存角色级联保存用户。在角色的映射文件中配置。
	 * * 在Role.hbm.xml中的set上配置 cascade="save-update"
	 */
	public void demo4(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建2个用户
		User user1 = new User();
		user1.setUser_name("李兵");
		
		// 创建3个角色
		Role role1 = new Role();
		role1.setRole_name("公关部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		role1.getUsers().add(user1);
		// 只保存用户：
		session.save(role1);
		
		tx.commit();
	}

多对多级联删除（基本用不上）

/**
	 * 多对多的级联删除：
	 * * 删除用户级联删除角色
	 * * 在User.hbm.xml中的set上配置 cascade="delete"
	 */
	public void demo5(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 查询1号用户:
		User user  = session.get(User.class, 1l);
		session.delete(user);
		
		tx.commit();
	}

/**
	 * 多对多的级联删除：
	 * * 删除角色级联删除用户
	 * * 在Role.hbm.xml中的set上配置 cascade="delete"
	 */
	public void demo6(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 查询2号角色:
		Role role  = session.get(Role.class, 2l);
		session.delete(role);
		
		tx.commit();
	}

多对多的其他操作（必须要会）

• 给用户选择角色

• /**
  	 * 给用户选择角色
  	 */
  	public void demo7(){
  		Session session = HibernateUtils.getCurrentSession();
  		Transaction tx = session.beginTransaction();
  		
  		// 给1号用户多选2号角色
          //先查询，因为先查询可以把这个user已经有的角色都查出来
          // 查询1号用户
  		User user  = session.get(User.class, 1l);
  		// 查询2号角色
  		Role role = session.get(Role.class, 2l);
  		user.getRoles().add(role);
          //这里也不用使用update，因为前面获取到的是持久态对象
          //而且这里也可以设置双向关联，因为前面已经设置了维护外键的权限
  		
  		tx.commit();
  	}

• 给用户改选角色

• /**
  	 * 给用户改选角色
  	 */
  	public void demo8(){
  		Session session = HibernateUtils.getCurrentSession();
  		Transaction tx = session.beginTransaction();
  		
  		// 给2号用户将原有的2号角色改为3号角色
  		// 查询2号用户
  		User user  = session.get(User.class, 2l);
  		// 查询2号角色
  		Role role2 = session.get(Role.class, 2l);
  		Role role3 = session.get(Role.class, 3l);
  		user.getRoles().remove(role2);
  		user.getRoles().add(role3);
  		
  		tx.commit();
  	}

• 给用户删除角色

• /**
  	 * 给用户改选角色
  	 */
  	public void demo9(){
  		Session session = HibernateUtils.getCurrentSession();
  		Transaction tx = session.beginTransaction();
  		
  		// 给2号用户删除1号角色
  		// 查询2号用户
  		User user  = session.get(User.class, 2l);
  		// 查询2号角色
  		Role role = session.get(Role.class, 1l);
  		user.getRoles().remove(role);
  		
  		tx.commit();
  	}

  其实这内部的操作的都是集合

一对一关系（只做了解即可）

其实这种关系可以建成一张表，除非是有特殊的需求需要将其分开

一对一关系建表原则（有两种）

CRUD（增create    查retrieve   改update  删delete）