0 列表功能实现
1 表与表之间关系回顾
（1）一对多（客户和联系人）
（2）多对多（用户和角色）
2 hibernate 一对多操作
（1）一对多映射配置
（2）一对多级联保存
（3）一对多级联删除
（4）inverse属性
3 hibernate多对多操作
（1）多对多映射配置
（2）多对多级联保存
（3）多对多级联删除
（4）维护第三张表
表与表之间关系回顾
1 一对多
（1）分类和商品关系，一个分类里面有多个商品，一个商品只能属于一个分类
（2）客户和联系人是一对多关系
-客户：与公司有业务往来，百度、新浪、360
-联系人：公司里面的员工，百度里面有很多员工，联系员工
--公司和公司员工的关系
-客户是一，联系人是多
一个客户里面有多个联系人，一个联系人只能属于一个客户
（3）一对多建表：通过外键建立联系
2 多对多
（1）订单和商品关系，一个订单里面有多个商品，一个商品属于多个订单
（2）用户和角色多对多关系
-用户：小王、小马、小宋
-角色：总经理、秘书、司机、保安
** 比如小王 可以是总经理， 可以是司机
** 比如小宋 可以是司机，可以是秘书，可以保安
** 比如小马 可以是秘书， 可以是总经理
-一个用户里面可以有多个角色，一个角色里面可以有多一个用户
（3）多对多建表，创建第三张表维护关系
创建第三张表
*至少有两个字段作为外键，指向两个表主键
3 一对一
（1）在中国，一个男人只能有一个妻子，一个女人只能有一个丈夫
Hibernate的一对多操作（重点）
一对多映射配置
以客户和联系人为例： 客户是一，联系人是多
第一步 创建实体类，客户和联系人
第二步 让两个实体类之间互相表示
（1）在客户实体类里面表示多个联系人
-一个客户里面有多个联系人
//在客户实体类里面表示多个联系人，一个客户有多个联系人
//hibernate要求使用集合表示多的数据，使用set集合
private Set<LinkMan> setLinkMan = new HashSet<LinkMan>();
public Set<LinkMan> getSetLinkMan() {
return setLinkMan;
}
public void setSetLinkMan(Set<LinkMan> setLinkMan) {
this.setLinkMan = setLinkMan;
}
（2）在联系人实体类里面表示所属客户
-一个联系人只能属于一个客户
//在联系人实体里面表示所属客户，一个联系人只能属于一个客户
private Customer customer;
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
第三步 配置映射关系
（1）一般一个实体类对应一个映射文件
（2）把映射最基本配置完成
（3）在映射文件中，配置一对多关系
-在客户映射文件中，表示所有联系人
<!-- 在客户映射文件中，表示所有联系人
使用set标签表示所有联系人
set标签里面有name属性，属性值写在客户实体类里面表示联系人的set集合名词
-->
<set name="setLinkMan">
<!-- 一对多建表，有外键
hibernate机制，双向维护外键，在一和多那一方都配置外键
column属性值：外键名词
-->
<key column="clid"></key>
<!-- 客户所有的联系人，class里面写联系人实体类全路径 -->
<one-to-many class="cn.itcast.entity.LinkMan" />
</set>
-在联系人映射文件中，表示所属客户
<!-- 表示联系人所属客户
name属性：因为在联系人实体类使用customer对象表示，写customer名称
class属性：customer全路径
column属性值：外键名词
-->
<many-to-one name="customer" class="cn.itcast.entity.Customer" column="clid"></many-to-one>
第四步 创建核心配置文件，把映射文件引入到核心配置文件中
<!-- 第三部分：把映射文件放到核心配置文件中 必须的 -->
<mapping resource="cn/itcast/entity/Customer.hbm.xml" />
<mapping resource="cn/itcast/entity/LinkMan.hbm.xml" />
测试：
CREATE TABLE `t_linkman` (
`lkm_id` int(11) NOT NULL AUTO_INCREMENT,
`lkm_name` varchar(255) DEFAULT NULL,
`lkm_gender` varchar(255) DEFAULT NULL,
`lkk_phone` varchar(255) DEFAULT NULL,
`clid` int(11) DEFAULT NULL,
PRIMARY KEY (`lkm_id`),
KEY `FKjtgu0oocf35ij4fmulu123vwk` (`clid`),
CONSTRAINT `FKjtgu0oocf35ij4fmulu123vwk` FOREIGN KEY (`clid`) REFERENCES `t_customer` (`cid`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 |
一对多级联操作
1 级联保存
（1）添加一个客户，为这个客户添加多个联系人
2 级联删除
（1）删除某一个客户，这个客户里面的所有的联系人也删除
一对多级联保存
1 添加客户，为这个客户添加一个联系人
（1）复杂写法
// 演示一对多级联保存
@Test
public void testAddDemo1() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
// 开启事务
tx = session.beginTransaction(); //添加一个客户，为这个客户添加一个联系人
// 1 创建客户和联系人对象
Customer customer = new Customer();
customer.setCustName("itcast");
customer.setCustLevel("vip");
customer.setCustSource("net");
customer.setCustPhone("110");
customer.setCustMobile("999"); LinkMan linkman = new LinkMan();
linkman.setLkm_name("lucy");
linkman.setLkm_gender("male");
linkman.setLkm_phone("911"); //2 在客户表示联系人，在联系人表示客户
//建立客户对象和联系人对象关系
//2.1 把联系人放到客户实体类对象的set集合里面
customer.getSetLinkMan().add(linkman);
//2.2 把客户对象放到联系人里面去
linkman.setCustomer(customer); //3 保存到数据库
session.save(customer);
session.save(linkman); // 提交事务
tx.commit();
} catch (Exception e) {
// 回滚事务
e.printStackTrace();
tx.rollback();
} finally {
session.close();
sessionFactory.close();
} }
查看数据库表
（2）简化写法
-一般都是根据客户添加联系人
第一步 在客户映射文件中进行配置
-在客户映射文件里面set标签进行配置
<set name="setLinkMan" cascade="save-update">
第二步 创建客户和联系人对象，只需要把联系人放到客户里面就可以了，最终只需要保存客户就可以了。
//添加一个客户，为这个客户添加一个联系人
// 1 创建客户和联系人对象
Customer customer = new Customer();
customer.setCustName("baidu");
customer.setCustLevel("plain");
customer.setCustSource("net");
customer.setCustPhone("110");
customer.setCustMobile("999"); LinkMan linkman = new LinkMan();
linkman.setLkm_name("xiaohong");
linkman.setLkm_gender("male");
linkman.setLkm_phone("911"); //2 把联系人放到客户里面
customer.getSetLinkMan().add(linkman); //3 保存客户
session.save(customer);
与第一种写相比，这里少写了两条语句。
linkman.setCustomer(customer);
//3 保存到数据库
session.save(linkman);
一对多级联删除
1 删除某个客户，把客户里面所有的联系人删除
2 具体实现
第一步 在客户映射文件set标签，进行配置
（1）使用属性cascade属性值
<set name="setLinkMan" cascade="save-update,delete">
第二步 在代码中直接删除客户
（1）根据id查询对象，调用session里面的delete方法删除。
// 1 根据id查询客户对象
Customer customer = session.get(Customer.class, 3);
// 2 调用方法删除
session.delete(customer);
3执行过程
底层sql
（1）根据id查询客户
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=?
（2）根据外键id值查询联系人
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=?
（3）把联系人的外键设置成null
update
t_linkman
set
clid=null
where
clid=?
（4）删除联系人和客户
delete
from
t_linkman
where
lkm_id=? delete
from
t_customer
where
cid=?
一对多修改操作
//持久态会自动跟新数据库，这和一级缓存有关
1 让lucy联系人所属客户不是itcast，而是baidu。
//1 根据id查询联系人，根据id查询百度客户
Customer baidu = session.get(Customer.class, 4);
LinkMan lucy = session.get(LinkMan.class, 1);
//2 设置持久态对象值
//把联系人放到客户里面
baidu.getSetLinkMan().add(lucy);
lucy.setCustomer(baidu);
//持久态会自动跟新数据库，这和一级缓存有关
2 inverse属性
（1）因为hibernate双向维护外键，在客户和联系人里面都需要维护外键，修改客户时候修改一次外键，修改联系人时候也修改过一次外键，造成效率问题。
update
t_linkman
set
lkm_name=?,
lkm_gender=?,
lkm_phone=?,
clid=?
where
lkm_id=?
Hibernate:
update
t_linkman
set
clid=?
where
lkm_id=?
（2）解决方式：让其中的一方不维护外键。
-一对多里面，让其中的一方放弃外键维护
-一个国家有总统，国家有很多人，总统不能认识国家所有的人，国家所有人可以认识总统。
（3）具体实现：
在放弃关系维护映射文件中，进行配置，在set标签上使用inverse属性。
所以在Customer.hbm.xml中
<!-- 在客户映射文件中，表示所有联系人
使用set标签表示所有联系人
set标签里面有name属性，属性值写在客户实体类里面表示联系人的set集合名词
inverse属性默认值：false不放弃关系维护
true放弃关系维护
-->
<set name="setLinkMan" inverse="true" cascade="save-update,delete">
Hibernate多对多操作
多对多映射配置
以用户和角色为例演示
第一步 创建实体类，用户和角色
第二步 让实体类之间互相表示
（1）用户里面表示所有角色，使用set集合
//一个用户可以有多个角色
private Set<Role> setRole = new HashSet<Role>(); public Set<Role> getSetRole() {
return setRole;
}
public void setSetRole(Set<Role> setRole) {
this.setRole = setRole;
}
（2）一个角色有多个用户，使用set集合
//一个角色有多个用户
private Set<User> setUser = new HashSet<User>(); public Set<User> getSetUser() {
return setUser;
}
public void setSetUser(Set<User> setUser) {
this.setUser = setUser;
}
第三步 配置映射关系
（1）基本配置
表名和路径都要正确
（2）配置多对多关系
-在用户里面表示所有角色，使用set标签
<!-- 在用户里面表示所有角色，使用set标签
name属性：角色set集合名称
table属性：第三张表名称
-->
<set name="setRole" table="user_role">
<!-- key标签里配置
配置当前映射文件在第三张表外键名称 -->
<key column="userid"></key>
<!-- class：角色实体类全路径
column:角色在第三张表外键名称
-->
<many-to-many class="cn.itcast.manytomany.Role" column="roleid"></many-to-many>
</set>
-在角色里面表示所有用户，使用set标签
<!-- 在角色里面表示所有用户，使用set标签 -->
<set name="setUser" table="user_role">
<!-- 角色在第三张表外键 -->
<key column="roleid"></key>
<many-to-many class="cn.itcast.manytomany.User" column="userid"></many-to-many>
</set>
关系
第四步 在核心配置文件中引入映射文件
<mapping resource="cn/itcast/manytomany/User.hbm.xml" />
<mapping resource="cn/itcast/manytomany/Role.hbm.xml" />
测试
结果成功，第三张表底层创建语句
CREATE TABLE `user_role` (
`userid` int(11) NOT NULL,
`roleid` int(11) NOT NULL,
PRIMARY KEY (`roleid`,`userid`),
KEY `FKkca1ytil11i8ffamb9x4it65m` (`userid`),
CONSTRAINT `FKkca1ytil11i8ffamb9x4it65m` FOREIGN KEY (`userid`) REFERENCES `t_user` (`user_id`),
CONSTRAINT `FKcwof70ufe1sg8jh46fhrgv5wp` FOREIGN KEY (`roleid`) REFERENCES `t_role` (`rold_id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 |
多对多级联保存
根据用户保存角色
第一步 在用户配置文件中set标签进行设置，cascade值save-update
第二步 写代码实现
（1）创建用户和角色对象，把角色对象放到用户里面，最终保存用户就可以了。
<set name="setRole" table="user_role" cascade="save-update">
//添加两个用户，为每个用户添加两个角色
//1 创建对象
User user1 = new User();
user1.setUser_name("lucy");
user1.setUser_password("456"); User user2 = new User();
user2.setUser_name("lucy");
user2.setUser_password("456"); Role r1 = new Role();
r1.setRole_name("zongjingli");
r1.setRole_memo("zongjingli"); Role r2 = new Role();
r2.setRole_name("mishu");
r2.setRole_memo("mishu"); Role r3 = new Role();
r3.setRole_name("baoan");
r3.setRole_memo("baoan");
//2 建立关系，把角色放到用户里面
// user1 -- r1/r2
user1.getSetRole().add(r1);
user1.getSetRole().add(r2); // user2 -- r2/r3
user2.getSetRole().add(r2);
user2.getSetRole().add(r3); //3 保存用户
session.save(user1);
session.save(user2);
运行结果：
多对多级联删除（了解）
第一步 在set标签进行配置(User.hbm.xml文件中)，cascade值delete
第二步 删除用户
<set name="setRole" table="user_role" cascade="save-update,delete">
User user = session.get(User.class, 1);
session.delete(user);
结果只剩下一条数据，原本应该剩两条数据的，
维护第三张表的关系
1 用户额角色是多对多关心，维护关系时通过第三张表维护
2 让某个用户有某个角色
第一步 根据id查询用户和角色
第二步 把角色放到用户里面
（1）把角色对象放到用户set集合里面
3 让某个用户没有某个角色
第一步 根据id查询用户和角色
//让某个用户有角色
//让lucy有经纪人角色
//1 查询lucy和经纪人
User lucy = session.get(User.class, 1);
Role role = session.get(Role.class, 1); //2把角色放到用户的set集合里面
lucy.getSetRole().add(role);
第二步 从用户里面把角色去掉
（1）从set集合里面把角色移除
//让某个用户有角色
User user = session.get(User.class, 2);
Role role = session.get(Role.class, 3); //2 从用户里面把某个角色去掉
user.getSetRole().remove(role);