hibernate总结（三）

最新推荐文章于 2022-12-11 17:44:27 发布

Gray_humor

最新推荐文章于 2022-12-11 17:44:27 发布

阅读量231

点赞数

分类专栏： hibernate 文章标签： java hibernate

本文链接：https://blog.csdn.net/Gray_humor/article/details/88578552

版权

hibernate 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

多表设计

多表设计的总则

问题：我们为什么要学习多表映射？

答：

在实际开发中，我们数据库的表难免会有相互的关联关系，在操作表的时候就有可能会涉及到多张表的操作。试想一下，如果把我们web阶段的在线商城案例的持久层改为hibernate的实现，我们现在根本无法实现功能。究其原因是我们在线商城中表之间都是有关联关系的。

例如：商品和分类，用户和订单，订单和商品等等。

掌握配置实体之间的关联关系。

要想实现多表映射，我们现阶段需要遵循的步骤：

第一步：首先确定两张表之间的关系。

如果关系确定错了，后面做的所有操作就都不可能正确。

第二步：在数据库中实现两张表的关系

第三步：在实体类中描述出两个实体的关系

第四步：配置出实体类和数据库表的关系映射

配置的方式支持注解和XML，我们以注解为重点。

表之间的关系划分

Hibernate框架实现了ORM的思想，将关系数据库中表的数据映射成对象，使开发人员把对数据库的操作转化为对对象的操作，Hibernate的关联关系映射主要包括多表的映射配置、数据的增加、删除等。

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

一对多、多对多、一对一

数据库表和实体类的一对多关系

示例分析

我们采用的示例为CRM中的客户和联系人。

客户：通常情况下客户指的是一家公司。

联系人：一般都是指客户的员工。

在不考虑兼职的情况下，客户和联系人的关系即为一对多。

表关系建立

在一对多关系中，我们习惯把一的一方称之为主表，把多的一方称之为从表。在数据库中建立一对多的关系，需要使用数据库的外键约束。

什么是外键？

指的是从表中有一列，取值参照主表的主键，这一列就是外键。

实体类关系建立

在实体类中，由于客户是少的一方，它应该包含多个联系人，所以实体类要体现出客户中有多个联系人的信息

/**
 * 客户的实体类
 */
public class Customer implements Serializable {

	private Long custId;
	private String custName;
	private String custSource;
	private String custIndustry;
	private String custLevel;
	private String custAddress;
	private String custPhone;
	
	//一对多关系映射：一个客户可以对应多个联系人
	private Set<LinkMan> linkmans = new HashSet<LinkMan>();
	
	public Long getCustId() {
		return custId;
	}
	public void setCustId(Long custId) {
		this.custId = custId;
	}
	public String getCustName() {
		return custName;
	}
	public void setCustName(String custName) {
		this.custName = custName;
	}
	public String getCustSource() {
		return custSource;
	}
	public void setCustSource(String custSource) {
		this.custSource = custSource;
	}
	public String getCustIndustry() {
		return custIndustry;
	}
	public void setCustIndustry(String custIndustry) {
		this.custIndustry = custIndustry;
	}
	public String getCustLevel() {
		return custLevel;
	}
	public void setCustLevel(String custLevel) {
		this.custLevel = custLevel;
	}
	public String getCustAddress() {
		return custAddress;
	}
	public void setCustAddress(String custAddress) {
		this.custAddress = custAddress;
	}
	public String getCustPhone() {
		return custPhone;
	}
	public void setCustPhone(String custPhone) {
		this.custPhone = custPhone;
	}
	public Set<LinkMan> getLinkmans() {
		return linkmans;
	}
	public void setLinkmans(Set<LinkMan> linkmans) {
		this.linkmans = linkmans;
	}
	@Override
	public String toString() {
		return "Customer [custId=" + custId + ", custName=" + custName + ", custSource=" + custSource
				+ ", custIndustry=" + custIndustry + ", custLevel=" + custLevel + ", custAddress=" + custAddress
				+ ", custPhone=" + custPhone + "]";
	}

由于联系人是多的一方，在实体类中要体现出，每个联系人只能对应一个客户，

/**
 * 联系人的实体类（数据模型）
 */
public class LinkMan implements Serializable {

	private Long lkmId;
	private String lkmName;
	private String lkmGender;
	private String lkmPhone;
	private String lkmMobile;
	private String lkmEmail;
	private String lkmPosition;
	private String lkmMemo;

	//多对一关系映射：多个联系人对应客户
	private Customer customer;//用它的主键，对应联系人表中的外键
	
	public Long getLkmId() {
		return lkmId;
	}
	public void setLkmId(Long lkmId) {
		this.lkmId = lkmId;
	}
	public String getLkmName() {
		return lkmName;
	}
	public void setLkmName(String lkmName) {
		this.lkmName = lkmName;
	}
	public String getLkmGender() {
		return lkmGender;
	}
	public void setLkmGender(String lkmGender) {
		this.lkmGender = lkmGender;
	}
	public String getLkmPhone() {
		return lkmPhone;
	}
	public void setLkmPhone(String lkmPhone) {
		this.lkmPhone = lkmPhone;
	}
	public String getLkmMobile() {
		return lkmMobile;
	}
	public void setLkmMobile(String lkmMobile) {
		this.lkmMobile = lkmMobile;
	}
	public String getLkmEmail() {
		return lkmEmail;
	}
	public void setLkmEmail(String lkmEmail) {
		this.lkmEmail = lkmEmail;
	}
	public String getLkmPosition() {
		return lkmPosition;
	}
	public void setLkmPosition(String lkmPosition) {
		this.lkmPosition = lkmPosition;
	}
	public String getLkmMemo() {
		return lkmMemo;
	}
	public void setLkmMemo(String lkmMemo) {
		this.lkmMemo = lkmMemo;
	}	
	public Customer getCustomer() {
		return customer;
	}
	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
	@Override
	public String toString() {
		return "LinkMan [lkmId=" + lkmId + ", lkmName=" + lkmName + ", lkmGender=" + lkmGender + ", lkmPhone="
				+ lkmPhone + ", lkmMobile=" + lkmMobile + ", lkmEmail=" + lkmEmail + ", lkmPosition=" + lkmPosition
				+ ", lkmMemo=" + lkmMemo + "]";
	}
}

一对多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="com.itheima.domain">

<class name="Customer" table="cst_customer">

<id name="custId" column="cust_id">

<generator class="native"></generator>

</id>

<property name="custName" column="cust_name"></property>

<property name="custLevel" column="cust_level"></property>

<property name="custSource" column="cust_source"></property>

<property name="custIndustry" column="cust_industry"></property>

<property name="custAddress" column="cust_address"></property>

<property name="custPhone" column="cust_phone"></property>

<!-- 一对多关系映射

涉及的标签

set：用于映射set集合属性

属性：

  name：指定集合属性的名称

  table:在一对多的时候写不写都可以。

   它指定的是集合元素所对应的表

one-to-many:用于指定当前映射配置文件所对应的实体和集合元素所对应的实体是一对多关系。

属性：

   class：指定集合元素所对应的实体类名称。

key：用于映射外键字段的。

属性：

   column：指定从表中的外键字段名称

-->

<set name="linkmans" table="cst_linkman">

<key column="lkm_cust_id"></key>

<one-to-many class="LinkMan"/>

</set>

</class>

</hibernate-mapping>

联系人配置文件：

2.1.2联系人配置文件：
<?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="com.itheima.domain">
	<class name="LinkMan" table="cst_linkman">
		<id name="lkmId" column="lkm_id">
			<generator class="native"></generator>
		</id>
		<property name="lkmName" column="lkm_name"></property>
		<property name="lkmGender" column="lkm_gender"></property>
		<property name="lkmPhone" column="lkm_phone"></property>
		<property name="lkmMobile" column="lkm_mobile"></property>
		<property name="lkmEmail" column="lkm_email"></property>
		<property name="lkmPosition" column="lkm_position"></property>
		<property name="lkmMemo" column="lkm_memo"></property>
		<!-- 多对一关系映射 
			涉及的标签：
				many-to-one:用于建立多对一的关系映射配置
					属性：
					  name：指定的实体类中属性的名称
					  class：该属性所对应的实体类名称。如果在hibernate-mapping上没有导包，则需要写全限定类名
					  column：指定从表中的外键字段名称
		-->
		<many-to-one name="customer" class="Customer" column="lkm_cust_id" />	</class>
</hibernate-mapping>

数据库表和实体类的多对多关系

示例分析

我们采用的示例为用户和角色。

用户：指的是咱们班的每一个同学。

角色：指的是咱们班同学的身份信息。

比如A同学，它是我的学生，其中有个身份就是学生，还是家里的孩子，那么他还有个身份是子女。

同时B同学，它也具有学生和子女的身份。

那么任何一个同学都可能具有多个身份。同时学生这个身份可以被多个同学所具有。

所以我们说，用户和角色之间的关系是多对多。

表关系建立

多对多的表关系建立靠的是中间表，其中用户表和中间表的关系是一对多，角色表和中间表的关系也是一对多，如下图所示：

实体类关系建立

一个用户可以具有多个角色，所以在用户实体类中应该包含多个角色的信息

/**
 * 用户的数据模型
 */
public class SysUser implements Serializable {

	private Long userId;
	private String userCode;
	private String userName;
	private String userPassword;
	private String userState;
	
	//多对多关系映射
	private Set<SysRole> roles = new HashSet<SysRole>(0);
	
	public Long getUserId() {
		return userId;
	}
	public void setUserId(Long userId) {
		this.userId = userId;
	}
	public String getUserCode() {
		return userCode;
	}
	public void setUserCode(String userCode) {
		this.userCode = userCode;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getUserPassword() {
		return userPassword;
	}
	public void setUserPassword(String userPassword) {
		this.userPassword = userPassword;
	}
	public String getUserState() {
		return userState;
	}
	public void setUserState(String userState) {
		this.userState = userState;
	}
	public Set<SysRole> getRoles() {
		return roles;
	}
	public void setRoles(Set<SysRole> roles) {
		this.roles = roles;
	}
	@Override
	public String toString() {
		return "SysUser [userId=" + userId + ", userCode=" + userCode + ", userName=" + userName + ", userPassword="
				+ userPassword + ", userState=" + userState + "]";
	}
}

一个角色可以赋予多个用户，所以在角色实体类中应该包含多个用户的信息，代码如下：

/**
 * 角色的数据模型
 */
public class SysRole implements Serializable {

	private Long roleId;
	private String roleName;
	private String roleMemo;
	
	//多对多关系映射
	private Set<SysUser> users = new HashSet<SysUser>(0);
		
	public Long getRoleId() {
		return roleId;
	}
	public void setRoleId(Long roleId) {
		this.roleId = roleId;
	}
	public String getRoleName() {
		return roleName;
	}
	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}
	public String getRoleMemo() {
		return roleMemo;
	}
	public void setRoleMemo(String roleMemo) {
		this.roleMemo = roleMemo;
	}
	public Set<SysUser> getUsers() {
		return users;
	}
	public void setUsers(Set<SysUser> users) {
		this.users = users;
	}
	@Override
	public String toString() {
		return "SysRole [roleId=" + roleId + ", roleName=" + roleName + ", roleMemo=" + roleMemo + "]";
	}
}

多对多关系映射


2.2.1用户配置文件：
<?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="com.itheima.domain">
	<class name="SysUser" table="sys_user">
		<id name="userId" column="user_id">
			<generator class="native"></generator>
		</id>
		<property name="userCode" column="user_code"></property>
		<property name="userName" column="user_name"></property>
		<property name="userPassword" column="user_password"></property>
		<property name="userState" column="user_state"></property>
		<!-- 多对多关系映射 
			涉及的标签：
				set:用于映射集合属性
					属性：
					  name：指定集合属性的名称
					  table:指定的是中间表的名称，在多对多的配置时，必须写。
				 key：指定外键字段
				 	属性：
				 	   column：指定的是当前映射文件所对应的实体在中间表的外键字段名称
				 many-to-many：指定当前映射文件所对应的实体和集合元素所对应的实体是多对多的关系
				 	属性：
				 		class：指定集合元素所对应的实体类
				 		column：指定的是集合元素所对应的实体在中间表的外键字段名称
				 	
				 	
		-->
		<set name="roles" table="user_role_rel">
			<key column="user_id"></key>
			<many-to-many class="SysRole" column="role_id"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

角色配置文件：

2.2.2角色配置文件：
<?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="com.itheima.domain">
	<class name="SysRole" table="sys_role">
		<id name="roleId" column="role_id">
			<generator class="native"></generator>
		</id>
		<property name="roleName" column="role_name"></property>
		<property name="roleMemo" column="role_memo"></property>
		<!-- 多对多关系映射 -->
		<set name="users" table="user_role_rel">
			<key column="role_id"></key>
			<many-to-many class="SysUser" column="user_id"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

Gray_humor

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
hibernate总结（三）

多表设计多表设计的总则问题：我们为什么要学习多表映射？答：在实际开发中，我们数据库的表难免会有相互的关联关系，在操作表的时候就有可能会涉及到多张表的操作。试想一下，如果把我们web阶段的在线商城案例的持久层改为hibernate的实现，我们现在根本无法实现功能。究其原因是我们在线商城中表之间都是有关联关系的。例如：商品和分类，用户和订单，订单和商品等等。掌握配置实体之间的关...
复制链接

扫一扫