Hibernate快速入门(2)

目录

一对多/多对一
多对多

数据库中多表之间存在着三种关系，也就是系统设计中的三种实体关系。如下图：

从图可以看出，系统设计的三种实体关系分别为：多对多、一对多、和一对一关系。

一对多/多对一

关系表达

表中的表达

首先我们先用一个实例来介绍在Hibernate中如何建立一对多的关系。

假设我们有两张表，一张是客户表，一张是联系人表。很明显，我们可以知道客户表中的某一个客户，是可以存在着多个联系人的。如下图：

首先我们在数据库中创建这两张表

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) NOT 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=3 DEFAULT CHARSET=utf8;

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=2 DEFAULT CHARSET=utf8;

实体中的表达

创建实体类LinkMan

public class LinkMan {
	
	private Long lkm_id;
	private Character lkm_gender;
	private String lkm_name;
	private String lkm_phone;
	private String lkm_mobile;
	private String lkm_email;
	private String lkm_qq;
	private String lkm_position;
	private String lkm_memo;
	
	//表达多对一的关系
	private Customer customer;

	public Long getLkm_id() {
		return lkm_id;
	}

	public void setLkm_id(Long lkm_id) {
		this.lkm_id = lkm_id;
	}

	public Character getLkm_gender() {
		return lkm_gender;
	}

	public void setLkm_gender(Character lkm_gender) {
		this.lkm_gender = lkm_gender;
	}

	public String getLkm_name() {
		return lkm_name;
	}

	public void setLkm_name(String lkm_name) {
		this.lkm_name = lkm_name;
	}

	public String getLkm_phone() {
		return lkm_phone;
	}

	public void setLkm_phone(String lkm_phone) {
		this.lkm_phone = lkm_phone;
	}

	public String getLkm_mobile() {
		return lkm_mobile;
	}

	public void setLkm_mobile(String lkm_mobile) {
		this.lkm_mobile = lkm_mobile;
	}

	public String getLkm_email() {
		return lkm_email;
	}

	public void setLkm_email(String lkm_email) {
		this.lkm_email = lkm_email;
	}

	public String getLkm_qq() {
		return lkm_qq;
	}

	public void setLkm_qq(String lkm_qq) {
		this.lkm_qq = lkm_qq;
	}

	public String getLkm_position() {
		return lkm_position;
	}

	public void setLkm_position(String lkm_position) {
		this.lkm_position = lkm_position;
	}

	public String getLkm_memo() {
		return lkm_memo;
	}

	public void setLkm_memo(String lkm_memo) {
		this.lkm_memo = lkm_memo;
	}

	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
	
}

创建Customer类

package cn.itheima.domain;

public class Customer {
	
	/*
	 * 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_linkman` VARCHAR(64) 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;
	 */
	private Long cust_id;
	
	private String cust_name;
	private String cust_source;
	private String cust_industry;
	private String cust_level;
	private String cust_linkman;
	private String cust_phone;
	private String cust_mobile;
	public Long getCust_id() {
		return cust_id;
	}
	public void setCust_id(Long cust_id) {
		this.cust_id = cust_id;
	}
	public String getCust_name() {
		return cust_name;
	}
	public void setCust_name(String cust_name) {
		this.cust_name = cust_name;
	}
	public String getCust_source() {
		return cust_source;
	}
	public void setCust_source(String cust_source) {
		this.cust_source = cust_source;
	}
	public String getCust_industry() {
		return cust_industry;
	}
	public void setCust_industry(String cust_industry) {
		this.cust_industry = cust_industry;
	}
	public String getCust_level() {
		return cust_level;
	}
	public void setCust_level(String cust_level) {
		this.cust_level = cust_level;
	}
	public String getCust_linkman() {
		return cust_linkman;
	}
	public void setCust_linkman(String cust_linkman) {
		this.cust_linkman = cust_linkman;
	}
	public String getCust_phone() {
		return cust_phone;
	}
	public void setCust_phone(String cust_phone) {
		this.cust_phone = cust_phone;
	}
	public String getCust_mobile() {
		return cust_mobile;
	}
	public void setCust_mobile(String cust_mobile) {
		this.cust_mobile = cust_mobile;
	}
	@Override
	public String toString() {
		return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + "]";
	}

}

ORM元数据的表达

分别在Customer.hbm.xml和LinkMan.hbm.xml文件中添加如上配置。然后在hibernate.cfg.xml中添加映射配置

然后就是编写测试类进行测试就OK啦。

//一对多|多对一关系操作
public class Demo {
	@Test
	//保存客户 以及客户 下的联系人
	public void fun1(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		Customer c = new Customer();
		c.setCust_name("传智播客");
		
		LinkMan lm1 = new LinkMan();
		lm1.setLkm_name("黎活明");
		
		LinkMan lm2 = new LinkMan();
		lm2.setLkm_name("刘悦东");
		
		//表达一对多,客户下有多个联系人
		c.getLinkMens().add(lm1);
		c.getLinkMens().add(lm2);
		
		//表达对对对,联系人属于哪个客户
		lm1.setCustomer(c);
		lm2.setCustomer(c);
		
		
		session.save(c);
		session.save(lm1);
		session.save(lm2);
		
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}
	
	@Test
	//为客户增加联系人
	public void fun2(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		//1> 获得要操作的客户对象
		Customer c = session.get(Customer.class,1l);
		//2> 创建联系人
		LinkMan lm1 = new LinkMan();
		lm1.setLkm_name("郝强勇");
		//3> 将联系人添加到客户,将客户设置到联系人中
		c.getLinkMens().add(lm1);
		lm1.setCustomer(c);
		//4> 执行保存
		session.save(lm1);
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}
	
	@Test
	//为客户删除联系人
	public void fun3(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		//1> 获得要操作的客户对象
		Customer c = session.get(Customer.class,1l);
		//2> 获得要移除的联系人
		LinkMan lm = session.get(LinkMan.class, 3l);
		//3> 将联系人从客户集合中移除
		c.getLinkMens().remove(lm);
		lm.setCustomer(null);
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}
		
}

这个时候大家可以思考一个问题，如果我们一个客户下有很多个联系人，代码当中，我们也要一个一个去save吗，能不能我们sava一个客户，自动的联系人就也保存到该客户下了呢。下面就要介绍我们的级联操作了。

级联操作：在我们的实体映射文件当中去配置，属性名为cascade，属性值有三个分别是：sava-update、delete、all。其中sava-update就可以满足我们上诉的需求，下面我们看一个例子。

        @Test
	//保存客户 以及客户 下的联系人
	//cascade:save-update
	public void fun1(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		Customer c = new Customer();
		c.setCust_name("传智播客");
		
		LinkMan lm1 = new LinkMan();
		lm1.setLkm_name("黎活明");
		
		LinkMan lm2 = new LinkMan();
		lm2.setLkm_name("刘悦东");
		
		//表达一对多,客户下有多个联系人
		c.getLinkMens().add(lm1);
		c.getLinkMens().add(lm2);
		
		//表达对对对,联系人属于哪个客户
		lm1.setCustomer(c);
		lm2.setCustomer(c);
		
		session.persist(lm1);
		session.persist(lm2);
		
		session.save(c);
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}

        @Test
	//测试删除客户时,级联删除客户下的联系人
	//cascade:delete
	public void fun2(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		//1> 获得要操作的客户对象
		Customer c = session.get(Customer.class,1l);
		//2>调用delete删除客户
		session.delete(c);
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}

	@Test
	//保存联系人以及联系人对应的客户
	//cascade:save-update
	public void fun3(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		Customer c = new Customer();
		c.setCust_name("北大青鸟");
		
		LinkMan lm1 = new LinkMan();
		lm1.setLkm_name("刘总");
		
		//表达一对多,客户下有多个联系人
		c.getLinkMens().add(lm1);
		
		//表达对对对,联系人属于哪个客户
		lm1.setCustomer(c);
		
		
		session.save(lm1);
		
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}

综上，我们可以得出一个结论，级联操作只是用来简化操作的，如果一定要使用的话，用sava-update就可以了，千万不要轻易使用delete属性值！！！

现在，我们来看下面这个例子

        @Test
	//保存客户 以及客户 下的联系人
	public void fun1(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		Customer c = new Customer();
		c.setCust_name("传智播客");
		
		LinkMan lm1 = new LinkMan();
		lm1.setLkm_name("黎活明");
		
		LinkMan lm2 = new LinkMan();
		lm2.setLkm_name("刘悦东");
		
		//表达一对多,客户下有多个联系人. 
		// 如果客户放弃维护与联系人的关系. 维护关系的代码可以省略
		c.getLinkMens().add(lm1);
		c.getLinkMens().add(lm2);
		
		//表达对对对,联系人属于哪个客户
		lm1.setCustomer(c);
		lm2.setCustomer(c);
		
		
		session.save(c);
		session.save(lm1);
		session.save(lm2);
		
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}

这个例子执行的结果如图：

那么我们要如何消除这种冗余操作呢，这个时候就需要用到我们的inverse属性，这个属性值默认是false，表示维护关系。如果将属性值设为true就表示该表放弃维护关系。将inverse属性值设置为true之后就没有了冗余的update操作了。

多对多

关系表达

表中的表达

这里举的多对多的例子就是员工表和角色表，一个员工可能有多种角色，而一种角色下也有可能有多个员工，对于外键的处理，多对多关系中都是使用中间表来表带，分别引用两张表的主键。

实体的表达

实体表都省略掉了get/set方法，这个大家自己创建就好。

public class User {
	
	private Long user_id;
	private String user_code;
	private String user_name;
	private String user_password;
	private Character user_state;
	//表达多对多
	private Set<Role> roles = new HashSet<Role>();
}

public class Role {

	private Long role_id;
	private String role_name;
	private String role_memo;
	//表达多对多
	private Set<User> users = new HashSet<User>();
}

ORM元数据的表达

User.hbm.xml

其中set标签中的name属性：关联的另一方的集合的属性名称。

table属性：中间表的名称。

key标签中的column属性：当前对象在中间表中的外键的名称。

many-to-many标签中的class属性：关联另一方的类的全路径

                                    column：关联的另一方在中间表的外键名称。

<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.domain" >
	<class name="User" table="sys_user" >
		<id name="user_id"  >
			<generator class="native"></generator>
		</id>
		<property name="user_code"  ></property>
		<property name="user_name"  ></property>
		<property name="user_password"  ></property>
		<property name="user_state"  ></property>
	
		<!-- 多对多关系表达 -->
		<!-- 
			name: 集合属性名
			table: 配置中间表名
			key
			 |-column:外键,别人引用"我"的外键列名
			 class: 我与哪个类是多对多关系
			 column:外键.我引用比人的外键列名
		 -->
		<set name="roles" table="sys_user_role" cascade="save-update" >
			<key column="user_id" ></key>
			<many-to-many class="Role" column="role_id" ></many-to-many>
		</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 package="cn.itcast.domain" >
	<class name="Role" table="sys_role" >
		<id name="role_id"  >
			<generator class="native"></generator>
		</id>
		<property name="role_name"  ></property>
		<property name="role_memo"  ></property>
		
		<set name="users" table="sys_user_role" inverse="true" >
			<key column="role_id" ></key>
			<many-to-many class="User" column="user_id" ></many-to-many>
		</set>
	</class>
</hibernate-mapping>

写好orm映射文件后，在核心配置文件中加入新编写的orm映射文件

<mapping resource="cn/itcast/domain/Role.hbm.xml" />
<mapping resource="cn/itcast/domain/User.hbm.xml" />

这个要如何测试我们的配置是否成功呢？

运行我们前面fun1()测试代码，如果数据库中多出了sys_role,sys_user,sys_user_role三张表就代表配置成功啦！

操作关联属性

下面我们先来看一个例子，我们上面的配置文件搭建并测试好之后。

//多对多关系操作
public class Demo {
	@Test
	//保存员工以及角色
	public void fun1(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		//1> 创建两个 User
		User u1 = new User();
		u1.setUser_name("郝强勇");
		
		User u2 = new User();
		u2.setUser_name("金家德");
		
		//2> 创建两个 Role
		Role r1 = new Role();
		r1.setRole_name("保洁");
		
		Role r2 = new Role();
		r2.setRole_name("保安");
		//3> 用户表达关系
		u1.getRoles().add(r1);
		u1.getRoles().add(r2);
		
		u2.getRoles().add(r1);
		u2.getRoles().add(r2);
		
		//4> 角色表达关系
		r1.getUsers().add(u1);
		r1.getUsers().add(u2);
		
		r2.getUsers().add(u1);
		r2.getUsers().add(u2);
		
		//5> 调用Save方法一次保存
		session.save(u1);
		session.save(u2);
		session.save(r1);
		session.save(r2);
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}
}

运行上面测试类，junit会报错。

这是因为，在多对多关系中，因为要借助中间表来表示外键，而上述例子中，user和role都对外键进行了维护，这个时候在中间表中添加了两次一样的数据，这个时候就报错了。解决方法就是让其中的一方放弃对外键的维护，这个时候就使用inverse属性，将属性值设为true就表示放弃维护。然后就可以成功添加数据了。

在多对多关系中，谁来放弃对外键的维护，一般是针对业务来说，例如录入员工时,需要为员工指定所属角色。那么业务方向就是由员工维护角色. 角色不需要维护与员工关系.角色放弃维护

下面的两个例子，分别是为用户新增角色，和为用户接触角色的操作。新增角色中的demo要注意的是，新建的角色是瞬时态，要将其转换为持久态，如果想省略掉这一步的话，让用户在新增角色的同时就将角色转换为持久态，需要使用级联操作，也就是cascade属性，将属性值设为sava-update。不过建议的话是不使用这个属性。

	@Test
	//为郝强勇新增一个角色
	public void fun3(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		//1> 获得郝强勇用户
		User user = session.get(User.class, 1l);
		//2> 创建公关角色
		Role r = new Role();
		r.setRole_name("男公关");
		//3> 将角色添加到用户中
		user.getRoles().add(r);
		//4> 将角色转换为持久化
		//session.save(r);
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}
	
	@Test
	//为郝强勇解除一个角色
	public void fun4(){
		//1 获得session
		Session session = HibernateUtils.openSession();
		//2 开启事务
		Transaction tx = session.beginTransaction();
		//-------------------------------------------------
		//3操作
		//1> 获得郝强勇用户
		User user = session.get(User.class, 1l);
		//2> 获得要操作的角色对象(保洁,保安)
		Role r1 = session.get(Role.class, 1l);
		Role r2 = session.get(Role.class, 2l);
		//3> 将角色从用户的角色集合中移除
		user.getRoles().remove(r1);
		user.getRoles().remove(r2);
		
		//-------------------------------------------------
		//4提交事务
		tx.commit();
		//5关闭资源
		session.close();
	}