Hibernate(三)上之数据库表与表之间的关系及一对多的具体配置

一对多关系

什么样关系属于一对多？

一个部门对应多个员工，一个员工只能属于某一个部门。
一个客户对应多个联系人，一个联系人只能属于某一个客户。

一对多的建表原则：

多对多关系

什么样关系属于多对多？

一个学生可以选择多门课程，一门课程也可以被多个学生选择。
一个用户可以选择多个角色，一个角色也可以被多个用户选择。

多对多的建表原则：

一对一关系（了解）

什么样关系属于一对一？

一个公司只能有一个注册地址，一个注册地址只能被一个公司注册。

一对一的建表原则：

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.创建实体
一的一方的实体

package com.wangshi.hibernate.test02;

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

/**
 * @author wanghaichuan
 *创建实体类
 */
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>LinkMan = new HashSet<LinkMan>();

		//构造
		public Customer() {
			super();
			// TODO Auto-generated constructor stub
		}

		public Customer(Long cust_id, String cust_name, String cust_source, String cust_industry, String cust_level,
				String cust_phone, String cust_mobile, Set<com.wangshi.hibernate.test02.LinkMan> linkMan) {
			super();
			this.cust_id = cust_id;
			this.cust_name = cust_name;
			this.cust_source = cust_source;
			this.cust_industry = cust_industry;
			this.cust_level = cust_level;
			this.cust_phone = cust_phone;
			this.cust_mobile = cust_mobile;
			LinkMan = linkMan;
		}

		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_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;
		}

		public Set<LinkMan> getLinkMan() {
			return LinkMan;
		}

		public void setLinkMan(Set<LinkMan> linkMan) {
			LinkMan = linkMan;
		}

		@Override
		public String toString() {
			return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
					+ ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone
					+ ", cust_mobile=" + cust_mobile + ", LinkMan=" + LinkMan + "]";
		}

}

多的一方的实体

package com.wangshi.hibernate.test02;

public class LinkMan {
	
	private Long lkm_id;
	private String lkm_name;
	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;

	public LinkMan() {
		super();
		// TODO Auto-generated constructor stub
	}

	public LinkMan(Long lkm_id, String lkm_name, String lkm_gender, String lkm_phone, String lkm_mobile,
			String lkm_email, String lkm_qq, String lkm_position, String lkm_memo, Customer customer) {
		super();
		this.lkm_id = lkm_id;
		this.lkm_name = lkm_name;
		this.lkm_gender = lkm_gender;
		this.lkm_phone = lkm_phone;
		this.lkm_mobile = lkm_mobile;
		this.lkm_email = lkm_email;
		this.lkm_qq = lkm_qq;
		this.lkm_position = lkm_position;
		this.lkm_memo = lkm_memo;
		this.customer = customer;
	}

	public Long getLkm_id() {
		return lkm_id;
	}

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

	public String getLkm_name() {
		return lkm_name;
	}

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

	public String getLkm_gender() {
		return lkm_gender;
	}

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

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

	@Override
	public String toString() {
		return "LinkMan [lkm_id=" + lkm_id + ", lkm_name=" + lkm_name + ", lkm_gender=" + lkm_gender + ", lkm_phone="
				+ lkm_phone + ", lkm_mobile=" + lkm_mobile + ", lkm_email=" + lkm_email + ", lkm_qq=" + lkm_qq
				+ ", lkm_position=" + lkm_position + ", lkm_memo=" + lkm_memo + ", 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">
    
  <!--   类与表的映射关系 batch-size=""批量抓取 -->
   <hibernate-mapping>
   		<class batch-size="" name="com.wangshi.hibernate.test02.LinkMan"  table="cst_linkman">
   		<!--类与表的主键-->
   		<id name="lkm_id"  column="lkm_id">
   			<generator class="native" />
   		</id>
   		
   		<!--普通属性-->
   		<property name="lkm_name" column="lkm_name"></property>
   		<property name="lkm_gender" column="lkm_gender"></property>
   		<property name="lkm_phone" column="lkm_phone"></property>
   		<property name="lkm_mobile" column="lkm_mobile"></property>
   		<property name="lkm_email" column="lkm_email"></property>
   		<property name="lkm_qq" column="lkm_qq"></property>
   		<property name="lkm_position" column="lkm_position"></property>
   		<property name="lkm_memo" column="lkm_memo"></property>
   		
   		<!--配置多对一的关系：放的是一的一方的对象-->
   		<!-- many-to-one标签
   		*name：一的一方的对象属性名称
   		*class：一的一方的全路径
   		*column：在多的一方的表的外键名称  -->
   		<many-to-one name="customer"  cascade="save-update"  class="com.wangshi.hibernate.test02.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="com.wangshi.hibernate.test02.Customer"  table="cst_customer">
   		<!--类与表的主键-->
   		<id name="cust_id"  column="cust_id">
   			<generator class="native" />
   		</id>
   		
   		<!--普通属性-->
   		<property name="cust_name" column="cust_name"></property>
   		<property name="cust_source" column="cust_source"></property>
   		<property name="cust_industry" column="cust_industry"></property>
   		<property name="cust_level" column="cust_level"></property>
   		<property name="cust_phone" column="cust_phone"></property>
   		<property name="cust_mobile" column="cust_mobile"></property>
   		
   		<!-- 配置一对多的映射：放置多的一端的集合  级联 保存和更新 -->
   		<set name="LinkMan" cascade="save-update"  inverse="true" batch-size="">
   				<key column="lkm_cust_id"/>
   				<one-to-many class="com.wangshi.hibernate.test02.LinkMan"/>
   		</set>
   		</class>
   </hibernate-mapping>

5.创建核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- hibernate核心配置的约束-->
<!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:///hibernate01</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>
		
		<!-- 事务的隔离级别 4  -->
		<property name="hibernate.connection.isolation">4</property>
		
		<!-- 配置session 绑定本地线程 -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<!-- 映射文件的路径 -->
		<mapping resource="com/wangshi/hibernate/test02/Customer.hbm.xml"/>
		<mapping resource="com/wangshi/hibernate/test02/LinkMan.hbm.xml"/>
		
		<mapping resource="com/wangshi/hibernate/test03/user.hbm.xml"/>
		<mapping resource="com/wangshi/hibernate/test03/role.hbm.xml"/>
		
		</session-factory>
	</hibernate-configuration>

6.引入工具类

package com.wangshi.hibernate.util;

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

/**hibernate的工具类
 * @author wanghiachaun
 */


public class HibernateUtils {
	
	public static final Configuration cfg;
	public static final SessionFactory sf;
	
	/**静态代码块
	 * 加载hibernate的核心配置
	 * 创建一个SessionFactory对象
	 * @author wanghiachaun
	 */
	static{
		cfg = new Configuration().configure();
		sf = cfg.buildSessionFactory();
	}
	
	
	/**
	 * 获取当前线程绑定的会话
	 * getcurrentSession
 */
	public static Session getCurrentSession(){
		return sf.getCurrentSession();
	}
	
	/**建立连接
	 * @author wanghiachaun
	 */
	public static Session openSession() {
		return sf.openSession();
	}

}

7.编写测试类

/**
 * @author wanghaichuan
 *一对多的测试类
 *
 */
public class hibernateDemo01 {
	
	@Test
	//保存2个客户  和三个联系人并且建立好关系
	public void demo01(){
		//创建session
		Session session = HibernateUtils.getCurrentSession();
		//开启事务
		Transaction tx = session.beginTransaction();
		
		//创建2客户
		Customer customer1 = new Customer();
		customer1.setCust_name("吕布");
		Customer customer2 = new Customer();
		customer2.setCust_name("貂蝉");
		
		//创建3联系人
		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.getLinkMan().add(linkman1);
		customer1.getLinkMan().add(linkman2);
		customer2.getLinkMan().add(linkman3);
		
		//保存数据
		session.save(linkman1);
		session.save(linkman2);
		session.save(linkman3);
		session.save(customer1);
		session.save(customer2);
		
		
		//提交
		tx.commit();
	}

Hibernate的一对多相关操作

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

	@Test
	//一对多的相关操作
	//一对多关系只保存一边是否可以
	public void demo02(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		//创建客户
		Customer customer = new Customer();
		customer.setCust_name("廉颇");
		//创建联系人
		LinkMan linkman = new LinkMan();
		linkman.setLkm_name("蔺相如");
		
		//两者关系
		customer.getLinkMan().add(linkman);
		linkman.setCustomer(customer);
		
		//测试 只保存一边是否可以:不可以，报一个瞬时对象异常，持久态对象关联了一个瞬时态对象
		//session.save(linkman);
		session.save(customer);
		
		tx.commit();
	}

2.一对多的级联操作
什么叫做级联
级联指的是，操作一个对象的时候，是否会同时操作其关联的对象。

级联是有方向性
操作一的一方的时候，是否操作到多的一方
操作多的一方的时候，是否操作到一的一方

保存客户级联联系人

	@Test
	//可以使用 级联操作
	//一对多的级联操作   级联的保存或更新
	//保存客户级联联系人，操作主体是客户对象，需要在Customer.hbm.xml中进行配置
	public void demo03(){
		
		Session session= HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		//创建客户及联系人
		Customer customer = new Customer();
		LinkMan linkman = new LinkMan();
		
		//添加数据及关系
		customer.setCust_name("小鱼儿");
		linkman.setLkm_name("花无缺");
		customer.getLinkMan().add(linkman);
		linkman.setCustomer(customer);
		
		session.save(customer);
		tx.commit();
		
	}

保存联系人级联客户

	@Test
	//可以使用 级联操作
	//一对多的级联操作   级联的保存或更新
	//保存联系人级联客户，操作主体是联系人对象，需要在Linkman.hbm.xml中进行配置
	public void demo04(){
		
		Session session= HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		//创建客户及联系人
		Customer customer = new Customer();
		LinkMan linkman = new LinkMan();
		
		//添加数据及关系
		customer.setCust_name("天蓬元帅");
		linkman.setLkm_name("猪刚烈");
		customer.getLinkMan().add(linkman);
		linkman.setCustomer(customer);
		
		session.save(linkman);
		tx.commit();
		
		
	}

测试对象的导航

	@Test
	//测试对象的导航
	public void demo05(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		//创建对象
		Customer customer =new Customer();
		LinkMan linkman1 = new LinkMan();
		LinkMan linkman2 = new LinkMan();
		LinkMan linkman3 = new LinkMan();
		
		//添加数据
		customer.setCust_name("孙悟空");
		
		linkman1.setLkm_name("齐天大圣");
		linkman2.setLkm_name("花果山");
		linkman3.setLkm_name("美猴王");
		//联系人找客户
		linkman1.setCustomer(customer);
		//客户添加联系人
		customer.getLinkMan().add(linkman2);
		customer.getLinkMan().add(linkman3);
		
		//双方都设置了级联 cascade
		//发送几条insert语句   4条
		//session.save(linkman1);
		//发送几条insert语句   3条
		//session.save(customer);
		//发送几条insert语句   1条
		session.save(linkman2);
			
		tx.commit();
	}

级联删除

级联删除：
删除一边的时候，同时将另一方的数据也一并删除。

删除客户级联删除联系人

	@Test
	//级联删除 删除客户级联删除联系人
	
	//删除联系人 级联删除客户(基本不用)
	public void  demo06(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		//没有设置级联删除的情况，默认修改联系人的外键删除客户
		//删除客户同时删除联系人
		Customer customer = session.get(Customer.class, 17l);
		session.delete(customer);
			
		tx.commit();
		
	}

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

解决多余的SQL语句

单向维护：
使一方放弃外键维护权：
一的一方放弃。在set上配置inverse=”true”

区分cascade和inverse

--------------------------------------------------------一对多到此结束，稍后请看多对多☻☻☻