第二次学习总结
- Hibernate的持久化类的编写规则
- 无参数构造
- 属性私有
- 属性尽量使用包装类
- 提供一个唯一OID与主键对应
- 不要使用final修饰
- Hibernate的主键生成策略
- 主键分类
- 自然主键
- 代理主键
- 主键生成策略
- increment
- identity
- sequence
- uuid
- native
- assigned
- 主键分类
- Hibernate的持久化类的三种状态
- 瞬时态：没有唯一标识OID，没有被session管理
- 持久态：有唯一标识OID，已经被session管理
- 脱管态：有唯一标识OID，没有被session管理
- 状态转换：（了解）
- Hibernate的一级缓存
- 一级缓存：Hibernate优化手段，称为是session级别缓存。
- 一级缓存：快照区
- Hibernate的事务管理
- Hibernate的其他的API
- Query ：HQL 面向对象方式的查询。
- Criteria ：QBC 完成面向对象化。
- SQLQuery ：SQL查询
Hibernate的一对多关联映射
数据库表与表之间的关系
- 一对多关系
例1：一个部门对应多个员工，一个员工只属于某一个部门。
例2：一个客户对应多个联系人，联系人只能属于某一客户。- 建表原则：在所得一方创建外键指向一的一方的主键。
- 建表原则：在所得一方创建外键指向一的一方的主键。
- 多对多关系
例1：一个学生可以选择多门课程，一门课程也可以被多个学生选择
例2：一个用户可以选择多个角色，一个角色可以被多个用户选择。- 多对多的建表原则：创建一个中间表，中间表中至少有两个字段，分别作为外键指向多对多双方的主键。
- 多对多的建表原则：创建一个中间表，中间表中至少有两个字段，分别作为外键指向多对多双方的主键。
- 一对一关系(了解)
例1：一个公司只能有一个注册地址，一个注册地址只能被一个公司注册。
Hibernate的一对多的关系配置
1. 创将一个java项目，引入相应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. 创建实体类
- 一 的一方的实体
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> linkMans = new HashSet<LinkMan>();
- 多 的一方的实体
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;
注意：每个属性都得有set和get方法。
4. 创建映射文件
- 多 的一方的映射的创建
<!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="cn.itcast.hibernate.domain.LinkMan" table="cst_linkman">
<!-- 建立OID与主键的映射 -->
<id name="lkm_id" column="lkm_id">
<generator class="native"/>
</id>
<!-- 建立普通属性与数据库字段的映射 -->
<property name="lkm_name"/>
<property name="lkm_gender"/>
<property name="lkm_phone"/>
<property name="lkm_mobile"/>
<property name="lkm_email"/>
<property name="lkm_qq"/>
<property name="lkm_position"/>
<property name="lkm_memo"/>
<!-- 配置多对一的关系：放置的是 一 的一方的对象 -->
<!--
many-to-one标签：
*name ：一 的一方的对象的属性名称
*class ：一 的一方的类的全路径
*column ：在 多 的一方的表的外键的名称
-->
<many-to-one name="customer" class="cn.itcast.hibernate.domain.Customer" column="lkm_cust_id"></many-to-one>
</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="cn.itcast.hibernate.domain.Customer" table="cst_customer">
<!-- 建立OID与主键的映射 -->
<id name="cust_id" column="cust_id">
<generator class="native"/>
</id>
<!-- 建立普通属性与数据库字段的映射 -->
<property name="cust_name" column="cust_name"/>
<property name="cust_source" column="cust_source"/>
<property name="cust_industry" column="cust_industry"/>
<property name="cust_level" column="cust_level"/>
<property name="cust_phone" column="cust_phone"/>
<property name="cust_mobile" column="cust_mobile"/>
<!-- 配置一对多的映射：放置的 多 的一方的集合 -->
<!--
set标签：
*name：多 的一方的对象集合的属性名称
-->
<set name="linkMans">
<!--
key标签
*column：多 的一的外键的名称
-->
<key column="lkm_cust_id"></key>
<!--
one-to-many标签
*class：多 的一方的类的全路径
-->
<one-to-many class="cn.itcast.hibernate.domain.LinkMan"/>
</set>
</class>
</hibernate-mapping>
5. 创建核心配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!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:///hibernate_day03?useSSL=false</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">123456</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>
<!-- 设置事务隔离级别 -->
<property name="hibernate.connection.isolation">4</property>
<!-- 配置当前线程绑定的Session-->
<property name="hibernate.current_session_context_class">thread</property>
<!-- 引入映射文件 -->
<mapping resource="cn/itcast/hibernate/domain/Customer.hbm.xml"/>
<mapping resource="cn/itcast/hibernate/domain/LinkMan.hbm.xml"/>
</session-factory>
</hibernate-configuration>
6. 引入工具类
public class HibernateUtils {
public static final Configuration cfg;
public static final SessionFactory sf;
static {
cfg = new Configuration().configure();
sf = cfg.buildSessionFactory();
}
public static Session openSession() {
return sf.openSession();
}
public static Session getCurrentSession() {
return sf.getCurrentSession();
}
}
7. 编写测试类
public class HibernateDemo1 {
@Test
//保存两个客户和三个联系人，并且建立好关系
public void demo1() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//创建两个客户
Customer customer1 = new Customer();
customer1.setCust_name("李末");
Customer customer2 = new Customer();
customer2.setCust_name("小马");
//创建三个联系人
LinkMan lkm1 = new LinkMan();
lkm1.setLkm_name("小明");
LinkMan lkm2 = new LinkMan();
lkm2.setLkm_name("小苏");
LinkMan lkm3 = new LinkMan();
lkm3.setLkm_name("阿光");
//设置关系
lkm1.setCustomer(customer1);
lkm2.setCustomer(customer1);
lkm3.setCustomer(customer2);
customer1.getLinkMans().add(lkm1);
customer1.getLinkMans().add(lkm2);
customer2.getLinkMans().add(lkm3);
//保存数据
session.save(customer1);
session.save(customer2);
session.save(lkm1);
session.save(lkm2);
session.save(lkm3);
transaction.commit();
}
}
8. 执行结果
Hibernate的一对多的相关操作
1. 一对多关系只保存一边是否可以？
@Test
// 一对多关系只保存一边是否可以？
public void demo2() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("李末");
LinkMan lkm = new LinkMan();
lkm.setLkm_name("小苏");
customer.getLinkMans().add(lkm);
lkm.setCustomer(customer);
//只保存一边，不可以，报错：瞬时对象异常：持久态对象关联了一个瞬时态对象
//session.save(customer);
session.save(lkm);
transaction.commit();
}
不可以，会报错：瞬时对象异常
org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: cn.itcast.hibernate.domain.LinkMan
2. 一对多的级联操作
级联是指操作某一个对象的时候，是否会同时操作其他关联的对象。
级联是有方向性的：
操作 一 的一方的时候，是否操作到 多 的一方
操作 多 的一方的时候，是否操作到 一 的一方
- 级联保存或更新
- 保存客户级联联系人
保存客户级联联系人，操作的主体是客户对象，需要在Customer.hbm.xml中进行配置 cascade=“save-update”
- 保存客户级联联系人
<!--
set标签：
*name：多 的一方的对象集合的属性名称
-->
<set name="linkMans" cascade="save-update">
测试代码
@Test
// 级联保存或更新
// 保存客户级联联系人，操作的主体是客户对象，需要在Customer.hbm.xml中进行配置
// <set name="linkMans" cascade="save-update">
public void demo3() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("李末");
LinkMan lkm = new LinkMan();
lkm.setLkm_name("小苏");
customer.getLinkMans().add(lkm);
lkm.setCustomer(customer);
session.save(customer);
transaction.commit();
}
- 保存联系人级联客户
保存联系人级联客户，操作的主体是联系人对象，需要在LinkMan.hbm.xml中进行配置 cascade=“save-update”
<!-- 配置多对一的关系：放置的是 一 的一方的对象 -->
<!--
many-to-one标签：
*name ：一 的一方的对象的属性名称
*class ：一 的一方的类的全路径
*column ：在 多 的一方的表的外键的名称
-->
<many-to-one name="customer" class="cn.itcast.hibernate.domain.Customer" column="lkm_cust_id" cascade="save-update"></many-to-one>
测试代码
@Test
// 级联保存或更新
// 保存联系人级联客户，操作的主体是联系人对象，需要在LinkMan.hbm.xml中进行配置
public void demo4() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("李大");
LinkMan lkm = new LinkMan();
lkm.setLkm_name("小花");
customer.getLinkMans().add(lkm);
lkm.setCustomer(customer);
session.save(lkm);
transaction.commit();
}
- 测试对象的导航
Test
// 测试对象的导航
// 前提：一对多的双方都设置了casecade="save-update"
public void demo5() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("李大");
LinkMan lkm1 = new LinkMan();
lkm1.setLkm_name("小花");
LinkMan lkm2 = new LinkMan();
lkm2.setLkm_name("小苏");
LinkMan lkm3 = new LinkMan();
lkm3.setLkm_name("阿光");
lkm1.setCustomer(customer);
customer.getLinkMans().add(lkm2);
customer.getLinkMans().add(lkm3);
// 双方都设置了casecade="save-update"
//session.save(lkm1);// 发送几条insert语句？ 四条
//session.save(customer);// 发送几条insert语句？ 三条
session.save(lkm2);// 发送几条insert语句？ 一条
transaction.commit();
}
显示的四条insert语句
- 级联删除
删除一边的时候，同时将另一边的数据也删除。- 不设置级联删除，默认情况
先将外键update为null，再进行删除。
- 删除客户级联删除联系人：
删除客户级联删除联系人，删除的主体是客户，需要在Customer.hbm.xml中配置 cascade=“delete”
具体实现：
- 不设置级联删除，默认情况
@Test
// 级联删除
// 删除客户级联删除联系人，删除的主体是客户，需要在Customer.hbm.xml中配置
// <set name="linkMans" cascade="delete">
public void demo6() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 没有设置级联删除，默认情况:修改联系人的外键，删除客户
/*Customer customer = session.get(Customer.class, 1l);
session.delete(customer);*/
//删除客户，同时删除联系人
Customer customer = session.get(Customer.class, 1l);
session.delete(customer);
transaction.commit();
}
执行过程：
1. 根据id查询客户
2. 根据外键id值查询联系人
3. 把联系人外键设置为null
4. 删除联系人和客户
- 删除联系人级联删除客户(基本不用)
具体实现
@Test
// 级联删除
// 删除联系人级联删除客户，删除的主体是联系人，需要在LinkMan.hbm.xml中配置
// <many-to-one name="customer" cascade="delete">
public void demo7() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 删除联系人，同时删除客户
LinkMan linkMan = session.get(LinkMan.class, 1l);
session.delete(linkMan);
transaction.commit();
}
- 一对多设置了双向关联产生多余的SQL语句
代码
@Test
/**
* 将2号联系人原来属于1号客户，现改为属于2号客户
*/
public void demo8() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
// 查询2号联系人
LinkMan linkMan = session.get(LinkMan.class, 2l);
// 查询2号客户
Customer customer = session.get(Customer.class, 2l);
// 双向的关联
linkMan.setCustomer(customer);
customer.getLinkMans().add(linkMan);
transaction.commit();
}
因为hibernate双向维护外键，在客户和联系人里面都需要维护外键，修改客户时候修改一次外键，修改联系人时候也修改一次外键，造成效率问题
分析：
解决方式：
1、单向维护：
2、使一方放弃外键维护权：
一 的一方放弃。在set上配置inverse=”true”
<!--
set标签：
*name：多 的一方的对象集合的属性名称
*casecade:级联
*inverse：放弃外键维护权。
-->
<set name="linkMans" cascade="save-update,delete" inverse="true">
放弃外键维护权的其他使用：一对多的关联查询的修改的时候。(CRM练习)
3. 区分casecade和inverse
@Test
/**
* 区分casecade和inverse
*/
public void demo9() {
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("李兵");
LinkMan linkMan = new LinkMan();
linkMan.setLkm_name("小明");
customer.getLinkMans().add(linkMan);
// 条件在Customer.hbm.xml上配置了casecade="save-update" inverse="true"
session.save(customer); //k客户会插入、联系人会插入、但是外键为null
transaction.commit();
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
