版权声明：转载请联系作者本人！！！ https://blog.csdn.net/weixin_42061805/article/details/83243806
表与表的关系
- 一对一
- 一对多（常用）
- 多对多（常用）注：需要建立第三张表
一对多操作
- 实体类以及实体之间的关系的创建
- 映射文件的配置映射文件的配置
- 核心配置文件的配置
- 具体的操作
1）cascade属性：级联操作
2）级联保存
3）级联删除
实体类
package tqb.entity;
import java.util.HashSet;
import java.util.Set;
public class Customer {
// 客户id
private Integer cid;
// 客户名称
private String custName;
// 客户级别
private String custLevel;
// 客户来源
private String custSource;
// 联系电话
private String custPhone;
// 手机
private String custMobile;
// 在客户实体类里面表示多个联系人，一个客户有多个联系人
// hibernate要求使用集合表示多的数据，使用set集合
private Set<LinkMan> setLinkMan = new HashSet<LinkMan>();
public Set<LinkMan> getSetLinkMan() {
return setLinkMan;
}
public void setSetLinkMan(Set<LinkMan> setLinkMan) {
this.setLinkMan = setLinkMan;
}
public Integer getCid() {
return cid;
}
public void setCid(Integer cid) {
this.cid = cid;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
public String getCustMobile() {
return custMobile;
}
public void setCustMobile(String custMobile) {
this.custMobile = custMobile;
}
@Override
public String toString() {
return "Customer [cid=" + cid + ", custName=" + custName + ", custLevel=" + custLevel + ", custSource="
+ custSource + ", custPhone=" + custPhone + ", custMobile=" + custMobile + ", setLinkMan=" + setLinkMan
+ "]";
}
}
package tqb.entity;
public class LinkMan {
private Integer lkm_id; // 联系人编号(主键)
private String lkm_name;// 联系人姓名
private String lkm_gender;// 联系人性别
private String lkm_phone;// 联系人办公电话
// 在联系人实体类里面表示所属客户,一个联系人只能属于一个客户
private Customer customer;
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
public Integer getLkm_id() {
return lkm_id;
}
public void setLkm_id(Integer 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;
}
@Override
public String toString() {
return "LinkMan [lkm_id=" + lkm_id + ", lkm_name=" + lkm_name + ", lkm_gender=" + lkm_gender + ", lkm_phone="
+ lkm_phone + ", customer=" + customer + "]";
}
}
映射文件的配置
<?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>
<!-- 1 配置类和表对应
class标签
name属性：实体类全路径
table属性：数据库表名称
-->
<class name="tqb.entity.Customer" table="t_customer">
<id name="cid" column="cid">
<generator class="native"></generator>
</id>
<property name="custName" column="custName"></property>
<property name="custLevel" column="custLevel"></property>
<property name="custSource" column="custSource"></property>
<property name="custPhone" column="custPhone"></property>
<property name="custMobile" column="custMobile"></property>
<!--
name：实体关系中多对一（多）对应的对象名称
-->
<set name="setLinkMan" cascade="save-update,delete">
<!-- column：实体关系中多对一（多）对应的表字段名称 -->
<key column="clid"></key>
<!-- class：实体关系中多对一（多）对应实体的全路径 -->
<one-to-many class="tqb.entity.LinkMan"/>
</set>
</class>
</hibernate-mapping>
<?xml version="1.0" encoding="UTF-8"?>
<!-- 对hibernate配置文件的dtd约束 -->
<!-- hibernate-mapping为父标签 -->
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- hibernate的配置文件 -->
<hibernate-mapping>
<!--
name:实体类的全路径
table:数据库对应的表名
-->
<class name="tqb.entity.LinkMan" table="t_linkman">
<!--
hibernate中必须有一个具有唯一值的属性
name:实体中id的属性名
column:就是表中的字段
-->
<id name="lkm_id" column="lkm_id">
<generator class="native"></generator>
</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>
<!-- 多对一 -->
<!--
name：多对一中（一）实体中对应的对象名称
class：多对一中（一）实体的全路径
column：多对一中（多）对应表中的外键字段名称
-->
<many-to-one name="customer" class="tqb.entity.Customer" column="clid"></many-to-one>
</class>
</hibernate-mapping>
核心文件的配置
<!-- 加载表单项配置文件 -->
<mapping resource="tqb/entity/Customer.hbm.xml"/>
<mapping resource="tqb/entity/LinkMan.hbm.xml"/>
级联保存
注：在Customer映射文件中的set标签添加如下属性信息cascade="save-update"
<set name="setLinkMan" cascade="save-update">
<!-- column：实体关系中多对一（多）对应的表字段名称 -->
<key column="clid"></key>
<!-- class：实体关系中多对一（多）对应实体的全路径 -->
<one-to-many class="tqb.entity.LinkMan"/>
</set>
package tqb.test;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import tqb.entity.Customer;
import tqb.entity.LinkMan;
import utils.HibernateUtils;
/**
* 级联添加数据
*
* @author tqb
*
*/
public class Demo {
/**
* 该方法较另一种（该方法下面）麻烦
*/
@Test
public void add1() {
Session session = null;
Transaction transaction = null;
try {
session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
//给实体添加数据
Customer customer = new Customer();
customer.setCustName("Tencent");
customer.setCustLevel("VIP");
customer.setCustSource("IT");
customer.setCustPhone("2222222");
LinkMan linkMan = new LinkMan();
linkMan.setLkm_name("马化腾");
linkMan.setLkm_gender("male");
linkMan.setLkm_phone("15200000000");
customer.getSetLinkMan().add(linkMan);
linkMan.setCustomer(customer);
//向数据库中添加数据
session.save(customer);
session.save(linkMan);
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
}
/**
* 配置文件后较上边的方法简便
* 在Customer实体对应的配置文件set中添加如下属性
* <set name="setLinkMan" cascade="save-update">
*/
@Test
public void add2() {
Session session = null;
Transaction transaction = null;
try {
session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
//给实体添加数据
Customer customer = new Customer();
customer.setCustName("Alibaba");
customer.setCustLevel("VIP");
customer.setCustSource("IT");
customer.setCustPhone("33333333");
LinkMan linkMan = new LinkMan();
linkMan.setLkm_name("杰克马");
linkMan.setLkm_gender("male");
linkMan.setLkm_phone("15800000000");
customer.getSetLinkMan().add(linkMan);
//向数据库中添加数据
session.save(customer);
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
}
}
级联删除数据
注：在Customer映射文件中的set标签添加如下属性信息cascade="delete"
<set name="setLinkMan" cascade="delete">
<!-- column：实体关系中多对一（多）对应的表字段名称 -->
<key column="clid"></key>
<!-- class：实体关系中多对一（多）对应实体的全路径 -->
<one-to-many class="tqb.entity.LinkMan"/>
</set>
package tqb.test;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import tqb.entity.Customer;
import utils.HibernateUtils;
/**
* 一对多的级联删除
* 在Customer实体对应的配置文件中添加如下内容
* <set name="setLinkMan" cascade="delete">
* 或（同一属性的多个值）
* <set name="setLinkMan" cascade="save-update,delete">
* @author tqb
*
*/
public class Demo2 {
@Test
public void delete(){
Session session = null;
Transaction transaction = null;
try {
session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
Customer customer = session.get(Customer.class, 2);
session.delete(customer);
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
}
}
原理：
/**
* 原理实现
Hibernate:
select
customer0_.cid as cid1_0_0_,
customer0_.custName as custName2_0_0_,
customer0_.custLevel as custLeve3_0_0_,
customer0_.custSource as custSour4_0_0_,
customer0_.custPhone as custPhon5_0_0_,
customer0_.custMobile as custMobi6_0_0_
from
t_customer customer0_
where
customer0_.cid=?
Hibernate:
select
setlinkman0_.clid as clid5_1_0_,
setlinkman0_.lkm_id as lkm_id1_1_0_,
setlinkman0_.lkm_id as lkm_id1_1_1_,
setlinkman0_.lkm_name as lkm_name2_1_1_,
setlinkman0_.lkm_gender as lkm_gend3_1_1_,
setlinkman0_.lkm_phone as lkm_phon4_1_1_,
setlinkman0_.clid as clid5_1_1_
from
t_linkman setlinkman0_
where
setlinkman0_.clid=?
Hibernate:
update
t_linkman
set
clid=null
where
clid=?
Hibernate:
delete
from
t_linkman
where
lkm_id=?
Hibernate:
delete
from
t_customer
where
cid=?
*/
多对多操作
- 实体类以及实体之间的关系的创建
- 映射文件的配置映射文件的配置
- 核心配置文件的配置
- 具体的操作
- 第三张表的维护
实体类
package tqb.entity.manytomany;
import java.util.HashSet;
import java.util.Set;
public class User {
private Integer user_id;//用户id
private String user_name;//用户名称
private String user_password;//用户密码
//一个用户可以有多个角色
private Set<Role> setRole = new HashSet<Role>();
public Set<Role> getSetRole() {
return setRole;
}
public void setSetRole(Set<Role> setRole) {
this.setRole = setRole;
}
public Integer getUser_id() {
return user_id;
}
public void setUser_id(Integer user_id) {
this.user_id = user_id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getUser_password() {
return user_password;
}
public void setUser_password(String user_password) {
this.user_password = user_password;
}
}
package tqb.entity.manytomany;
import java.util.HashSet;
import java.util.Set;
public class Role {
private Integer role_id;//角色id
private String role_name;//角色名称
private String role_memo;//角色描述
// 一个角色有多个用户
private Set<User> setUser = new HashSet<User>();
public Set<User> getSetUser() {
return setUser;
}
public void setSetUser(Set<User> setUser) {
this.setUser = setUser;
}
public Integer getRole_id() {
return role_id;
}
public void setRole_id(Integer role_id) {
this.role_id = role_id;
}
public String getRole_name() {
return role_name;
}
public void setRole_name(String role_name) {
this.role_name = role_name;
}
public String getRole_memo() {
return role_memo;
}
public void setRole_memo(String role_memo) {
this.role_memo = role_memo;
}
}
映射文件配置
<?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>
<!-- 1 配置类和表对应
class标签
name属性：实体类全路径
table属性：数据库表名称
-->
<class name="tqb.entity.manytomany.User" table="t_user">
<id name="user_id" column="user_id">
<generator class="native"></generator>
</id>
<property name="user_name" column="user_name"></property>
<property name="user_password" column="user_password"></property>
<!-- table：第三张表名 -->
<set name="setRole" table="user_role" cascade="save-update">
<key column="user_id"></key>
<many-to-many class="tqb.entity.manytomany.Role" column="role_id"></many-to-many>
</set>
</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>
<!-- 1 配置类和表对应
class标签
name属性：实体类全路径
table属性：数据库表名称
-->
<class name="tqb.entity.manytomany.Role" table="t_role">
<id name="role_id" column="role_id">
<generator class="native"></generator>
</id>
<property name="role_name" column="role_name"></property>
<property name="role_memo" column="role_memo"></property>
<set name="setUser" table="user_role">
<key column="role_id"></key>
<many-to-many class="tqb.entity.manytomany.User" column="user_id"></many-to-many>
</set>
</class>
</hibernate-mapping>
级联保存数据与级联删除（级联删除几乎不用）
package tqb.test;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import tqb.entity.manytomany.Role;
import tqb.entity.manytomany.User;
import utils.HibernateUtils;
public class ManyToManyDemo {
/**
* 级联保存
*/
@Test
public void funadd() {
Session session = null;
Transaction transaction = null;
try {
session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
User user1 = new User();
User user2 = new User();
user1.setUser_name("zhangsan");
user1.setUser_password("123");
user2.setUser_name("lisi");
user2.setUser_password("456");
Role role1 = new Role();
Role role2 = new Role();
Role role3 = new Role();
role1.setRole_name("总经理");
role1.setRole_memo("总经理");
role2.setRole_name("董事长");
role2.setRole_memo("董事长");
role3.setRole_name("保卫科长");
role3.setRole_memo("保卫科长");
user1.getSetRole().add(role1);
user1.getSetRole().add(role2);
user2.getSetRole().add(role2);
user2.getSetRole().add(role3);
session.save(user1);
session.save(user2);
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
}
/**
* 级联删除
* 危险性太高，不建议使用（只提供方法，不使用）
*/
@Test
public void fundelete() {
Session session = null;
Transaction transaction = null;
try {
session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
User user = session.get(User.class, 1);
/*
* 结果为：
* 三张表与user_id=1有关系的全部删除
*/
session.delete(user);
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
}
/**
* 维护第三张表
* 即给第三张表添加数据和删除数据
*/
@Test
public void user_role() {
Session session = null;
Transaction transaction = null;
try {
session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
/*
* 给第一个用户添加第三种角色
*/
// User user = session.get(User.class, 1);
// Role role = session.get(Role.class, 3);
// user.getSetRole().add(role);
/*
* 第一个用户删除第三种角色
*/
User user = session.get(User.class, 1);
Role role = session.get(Role.class, 3);
user.getSetRole().remove(role);
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
}
}