hibernate_2

最新推荐文章于 2022-11-30 22:44:09 发布

weixin_36142178

最新推荐文章于 2022-11-30 22:44:09 发布

阅读量266

点赞数

本文链接：https://blog.csdn.net/weixin_36142178/article/details/77104597

版权

表与表之间的关系回顾

1 一对多

（1）分类和商品关系，一个分类里面有多个商品，一个商品只能属于一个分类

（2）客户和联系人是一对多关系

- 客户：与公司有业务往来，百度、新浪、360

- 联系人：公司里面的员工，百度里面有很多员工，联系员工

** 公司和公司员工的关系

- 客户是一，联系人是多

- 一个客户里面有多个联系人，一个联系人只能属于一个客户

（3）一对多建表：通过外键建立关系

2 多对多

（1）订单和商品关系，一个订单里面有多个商品，一个商品属于多个订单

（2）用户和角色多对多关系

- 用户：小王、小马、小宋

- 角色：总经理、秘书、司机、保安

** 比如小王可以是总经理，可以是司机

** 比如小宋可以是司机，可以是秘书，可以保安

** 比如小马可以是秘书，可以是总经理

- 一个用户里面可以有多个角色，一个角色里面可以有多个用户

（3）多对多建表：创建第三张表维护关系

3 一对一

（1）在中国，一个男人只能有一个妻子，一个女人只能有一个丈夫

02-一对多&多对一关系表达_

以客户和联系人为例：客户是一，联系人是多

第一步创建两个实体类，客户和联系人

第二步让两个实体类之间互相表示

（1）

在客户实体类里面表示多个联系人

- 一个客户里面有多个联系人

创建客户类，代码如下：

package cn.itcast.domain;

import java.util.HashSet;

import java.util.Set;

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;

//使用set集合,表达一对多关系

//在客户实体类里面表示多个联系人，一个客户可以有多个联系人，hibernate要求表示多个联系人集合统一使用se集合

private Set<LinkMan> linkMens = new HashSet<LinkMan>();

public Set<LinkMan> getLinkMens() {

return linkMens;

}

public void setLinkMens(Set<LinkMan> linkMens) {

this.linkMens = linkMens;

}

public Long getCust_id() {

return cust_id;

}

public void setCust_id(Longcust_id) {

this.cust_id =cust_id;

}

public String getCust_name() {

return cust_name;

}

public void setCust_name(Stringcust_name) {

this.cust_name =cust_name;

}

public String getCust_source() {

return cust_source;

}

public void setCust_source(Stringcust_source) {

this.cust_source =cust_source;

}

public String getCust_industry() {

return cust_industry;

}

public void setCust_industry(Stringcust_industry) {

this.cust_industry =cust_industry;

}

public String getCust_level() {

return cust_level;

}

public void setCust_level(Stringcust_level) {

this.cust_level =cust_level;

}

public String getCust_linkman() {

return cust_linkman;

}

public void setCust_linkman(Stringcust_linkman) {

this.cust_linkman =cust_linkman;

}

public String getCust_phone() {

return cust_phone;

}

public void setCust_phone(Stringcust_phone) {

this.cust_phone =cust_phone;

}

public String getCust_mobile() {

return cust_mobile;

}

public void setCust_mobile(Stringcust_mobile) {

this.cust_mobile =cust_mobile;

}

@Override

public String toString() {

return "Customer [cust_id=" +cust_id + ", cust_name=" + cust_name + "]";

}

（2）在联系人实体类里面表示所属客户

- 一个联系人只能属于一个客户

package cn.itcast.domain;

//联系人实体

public class 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) 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;

private Long lkm_id;

private Character lkm_gender;

private String lkm_name;

private String lkm_phone;

private String lkm_email;

private String lkm_qq;

private String lkm_mobile;

private String lkm_memo;

private String lkm_position;

//表达多对一关系

//在联系人实体类里面表示所属客户，一个联系人只能属于一个客户

private Customercustomer ;

public Customer getCustomer() {

return customer;

}

public void setCustomer(Customercustomer) {

this.customer =customer;

}

public Long getLkm_id() {

return lkm_id;

}

public void setLkm_id(Longlkm_id) {

this.lkm_id =lkm_id;

}

public Character getLkm_gender() {

return lkm_gender;

}

public void setLkm_gender(Characterlkm_gender) {

this.lkm_gender =lkm_gender;

}

public String getLkm_name() {

return lkm_name;

}

public void setLkm_name(Stringlkm_name) {

this.lkm_name =lkm_name;

}

public String getLkm_phone() {

return lkm_phone;

}

public void setLkm_phone(Stringlkm_phone) {

this.lkm_phone =lkm_phone;

}

public String getLkm_email() {

return lkm_email;

}

public void setLkm_email(Stringlkm_email) {

this.lkm_email =lkm_email;

}

public String getLkm_qq() {

return lkm_qq;

}

public void setLkm_qq(Stringlkm_qq) {

this.lkm_qq =lkm_qq;

}

public String getLkm_mobile() {

return lkm_mobile;

}

public void setLkm_mobile(Stringlkm_mobile) {

this.lkm_mobile =lkm_mobile;

}

public String getLkm_memo() {

return lkm_memo;

}

public void setLkm_memo(Stringlkm_memo) {

this.lkm_memo =lkm_memo;

}

public String getLkm_position() {

return lkm_position;

}

public void setLkm_position(Stringlkm_position) {

this.lkm_position =lkm_position;

}

第三步配置映射关系

（1）一般一个实体类对应一个映射文件

（2）把映射最基本配置完成

（3）在映射文件中，配置一对多关系

- 在客户映射文件中，表示所有联系人

<?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" >

</id>

<!--

级联操作:cascade

save-update: 级联保存更新

delete:级联删除

all:save-update+delete

级联操作: 简化操作.目的就是为了少些两行代码.

-->

<!-- inverse属性: 配置关系是否维护.

true: customer不维护关系

false(默认值): customer维护关系

inverse属性: 性能优化.提高关系维护的性能.

原则: 无论怎么放弃,总有一方必须要维护关系.

一对多关系中: 一的一方放弃.也只能一的一方放弃.多的一方不能放弃.

--><!--

使用set标签标识所有联系人

name属性:在客户实体类里面表示联系人的set集合的变量名

column属性: 外键列名

class属性: 与我关联的对象完整类名

-->

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

</set>

</class>

</hibernate-mapping>

操作：

package cn.itcast.a_one2many;

import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;

import cn.itcast.domain.Customer;

import cn.itcast.domain.LinkMan;

import cn.itcast.utils.HibernateUtils;

//一对多|多对一关系操作

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,3l);

//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,3l);

//2> 获得要移除的联系人

LinkMan lm = session.get(LinkMan.class, 3l);

//3> 将联系人从客户集合中移除

c.getLinkMens().remove(lm);

lm.setCustomer(null);

//-------------------------------------------------

//4提交事务

tx.commit();

//5关闭资源

session.close();

}

操作进阶：级联保存和级联删除

Customer.hbm.xml

<!--

级联操作:cascade

save-update: 级联保存更新

delete:级联删除

all:save-update+delete

级联操作: 简化操作.目的就是为了少些两行代码.

-->

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

</set>

LinkMan.hbm.xml

<many-to-one name="customer" column="lkm_cust_id" class="Customer" cascade="all">

package cn.itcast.a_one2many;

import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;

import cn.itcast.domain.Customer;

import cn.itcast.domain.LinkMan;

import cn.itcast.utils.HibernateUtils;

//测试级联操作

public class Demo2 {

@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.save(c);

// session.save(lm1);

// session.save(lm2);

//-------------------------------------------------

//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,2l);

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

}

操作进阶--关系维护属性inverse属性

inverse属性

（1）因为hibernate双向维护外键，在客户和联系人里面都需要维护外键，修改客户时候修改一次外键，修改联系人时候也修改一次外键，造成效率问题

（2）解决方式：让其中的一方不维护外键

- 一对多里面，让其中一方放弃外键维护

- 一个国家有总统，国家有很多人，总统不能认识国家所有人，国家所有人可以认识总统

（3）具体实现：

在放弃关系维护映射文件中，进行配置，在set标签上使用inverse属性

Customer.hbm.xml

<!-- inverse属性: 配置关系是否维护.

true: customer不维护关系,

false(默认值): customer维护关系

inverse属性: 性能优化.提高关系维护的性能.

原则: 无论怎么放弃,总有一方必须要维护关系.

一对多关系中: 一的一方放弃.也只能一的一方放弃.多的一方不能放弃.

-->

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

</set>

LinkMan.hbm.xml

<many-to-one name="customer"column="lkm_cust_id" class="Customer" >

多对多关系的表达

表中表达

以用户和角色为例演示

第一步创建实体类，用户和角色

第二步让两个实体类之间互相表示

（1）一个用户里面表示所有角色，使用set集合

package cn.itcast.domain;

import java.util.HashSet;

import java.util.Set;

public class User {

* CREATE TABLE `sys_user` (

`user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',

`user_code` varchar(32) NOT NULL COMMENT '用户账号',

`user_name` varchar(64) NOT NULL COMMENT '用户名称',

`user_password` varchar(32) NOT NULL COMMENT '用户密码',

`user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停',

PRIMARY KEY (`user_id`)

) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

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 Long getUser_id() {

return user_id;

}

public void setUser_id(Long user_id) {

this.user_id = user_id;

}

public String getUser_code() {

return user_code;

}

public void setUser_code(String user_code) {

this.user_code = user_code;

}

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;

}

public Character getUser_state() {

return user_state;

}

public void setUser_state(Character user_state) {

this.user_state = user_state;

}

public Set<Role> getRoles() {

return roles;

}

public void setRoles(Set<Role> roles) {

this.roles = roles;

}

（2）一个角色有多个用户，使用set集合

package cn.itcast.domain;

import java.util.HashSet;

import java.util.Set;

//角色对象

public class Role {

CREATE TABLE `sys_role` (

`role_id` bigint(32) NOT NULL AUTO_INCREMENT,

`role_name` varchar(32) NOT NULL COMMENT '角色名称',

`role_memo` varchar(128) DEFAULT NULL COMMENT '备注',

PRIMARY KEY (`role_id`)

) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

private Long role_id;

private String role_name;

private String role_memo;

//表达多对多

private Set<User> users = new HashSet<User>();

public Long getRole_id() {

return role_id;

}

public void setRole_id(Long 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;

}

public Set<User> getUsers() {

return users;

}

public void setUsers(Set<User> users) {

this.users = users;

}

第三步配置映射关系

（1）基本配置

（2）配置多对多关系

- 在用户里面表示所有角色，使用set标签

<?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" >

</id>

<!--

name: 集合属性名

table: 配置中间表名

key

|-column:外键,别人引用"我"的外键列名

class: 我与哪个类是多对多关系

column:外键.我引用比人的外键列名

-->

<!-- cascade级联操作:

save-update: 级联保存更新

delete:级联删除

all:级联保存更新+级联删除

结论: cascade简化代码书写.该属性使不使用无所谓. 建议要用只用save-update.

如果使用delete操作太过危险.尤其在多对多中.不建议使用.

-->

<many-to-many class="Role" column="role_id" ></many-to-many>

</set>

</class>

</hibernate-mapping>

- 在角色里面表示所有用户，使用set标签

<?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" >

</id>

<!-- 使用inverse属性

true: 放弃维护外键关系

false(默认值):维护关系

结论: 将来在开发中,如果遇到多对多关系.一定要选择一方放弃维护关系.

一般谁来放弃要看业务方向. 例如录入员工时,需要为员工指定所属角色.

那么业务方向就是由员工维护角色. 角色不需要维护与员工关系.角色放弃维护

-->

<many-to-many class="User" column="user_id" ></many-to-many>

</set>

</class>

</hibernate-mapping>

<!-- 使用inverse属性

true: 放弃维护外键关系

false(默认值):维护关系

结论: 将来在开发中,如果遇到多对多关系.一定要选择一方放弃维护关系.

一般谁来放弃要看业务方向. 例如录入员工时,需要为员工指定所属角色.

那么业务方向就是由员工维护角色. 角色不需要维护与员工关系.角色放弃维护

-->

操作：

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

}

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

}

weixin_36142178

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
hibernate_2

表与表之间的关系回顾1 一对多（1）分类和商品关系，一个分类里面有多个商品，一个商品只能属于一个分类（2）客户和联系人是一对多关系- 客户：与公司有业务往来，百度、新浪、360- 联系人：公司里面的员工，百度里面有很多员工，联系员工** 公司和公司员工的关系 - 客户是一，联系人是多- 一个客户里面有多个联系人，一个联系人只能属于一个客户（3
复制链接

扫一扫