Hibernate3 第二天

Hibernate3 第二天

第一天回顾：

1. 三个准备

• 创建数据库
• 准备po和hbm文件
• 准备灵魂文件hibernate.cfg.xml

1. 七个步骤

• 1 加载配置文件Configuration
• 2 创建会话工厂SessionFactory
• 3 获取连接Session
• 4 开启事务Transaction
• 5 各种操作
• 6 提交事务commit
• 7 关闭连接close

  今天内容安排：

1. Hibernate的持久化对象（PO）相关状态和操作。（重点理解）

• Hibernate持久化对象的状态（3个）和转换。
• Session的一级缓存。
• Session一级缓存的快照（snapshot）。

1. 多表关联映射配置和操作（重点应用）

• 一对多关联映射配置和操作、以及级联配置、外键维护配置。
• 多对多关联映射配置和操作。

  学习目标：

1. 掌握Hibernate的核心概念：PO的状态+一级缓存和快照
2. 掌握多表映射的配置、级联配置和增删改的操作（项目中使用）
3. 逐步学会和习惯使用debug

1. Hibernate的持久化对象相关概念和操作

   1. Hibernate持久化对象(po)的状态和转换

      1. 持久化对象的状态

官方描述：

Hibernate 将操作的PO对象分为三种状态：

• 瞬时 （Transient ）/ 临时： 通常new 创建对象(持久化类)，未与Session关联，没有OID
• 持久 （Persistent） ： 在数据库存在对应实例，拥有持久化标识OID， 与Session关联（受session管理）
• 脱管 （Detached）/游离：当Session关闭后，持久状态对象与Session断开关联，称为脱管对象，此时也持有OID

搭建测试环境：创建项目Hibernate3_day02

1. 导入开发jar包（11个），将hibernate.cfg.xml、log4j.properties复制到src，修改Hibernate.cfg.xml的jdbc连接参数，导入hibernateUtils工具类。
2. 创建包:cn.itcast.a_postate，在包中创建Customer类，代码如下：
3. 编写hbm映射

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

<!-- 配置java类与数据表的对应关系

name:java类名

table：表名

-->

<class name="cn.itcast.a_postate.Customer" table="t_customer">

<!-- 配置主键 -->

<id name="id">

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

</id>

<!-- 配置其他属性 -->

<property name="name"></property>

<property name="age"></property>

</class>

</hibernate-mapping>

1. 在hibernate.cfg.xml加载映射配置

5 创建TestPOState类，描述对象的三状态。

在类中编写测试testSave方法：代码如下：

@Test

public void testSave(){

//瞬时态：

//特点：没有OID，new出来的一个对象，不与session关联，不受session管理，数据库中没有对应的记录

Customer customer = new Customer();

customer.setName("rose");

customer.setAge(18);

System.out.println(customer);

Session session = HibernateUtils.openSession();

session.beginTransaction();

//在save执行之前，customer都只是瞬时态

//当save执行之后，customer就处于持久态

session.save(customer);

//持久态

//        /特点：有OID，数据库存在对应的记录，与session关联，受session管理

System.out.println(customer);

session.getTransaction().commit();

session.close();

//只要session已关闭，那么久处于脱管态

//有OID，数据库中存在对应的记录，但是不与session关联，不受session管理

System.out.println(customer);

}

三种状态的区别分析：

• 持久态和瞬时态、脱管态：容易区别，持久态主要特点是与Session关联，而且数据库中有对应记录、拥有OID，因此，只要与session关联的就是持久态。

瞬时态和脱管态：相同点是都和Session没关联，不同点是瞬时态没有OID，而脱管态有OID。

【思考】

通过上述的分析，发现，瞬时态和脱管态对象就差一个OID，那么瞬时态的对象中给主键ID属性赋值后就是脱管态了么？

未必！

首先，需要区分持久化标识OID和对象中主键ID属性的关系：

• 在持久化之前，虽然有ID属性，但数据库中没有对应的数据，那么此时OID是null；
• 在持久化之后，这个ID属性值被插入数据库中当主键了，数据库中有对应的数据了，此时OID就有值了，而且与主键值保持一致性，比如类型、长度等。

因此：OID和PO对象中主键ID属性的区别就是：数据库存在不存在，如果存在就是OID，如果不存在，那就是个ID属性而已。

瞬时态和脱管态的区别总结：

• 脱管态对象：有持久化的标识oid，并且在数据库中存在。
• 瞬时态对象：无持久化标识oid，或者有id但在数据库中不存在的。

例如：

Customer对象具有Id属性值，如果数据库中不存在，则该对象还是瞬时态对象，如果数据库中存在，则认为是脱管态的。

【三者的区别最终总结】：

对于三者：在session中存在的，就是持久化对象，不存在的就是瞬时或脱管对象。

对于瞬时和脱管对象：有oid（持久化标识）的就脱管对象，没有的就是瞬时对象。

OID一定是与数据库主键一一对应的

	是否有持久化标识OID	session是否存在	数据库中是否有
瞬时态对象-临时状态	n	n	n
持久态对象	y	y	y/（n：没有提交）
脱管态对象-游离	y	n	y

1. 持久化对象状态的相互转换

持久化对象状态转换图（官方规范）：

【分析】：（各状态对象的获取方式以及不同状态之间转换的方法介绍）：

• 瞬时对象：

如何直接获得 --- new 出来

转换到持久态 ---- save、saveOrUpdate 保存操作

转换到脱管态 ---- setId 设置OID持久化标识（这个id是数据库中存在的）

• 持久对象

  如何直接获得 ---- 通过session查询方法获得 get、load、createQuery、createSQLQuery、createCriteria

转换到瞬时态 ---- delete 删除操作 （数据表不存在对应记录 ）（其实还有id，只是不叫OID）

转换到脱管态 ---- close 关闭Session， evict、clear 从Session清除对象

• 脱管对象

  如何直接获得 ----- 无法直接获得 ，必须通过瞬时对象、持久对象转换获得

转换到瞬时态 ---- 将id设置为 null,或者手动将数据库的对应的数据删掉或者将id修改成数据库中不存在的

转换到持久态 ---- update、saveOrUpdate、lock （对象重新放入Session ，重新与session关联）

在Hibernate所有的操作只认OID，如果两个对象的OID一致，它就直接认为是同一个对象。

1. Session的一级缓存（重点理解）

   1. 什么是一级缓存？

又称为：hibernate一级缓存、session缓存、session一级缓存

• 缓存的概念：在内存上存储一些数据

缓存的介质是一般是内存(硬盘)，用来存放数据，当第一次查询数据库的时候，将数据放入缓存，当第二次继续使用这些数据的时候，就不需要要查询数据库了，直接从缓存获取，

• 一级缓存概念：

在Session接口中实现了一系列的java集合，这些java集合构成了Session的缓存，只要Session的生命周期没有结束，session中的数据也就不会被清空。

• 缓存作用：

将数据缓存到内存或者硬盘上，访问这些数据，直接从内存或硬盘加载数据，无需到数据库查询。

好处: 快! 降低数据库压力。

• 一级缓存的生命周期：

Session中对象集合(map)，在Session创建时，对象集合(map)也就创建，缓存保存了Session对象数据，当Session销毁后，集合（map）销毁， 一级缓存释放 ！

• 什么对象会被放入一级缓存？

只要是持久态对象，都会保存在一级缓存 （与session关联的本质，就是将对象放入了一级缓存）

一级缓存的作用：第一次get/load的时候，肯定会发出sql语句，查询数据库，（此时会将数据放入一级缓存），只要session不关闭，

第二次get/load的时候，直接从缓存中读取数据，不会发出sql语句，查询数据库（这里的数据指的是同一条记录：OID相等）

【示例】证明一级缓存的存在性！

通过多次查询同一个po对象数据，得到同一个对象，且第二次不再从数据库查询，证明一级缓存存在。

@Test

public void testFirstCacheExist(){

/**

* 证明一级缓存的存在性

* 证明思路：

* 缓存的作用就是用来少查数据库的，提高访问速度

* 第一步，通过get/load查询数据，由于是第一次查询，所以必然发出sql语句，查询数据库

* 第二步，不关闭session，继续使用当前的session去get/load数据，观察是否发出sql语句

* 如果不发出，表明是从一级缓存取出的数据

*/

Session session = HibernateUtils.openSession();

session.beginTransaction();

//第一步:此时必然发出sql语句，然后自动将数据放入一级缓存

Customer customer = (Customer) session.get(Customer.class, 1);

System.out.println(customer);

//第二步：此时不会发出sql语句，直接从一级缓存获取数据

Customer customer2 = (Customer) session.get(Customer.class, 1);

System.out.println(customer2);

session.getTransaction().commit();

session.close();

}

测试（同一个对象）：

1. 一级缓存的生命周期

一级缓存的生命周期就是session的生命周期，不能跨Session，可以说，一级缓存和session共存亡！

【示例】

使用两个不同Session来测试生命周期。（一级缓存和session共存亡）

@Test

public void testFirstCachelifecycle(){

/**

* 一级缓存的声明周期：与session同生命共存亡

* 如何证明一级缓存的生命周期？

* 只要证明数据不能跨session

* 1 获取session1，通过session1拿到customer对象，此时必然发出sql语句，关闭session1

* 2 获取session2，通过session2继续抓取customer对象，观察第二次是否发出sql语句

* 如果发出，，表名session1销毁的时候，把数据也销毁了

*/

Session session1 = HibernateUtils.openSession();

session1.beginTransaction();

//此时必然发出sql语句，因为是第一次查询

Customer customer = (Customer)session1.get(Customer.class, 1);

System.out.println(customer);

//        此处如果需要查询Customer，会发sql语句吗？答：不会，直接走一级缓存

//也能证明数据成功存入了一级缓存

Customer customer2 = (Customer)session1.get(Customer.class, 1);

System.out.println(customer2);

session1.getTransaction().commit();

session1.close();

/**********第二次*********/

Session session2 = HibernateUtils.openSession();

session2.beginTransaction();

//此时发sql语句吗？答：发，因为session1中的数据跟随session1一起销毁了

Customer customer3 = (Customer)session2.get(Customer.class, 1);

System.out.println(customer3);

session2.getTransaction().commit();

session2.close();

}

测试：

小结：缓存的作用，可以提高性能，减少数据库查询的频率。

[补充：原则]所有通过hibernate操作(session操作)的对象都经过一级缓存。

一级缓存是无法关闭的！内置的！hibernate自己维护的！

1. Session一级缓存的快照

   1. 什么是一级缓存的快照(snapshot)

什么是快照？

答：快照，是数据在内存中的副本，是数据库中数据在内存中的映射。

如：

一句话：

快照跟数据库数据保持一致

快照的作用就是用来更新数据的。

1. 一级缓存快照的原理（图）

采用快照技术进行更新，不需要手动的调用update 方法，完全是自动的发出update语句。

保正一级缓存、数据库、快照的一致性

【注意】

1. 持久态对象原则：po对象尽量保持与数据库一一致。
2. 当一级缓存和快照不一致的时候，会先发出update语句，将一级缓存同步到数据库（发出update语句），然后当同步成功之后，再自动内部同步快照。保证三者的一致性。

1. 一级缓存快照的能力

一级缓存的快照是由Hibernate来维护的，用户可以更改一级缓存（PO对象的属性值），但无法手动更改快照！

快照的主要能力（作用）是：用来更新数据！当刷出缓存的时候，如果一级缓存和快照不一致，则更新数据库数据。

【示例】

通过改变查询出来的PO的属性值，来查看一级缓存的更改；通过提交事务，来使用快照更新数据。

@Test

public void testSnapShot(){

/**

* 证明快照的能力：自动更新数据

* 1 从数据库查找一个对象，改变对象的某个值，手动的flush，看控制台是否发出sql语句,

* 如果控制台发出update语句，就可以表明快照的能力

*/

Session session = HibernateUtils.openSession();

session.beginTransaction();

//get的时候，不光将数据放入一级缓存，还同时将数据同步到了快照中

Customer customer = (Customer)session.get(Customer.class, 1);

System.out.println(customer);

//修改customer对象的值

customer.setName("lucy");

//这个值是改变过后的值，是内存中的值

System.out.println(customer);

//提交事务

//如果不手动flush，在事务commit的时候，会先flush，在commit

session.getTransaction().commit();

session.close();

}

【能力扩展】快照可以用来更新数据，而且，可以用来更新部分数据。

【问题】update也是更新数据，快照也是更新数据？两个有什么区别？

Update更新的时候，会将所有值都更新，如果有某个属性没有赋值，值将会被置空

快照符合我们修改的要求：先查后改

1. 刷出缓存的时机

什么叫刷出缓存？

Session能够在某些时间点，按照缓存中对象的变化来执行相关的SQL语句，来同步更新数据库，这一过程被成为刷出缓存（flush）。

通俗的说法：将一级缓存的数据同步到数据库，就是刷出缓存

什么情况下session会执行 flush操作？

刷新缓存的三个时机：

• 事务提交commit()：该方法先刷出缓存（session.flush()），然后再向数据库提交事务。
• 手动刷出flush()：直接调用session.flush()。
• 查询操作：当Query查询（get、load除外,这两个会优先从一级缓存获取数据）时，会去比较一级缓存和快照，如果数据一致，则去数据库直接获取数据，如果缓存中持久化对象的属性已经发生了变化，（一级缓存和快照不一样了），则先刷出缓存，发出update语句，然后查询，以保证查询结果能够反映出持久化对象的最新状态。（Query查询数据不走一级缓存）

【补充理解】：

关于Hibernate如何识别同一个对象？

根据OID，

问题：假如先查询出来一个对象oid是1001，数据库主键也是1001，但其他字段的属性不一样，那么，再次查询数据库的数据出来的对象，和原来的对象是否是一个对象？

答案：是！

【示例】

1 、通过commit 的方式隐式的刷出缓存(证明略)

2 、通过flush的方式手动的刷出缓存

//采用flush的方式手动的刷出缓存

@Test

public void testflushcache2()

{

Session session = HibernateUtils.openSession();

// 开启 事务

session.beginTransaction();

//获取数据

Customer customer = (Customer)session.get(Customer.class, 1);

System.out.println(customer);

customer.setName("rose");

//手动的flush,发出update语句，更新数据库，并且同时更新快照

session.flush();

session.getTransaction().commit();

//特点：在数据库中存在对应的记录，有OID，但是不受session管理

session.close();

}

3 、使用Query的时候，（不包含get、laod:原因：get和load的处理方式，是直接获取缓存的数据，即使一级缓存和快照的数据不一致）

会去比较一级缓存和快照是否一致，如果一致，他直接去查询（1条select语句）

当不一致了，会先发出update语句，更新数据库，然后在查询(1条update语句，1条select语句)

3.1 测试get和load 的处理方式

@Test

public void testGetAndLoad_Cache(){

/**

* 证明get和load优先从缓存取数据，哪怕一级缓存和快照的数据不一致，

* 它也是直接取缓存数据

* 证明思路:

* 第一步，将数据放入一级缓存和快照

* 第二步，取 ，观察是否发出sql语句和数据

* 第三步，改

* 第四部，取 ，观察是否发出sql语句和数据

*

*/

Session session = HibernateUtils.openSession();

session.beginTransaction();

// 1 取，并且放入一级缓存和快照

Customer customer1 = (Customer) session.get(Customer.class, 1);

System.out.println(customer1);

//2 取:肯定不发sql语句，直接从缓存取

Customer customer2 = (Customer) session.get(Customer.class, 1);

System.out.println(customer2);

//3 改：

customer2.setName("tom");

//4 取，虽然此时一级缓存和快照不一致，但是get/load也是直接抓取缓存数据

Customer customer4 = (Customer) session.get(Customer.class, 1);

System.out.println(customer4);

//隐式flush

session.getTransaction().commit();

session.close();

}

3.2 测试query的工作方式：

【证明1】query对象不走一级缓存

//query不走一级缓存

@Test

public void testQuery_cache(){

//        证明query不使用session缓存的数据，即使缓存中有，它也会发出sql语句，查询数据库

Session session = HibernateUtils.openSession();

session.beginTransaction();

//        /此处也会发出sql语句

Customer customer = (Customer)session.get(Customer.class, 1);

System.out.println(customer);

//此时必须发出sql语句，因为它不会直接从一级缓存中拿数据

Customer customer2 = (Customer)session.createQuery("from Customer where id = 1").uniqueResult();

System.out.println(customer2);

session.getTransaction().commit();

session.close();

}

【证明2】但是Query对象在查询数据的时候，会去校验一级缓存和快照的数据是否一致，

如果不一致，发出update语句，更新数据库，然后再发出sql查询语句

//证明2：query对象虽然不从一级缓存取数据，但是在它去数据库查找数据之前，会干这么一件事情：

// 会比较一级缓存和快照是否一致，

// 如果一致，直接去数据库查找需要的数据

// 如果不一致，先flush(先发出update语句)，再去数据库查找需要的数据

@Test

public void testQuery2(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

Customer customer1 = (Customer) session.get(Customer.class, 1);

System.out.println(customer1);

customer1.setName("tom");

Customer customer2 = (Customer) session.createQuery("from Customer where id = 1").uniqueResult();

System.out.println(customer2);

session.getTransaction().commit();

session.close();

}

【提示】

flush和commit的区别：

• flush是发语句的。
• commit的是数据库层面的是否保存更改的数据(是否提交数据，是否持久化数据到数据库),若不手动发出flush， hibernate在commit之前自动先flush()；

1. 一级缓存的刷出模式--（了解）

问题:能否改变一级缓存的刷出时机？答案是可以的.

【示例】

通过在session上设置手动flush模式测试：只能通过flush刷出缓存

@Test

public void testFlushMode(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

// 1 第一步证明：先不设置FlushMode，看运行结果

Customer customer = (Customer)session.get(Customer.class, 1);

//改变缓存中对象的属性

customer.setName("lucy");

// 2 第二证明：设置FlushMode，看运行结果

//这个一旦设置，只有手动flush的时候，才会发出update语句

session.setFlushMode(FlushMode.MANUAL);

//第二种方式，手动flush，发出update语句

session.flush();

//在第一种情况下，此处必然发出update语句

//在第二种情况下，此处必然不会发出update语句

session.getTransaction().commit();

session.close();

}

1. 一级缓存的常用操作

操作一级缓存中的对象

一级缓存除了可以flush之外，还可以清除（clear，evict）、重载（refresh）。

• flush：刷出一级缓存

作用：当一级缓存发生变化时，即和快照不同时，刷出一级缓存，会自动向数据库提交update语句。

• clear：清除一级缓存中所有的数据

作用：清除一级缓存中的所有对象，这些对象被清除后，会从持久态对象变成脱管态.

【扩展理解】

持久态对象与session关联的另一层含义就是对象在一级缓存中存在。

• evict：清除一级缓存指定对象

作用：清除一级缓存中的指定对象，使对象变成脱管态的。

• refresh：刷新一级缓存

  通俗的讲：不管内存中对象是否发生了更新，重新将数据库中的内容加载到缓存中，覆盖原来的值

@Test

public void testClearAndEvict(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

//此时数据会被放入一级缓存

Customer customer = (Customer)session.get(Customer.class, 1);

System.out.println(customer);

//在第二次获取之前插入代码：clear 一级缓存

//clear：清除一级缓存中的所有数据

//        session.clear();

//evict:清除一级缓存的指定对象,主要清除的是OID=1的这个对象

session.evict(customer);

//由于第一次get的时候，已经发出了sql语句查询数据库，所以，第二次get的时候就不会发sql语句

//如果我们执行了session.clear()代码，表示一级缓存数据被清空了，那么这次获取的时候

//还是要继续发出sql语句的

Customer customer2 = (Customer)session.get(Customer.class, 1);

System.out.println(customer2);

session.getTransaction().commit();

session.close();

}

//refresh： 不管缓存中的数据是否发生了改变，将数据库中的数据重新放入缓存

//如果缓存的数据发生了改变，那么这个改变将会被覆盖

@Test

public void testRefresh(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

Customer customer = (Customer)session.get(Customer.class, 1);

customer.setName("rose");

System.out.println(customer);

//从数据库中根据OID重新加载这条记录，原先的改变失效，数据库中原始的值会覆盖修改的值

session.refresh(customer);

System.out.println(customer);

session.getTransaction().commit();

session.close();

}

【面试题】请你说说session的flush和refresh的区别？

为什么要清除一级缓存：

大批量处理数据的时候，有些数据无需在一级缓存存在，或者已经处理完了，为了防止内存泄漏，一级缓存爆满，可以手动清除一级缓存的对象。

1. get()和load()的区别

【状态变化】直接拿到持久态对象。

【理解 session的get方法和load方法区别】

两者的区别：

get()方法是立即加载，即执行get方法后，立即发出查询语句进行查询，直接返回目标对象。

load()方法是延迟加载，即执行load方法后，不会立即发出查询语句，返回具有id的目标对象代理类子对象，再访问对象的除了ID之外的其他属性的时候，才发出SQL语句进行查询。

【示例】

分别用get和load，来根据不同id查询不同对象，使用debug来查看语句发出的时机以及延迟加载时的代理类子对象。

@Test

public void testGetAndLoad(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

//比较get和load的区别

//1 观察get和load的sql语句发出时机

//get方法立即发出sql语句

//        Customer customer = (Customer) session.get(Customer.class, 1);

//        System.out.println(customer);

//load方法：属于懒加载，如果只用到id属性，是不会发出sql查询语句的

//只有用到id以外的其他属性的时候，才会发出sql查询语句

Customer customer = (Customer) session.load(Customer.class, 1);

//简单的打印id,发出sql语句吗？

System.out.println(customer.getId());

//发出sql语句吗？

System.out.println(customer.getName());

session.getTransaction().commit();

session.close();

}                

C2引用的Customer的代理子对象

继续调试

初始化后，内部handler中initialized变为true （已经初始化）， target 指向真正查询结果对象

【关于load延迟加载的几个情况提示】

• 代理子对象，handler属性,包含了主键id，因此只访问id时，不需要发出sql语句。

【示例】

延迟加载时，访问ID属性不发出sql，访问ID之外的属性时发出sql

//load:不会立即发出sql，只有在访问除id之外的其他属性的时候，才发出sql

Customer customer2 =(Customer) session.load(Customer.class, 2);

System.out.println(customer2.getId());//不需要发出sql

System.out.println(customer2.getName());//此时才发出sql

• 当id在数据库中不存在的时候，访问其他属性时会发生 ObjectNotFoundException。

【示例】

两者查不到数据的区别：

结论：get会返回null，load会报错：

【扩展了解】

代理子对象是谁来负责生成的？

答：通过javassist.jar来进行生成子对象(反射机制)

延迟加载的好处：节约资源，需要的时候再加载（提高内存利用率），如果不需要的话，先不加载。

1. 多表关联映射配置和操作（未来项目肯定会用）

   1. 多表设计

多对多： 学生选课 （一个学生选多门课， 一门课被多个学生选择）

一对多： 客户和订单 （一个客户可以产生很多订单， 一个订单属于一个客户）

一对一： 一个公司对应建表规则：

多对多： 一定产生第三方关系表， 需要三张表 （学生表、 课程表、 选课表）， 关系表联合主键，引入两张实体表主键，作为外键

一对多： 在多方表，添加一方主键作为外键 ，不需要第三张表 ， 需两张表（客户表 、订单表），在订单表添加客户id

一对一： 在任意一方添加对方主键作为外键

一个地址

范式：可以理解成是数据库设计的规范/标准

为什么表的设计需要有规范和标准？

防止数据冗余，科学的数据库设计可以防止数据冗余

//一般数据库的设计要符合3NF，符合的范式要求越高，表越多

范式之间的关系：

第一范式（1NF）：保证每列的原子性（每列都是不可再分割的单元）

学生表

stuno	stuinfo	Coursename
1	Lucy23	Java
1	Tom18	Oracle
1	Rose12	Hibernate

上表是不符合第一范式的，修改如下

stuno	Name	Age	Coursename
1	Lucy	23	Java
1	Tom	18	Oracle
1	Rose	12	Hibernate

第二范式：保证表有主键

上表符合第二范式吗？不符合，因为没有主键，修改如下：

stuno	Name	Age	Coursename
1	Lucy	23	Java
2	Tom	18	Oracle
3	Rose	12	Hibernate

第三范式：每张表不包含其他表中非主键以外的字段（每张表的字段都依赖于当前的主键）

上表符合第三范式吗？答：不符合，修改如下

stuno	Name	Age
1	Lucy	23
2	Tom	18
3	Rose	12

Courseid	Coursename
1	Java
2	Oracle
3	Hibernate

关系表：

Stuno	Courseid
1	1
1	2
2	1
2	3

BCNF

4NF

5NF

1. java对象(po)描述表关系

Hibernate 是一个完全ORM框架，使用hibernate 编程，可以完成类和表映射

多对多 ：

Student {

// 一个学生对应 多门课

// Set、List、bag、数组 代表复数，基本区别：set不能重复，没顺序、list可以重复，有顺序。bag：不能重复，而且有顺序（缺点：效率低）

Set<Cource> cources ;

}

Cource {

// 一门课，多个学生

Set<Student> students ;

}

一对多 ：

Customer {

// 一个客户 多个订单

Set<Order> orders ;

}

Order {

// 一个订单 一个客户

Customer customer ;

}

一对一：

Company {

// 一个公司 一个地址

Address address;

}

Address {

// 一个地址 对应一个公司

Company company ;

}

我们下面重点学习一对多和多对多！

1. 一对多关联映射配置

案例：客户和订单（一对多）

建立一个包用于测试: cn.itcast.b_oneToMany

1. 映射配置

编写方法：实体类的编写，先写单表的属性和配置，再加关系。

【第一步】：实体类编写

【第二步】：hbm映射文件编写

Order.hbm.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>

<class name="cn.itcast.b_onetomany.Order" table="t_order">

<!-- 主键 -->

<id name="id">

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

</id>

<!-- 其他属性 -->

<property name="name"></property>

<!-- 配置关系

name:类中属性

class:这个属性的原型(属性对应对象的完整的包路径)

column:customer在Order表中的外键的名字

-->

<many-to-one name="customer" class="cn.itcast.b_onetomany.Customer" column="cid"></many-to-one>

</class>

</hibernate-mapping>

Customer.hbm.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>

<!-- class -->

<class name="cn.itcast.b_onetomany.Customer" table="t_customer">

<!-- 配置主键 -->

<id name="id">

<!-- 主键策略 -->

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

</id>

<!-- 其他属性 -->

<property name="name"></property>

<!-- 配置集合

name:类中的属性名

-->

<set name="orders">

<!-- 配置当前Customer对象在order表中的外键的名字 -->

<key column="cid"></key>

<!-- 配置关系

class：当前order对应的完整的包路径(集合中装载的数据的原型)

-->

<one-to-many class="cn.itcast.b_onetomany.Order"/>

</set>

</class>

</hibernate-mapping>

注意：两个配置文件的外键必须对应！！！！！

【第三步】：核心配置文件中添加映射

<!-- 配置一对多的映射文件 -->

<mapping resource="cn/itcast/b_onetomany/Customer.hbm.xml"/>

<mapping resource="cn/itcast/b_onetomany/Order.hbm.xml"/>

【第四步】：建表测试

@Test

public void createTable()

{

HibernateUtils.getSessionFactory();

}

建表成功:

提示：外键的数据类型自动会使用对方主键的类型

1. 相关操作

本节难点：cascade级联和inverse外键维护

1. 保存操作Save

多表保存的原则：双方都必须是持久态的对象！

目标：学习几种保存方法。

1. 双向关联保存

@Test

public void testSave(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

Customer c1 = new Customer();

c1.setName("rose");

Order o1 = new Order();

o1.setName(c1.getName()+"的订单1");

//双向建立关系

c1.getOrders().add(o1);

o1.setCustomer(c1);

//必须同时保存两个对象，否则会报错

session.save(c1);

session.save(o1);

session.getTransaction().commit();

session.close();

}

这种保存要求:必须双方都建立关系,而且都要执行保存操作.

1. 级联保存

【需求】

保存客户的同时自动保存订单。

默认情况下：

会报错：

原因结论： 在hibernate代码中，在session.flush前，不允许 持久态对象 关联 瞬时态对象

持久态对象只能关联持久态对象！

解决：采用级联 ，cascade ：cascade="save-update"

它的作用：

可以使持久态对象"关联"瞬时态对象， 自动会隐式执行save操作，变为持久态，

可以使持久态对象"关联"脱管对象，自动会隐式执行update操作，变为持久态

如果通过操作customer来级联保存 order ，需要在Customer.hbm.xml(谁是持久的) 配置级联.

Customer.hbm.xml:

测试代码：

@Test

public void testSave(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

Customer c1 = new Customer();

c1.setName("lucy");

Order o1 = new Order();

o1.setName(c1.getName()+"的订单1");

Order o2= new Order();

o2.setName(c1.getName()+"的订单2");

Order o3 = new Order();

o3.setName(c1.getName()+"的订单3");

Order o4 = new Order();

o4.setName(c1.getName()+"的订单4");

//当级联保存的时候，当我们在Customer.hbm.xml中设置了级联关系的时候，

//那么在设置关系的时候，只需要向Customer的orders集合中添加Order，就可以进行级联保存

c1.getOrders().add(o1);

c1.getOrders().add(o2);

c1.getOrders().add(o3);

c1.getOrders().add(o4);

//        o1.setCustomer(c1);

//必须同时保存两个对象，否则会报错

session.save(c1);

//        session.save(o1);

session.getTransaction().commit();

session.close();

}

使用级联之后,Hibernate会对瞬时态的这个对象，会自动执行save操作.

问题:如果保存顺序反过来呢？即先保存订单，同时保存客户呢？
分析:先操作order ，级联保存 customer ，需要在 Order.hbm.xml 配置级联

Order.hbm.xml :

//保存订单的时候，能不能自动的保存customer

@Test

public
void testSave3(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

Customer c1 = new Customer();

c1.setName("jack");

Order o1 = new Order();

o1.setName(c1.getName()+"的订单1");

o1.setCustomer(c1);

session.save(o1);

session.getTransaction().commit();

session.close();

}

级联对于大量的保存或更新操作非常有用。

1. 对象导航—连续保存—其实是依赖于级联。
   

   对象导航概念：通过一个对象的保存操作，可以自动导航到另外一个关联对象的保存操作。
   

下面有个面试题，前提：customer和order都配置了级联保存（双向都配置），那么请问下面的1，2，3语句分别产生几条插入的sql语句，

答案： 4 3 1

@Test

public
void testSaveByCascadeNavi(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

Customer c1 = new Customer();

c1.setName("itcast2");

Order o1 = new Order();

o1.setName(c1.getName()+"的订单1");

Order o2 = new Order();

o2.setName(c1.getName()+"的订单1");

Order o3 = new Order();

o3.setName(c1.getName()+"的订单1");

o1.setCustomer(c1);

c1.getOrders().add(o2);

c1.getOrders().add(o3);

//第一种情况 4

session.save(o1);

//第2种情况 3

session.save(c1);

//第3种情况 1

session.save(o2);

session.getTransaction().commit();

session.close();

}

Hibernate的外键：是由关系来提供

导航保存对于大量的保存或更新操作非常有用。

1. 删除操作delete

表之间的依赖关系:在一对多中 ，多方表(从表)
依赖
一方表(主表) （order依赖customer）。

1. 删除多方的一条数据

// 第一种情况：直接删除多方的数据

//        Order order = new Order();

//        order.setId(7);

//

//        session.delete(order);

删除多方 （订单），直接删除

1. 删除一方的一条数据(问:会如何呢?)

//第二种情况：直接删除一方的数据

Customer customer = new Customer();

customer.setId(4);

//当customer是一个脱管态对象的时候，先解除关系，删除，所以删除之后，你会发现多方的外键被置空

session.delete(customer);

删除一方（客户），被依赖

结果：多方的外键被置空了，一方被删除了(内部机制)

原理：Hibernate 先解除对一方外键依赖，然后进行删除

（如果外键设置 not-null ， 无法删除 ）课后可以试试

1. 级联删除-删除客户自动删除对应的订单（知识点：这里就可以看出删脱管对象和持久对象的区别了）

   级联删除必须是持久态对象才会有级联删除效果，否则是无效的

问题： 从关系型数据库的角度来说:在一对多数据模型中，多方对一方存在依赖的， 如果一方数据被删除，多方数据不完整，无意义。（客户删除的同时，将订单一块都删了）

解决方法： 在一方 配置 cascade="delete" ,会级联删除.

级联删除的要求：被删除的对象要是持久态的对象

@Test

public
void testDelete(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

//删除多方的数据：直接删除

//        Order order = new Order();

//        order.setId(15);//设置oid，删除只能根据id删除

// 删除

//        session.delete(order);

//删除一方的数据

//        Customer customer = new Customer();

//        customer.setId(7);

//当删除的时候，hibernate会先解除关系(将cid置空)，然后在进行一方的删除操作

//        session.delete(customer);

/**

* 在进行级联删除的时候，如果删除的对象还是脱管态对象，级联删除失效，

* 默认处理方式：先解除关系，再一方删除数据(多方数据还存在，并没有达到级联删除的效果)

*

* 级联删除：一方对象必须是持久态，这样子，才能实现级联删除的效果

*/

//持久态

Customer customer = (Customer)session.get(Customer.class, 6);

//由于customer对象是持久态，所以会级联删除order订单

session.delete(customer);

session.getTransaction().commit();

session.close();

}

结论：删除操作中，删除托管对象没有级联效果，删除持久对象可以进行级联删除

1. 级联属性配置-cascade

Hibernate级联开发配置， cascade常用的取值：

• save-update：对关联瞬时对象执行save操作，对关联托管对象执行update
• delete：对关联对象进行删除

在实际开发中，一对多模型中，一方一般是主动的一方（多方要依赖一方），如果配置级联，通常在一方进行配置！！！

因为多方需要引用一方的主键作为外键使用

级联删除的情况：删除客户，订单也已经没有存在的意义了

删除订单，没有必要删除客户，没有必要再多方配删除级联

实际项目开发中，一般级联主要是用来进行级联删除操作，很少用来进行级联保存。一般都是先有一方的数据，再有多方的数据，即先有客户，再有订单。所以，保存多方不配置级联（不在多方配置级联）。

总结：

一般在业务开发中，不要两端都配置级联，（多方尽量不要配置级联,尽量在一方配置级联）

配置了级联之后，必须操作持久态对象，否则不会级联删除。

1. 外键的维护问题-inverse

问题:多余sql的问题

示例：

将没有关系的一个客户和一个订单建立关系。(双方)

@Test

public
void testInverse(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

//        获取5号客户

Customer customer = (Customer)session.get(Customer.class, 5);

//        获取订单

Order order = (Order)session.get(Order.class, 11);

//添加双向关联关系

customer.getOrders().add(order);

order.setCustomer(customer);

//此时当commit的时候，会隐式的flush

session.getTransaction().commit();

session.close();

}

产生的sql:多余sql

分析图：

解决方法：

采用inverse属性来配置。

简单的说这个属性谁是true，就放弃了主键维护权。

inverse默认值是false，即双方都有外键维护权。

inverse只对集合起作用，也就是只对one-to-many或many-to-many有效.

在业务开发中，一般是在一方放弃。（从业务场景上来分析，一般先存1 方，再存多方，那么就存多方的时候建立关系就比较合理。）

再次运行，发现就一条语句了：

一般，我们都让1方放弃外键维护权！

1. 多对多关联映射

学习点：掌握多对多配置方式。

案例：学生和课程，学生选课

1. 映射配置方式

   1. 多对多关系分析（student\course）

学生和课程 是经典 多对多关系，学生选课是关系表数据

在多对多中，一般情况 没必要使用 cascade 级联的！！！

1. 映射配置

【第一步】：实体类编写,创建cn.itcast.c_manytomany包，然后操作如下：

【第二步】：hbm映射文件编写

student.hbm.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>

<class
name="cn.itcast.c_manytomany.Student"
table="t_student">

<id
name="id">

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

</id>

<property
name="name"></property>

<!-- 配置集合

name:类中的属性

table:关系表名

-->

<set
name="courses"
table="t_s_c">

<!-- 当前Student对象在关系表中的外键名字 -->

<key
column="sid"></key>

<!-- 配置关系

class:当前的Course对应的完整的包路径

当前集合中装入的对象对应的完整的包路径

column:当前的Course对象在关系表中的外键

-->

<many-to-many
class="cn.itcast.c_manytomany.Course"
column="cid"></many-to-many>

</set>

</class>

</hibernate-mapping>

Course.hbm.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>

<class
name="cn.itcast.c_manytomany.Course"
table="t_course">

<id
name="id">

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

</id>

<property
name="name"></property>

<!-- 配置集合

table：配置多对多关系的时候，两边的table要一致

-->

<set
name="stus"
table="t_s_c">

<key
column="cid"></key>

<many-to-many
class="cn.itcast.c_manytomany.Student"
column="sid"></many-to-many>

</set>

</class>

</hibernate-mapping>

【第三步】：核心配置中添加映射

【第四步】：建表测试

建表完成之后，查看建表语句：

1. 映射图解

图解：

只要是多对一的标签，都配置自己在对方的外键属性。

1. 相关操作

   1. 保存操作save，同时建立关系

即保存学生和课程数据的同时，在中间选课表插入关联数据。

@Test

public
void testSave()

{

Session session = HibernateUtils.openSession();

session.beginTransaction();

//新建一个学生

Student stu = new Student();

stu.setName("rose");

//新建课程

Course course = new Course();

course.setName("hibernate");

//        /双向关联

stu.getCourses().add(course);

course.getStus().add(stu);

//发现抛出异常，如何解决

//1.外键维护权，一方放弃inverse="true"，并且不放弃维护权的一方，加入 cascade="save-update"

//2.建立关系是，只需要建立一方的关系即可，并且建立关系的一方，加入 cascade="save-update"

//双向保存

session.save(course);

session.save(stu);

session.getTransaction().commit();

session.close();

}

错误：

可以采用两种方案解决问题：

第一种方案.外键维护权，一方放弃inverse="true"，并且不放弃维护权的一方，加入 cascade="save-update"：推荐方案

第二种方案.建立关系时，只需要建立一方的关系即可，并且建立关系的一方，加入 cascade="save-update"

第一种方案：

执行的代码：

@Test

public
void testSave1(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

//创建学生

Student s1 = new Student();

s1.setName("rose");

///创建课程

Course c1 = new
Course();

c1.setName("hibernate");

//建立双向关联关系

s1.getCourses().add(c1);

c1.getStus().add(s1);

//保存

//        session.save(c1);

//        session.save(s1);

//第一种方案：一方放弃外键维护权，另一方加入级联保存，未来保存的时候，在另一方进行保存操作

session.save(s1);

session.getTransaction().commit();

session.close();

}

第二种方案：第二种方案xml文件的配置直接采用第一种方案的配置，不做任何修改，此时，我们知道Student.hbm.xml中配置了

Cascade="save-update"，所以接下来的测试代码如下：

实际业务中，一般不会去级联保存，因为学生和课程是各自产生存在的.

结论：多对多模型中，一次创建关系，对应中间表 一条insert语句 ！不需要双方发生关系。

在实际业务中，要么是在一方建立关系，要么是如果两方都建立关系，就配置inverse，让一方主动放弃维护权。

我们推荐一方放弃维护权

1. 解除关系

两个对象解除关系就是删除中间表的关系数据，即将两个对象解除关系。删除的时候，对象必须是持久态对象

@Test

public
void deleteRelation(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

Student student = (Student) session.get(Student.class, 3);

Course course = (Course) session.get(Course.class, 3);

//注意：由于course放弃了对集合的维护权，所以此时只能在Student这一方进行集合操作

student.getCourses().remove(course);

//不需要手动的删除，直接使用快照的更新功能，commit会隐式的flush

session.getTransaction().commit();

session.close();

}

语句问题：查看语句。

1. 改变关系：必须是持久态的对象

变更选课内容，原来选的语文，改为选数学

----- hibernate 无法生成update语句 （只能由我们自己先delete，后insert—先解除关系，再增加关系 ）

分析：假如能update，你要update中间表，但中间表无法通过实体操作。

插入测试数据，-

@Test

public
void
changeRelation(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

//让2号学生选修3号课程

Student student = (Student) session.get(Student.class, 2);

Course course = (Course) session.get(Course.class, 2);

//解除关系

student.getCourses().remove(course);

//查找3号课程

Course course2 = (Course) session.get(Course.class, 3);

//添加关系

student.getCourses().add(course2);

//flush

session.getTransaction().commit();

session.close();

}

1. 删除实体:持久态对象

多对多的删除！！！！！！！！！！

一定不能级联删除！！！！！！！

删除学生的时候，Hibernate会自动删除关系表(中间表)的数据（无需级联）

@Test

public
void
testDeleteEntity(){

Session session = HibernateUtils.openSession();

session.beginTransaction();

Student stu = (Student)session.get(Student.class, 2);

//删除

session.delete(stu);

//flush

session.getTransaction().commit();

session.close();

}

注意： 多对多不建议使用 级联 （delete 级联），造成数据丢失 ！！！！！！！(如果两边都配置级联,会两边删除,造成表被清空)

测试一下：（实际业务中是不存在的！！3个学生对应3个课程，创建9个关系，随便删除哪个对象，数据直接被置空）

在课程或者学生方配置级联

如果在学生方面配置了级联，那么当删除持久态的学生对象时，会将对应的课程也同时删除掉了！从而造成数据丢失！（删除脱管的不会，因为脱管态对级联不起作用）

（课后尝试多对多的级联删除）

1. 小结+重点

复习：

1 能够说出PO对象三状态

2 理解session一级缓存（能够存储数据）

3 理解快照（用来更新数据的）

4 get和load的区别

5 掌握一对多的配置

6 掌握一对多的CRUD操作

7 掌握多对多的配置

8 掌握对多对的CRUD操作

学会debug，多用debug

1. 作业

【作业一】

完成全天课程练习。

【作业二】

完成课前资料中的：《hibernate知识点作业练习》文档中的练习。