hibernate知识点讲述

ゞ浴缸里的玫瑰 2022-08-05 05:10 316阅读 0赞

Hibernate课程

# 1.   JDBC的优点和缺点 #

## JDBC的优点 ##

直接底层操作，提供了很简单、便捷的访问数据库的方法，跨平台性比较强。灵活性比较强，可以写很复杂的SQL语句。

## JDBC的缺点 ##

因为JAVA是面向对象的，JDBC没有做到使数据能够面向对象的编程，使程序员的思考仍停留在SQL语句上。

操作比较繁琐，很多代码需要重复写很多次。

如果遇到批量操作，频繁与数据库进行交互，容易造成效率的下降。

JDBC的程序操作可以封装一些什么内容？又不可以封装哪些内容？

# 2.   Hibernate #

## 为什么要用Hibernate ##

Hibernate实现了面向对象的数据库编程

Hibernate比起JDBC来，在代码的书写上比较简单化了。

Hibernate提出了缓存机制，这样可以使访问数据的效率提高很大。

## 第一个Hibernate程序 ##

例子包括的内容：

项目所需要的LIB包

配置文件hibernate.cfg.xml

持久化类      Customer.java

映射文件      Customer.hbm.xml

## 结论：通过这个例子可以看到利用面向对象的技术也可以操作数据库。Hibernate就是一个面向对象操作数据库的框架，是基于JDBC开发的。 ##

## 例子解析 ##

配置文件：

Hibernate.connection.url  表示要链接的数据库地址

Hibernate.connection.driver\_class    表示要链接的数据库的驱动类

Hibernate.connection.username     要连接的数据库的用户名

Hibernate.connection.password      要连接的数据库的密码

Hibernate.dialect   表示要使用的数据库的类型

org.hibernate.dialect.MySQL5Dialect      mysql数据库

org.hibernate.dialect.Oracle9Dialect        oracle数据库

org.hibernate.dialect.SQLServerDialect   SQLServer数据库

hibernate.hbm2ddl.auto

validate:加载hibernate时验证创建表结构

update:加载hibernate时自动更新数据库结构，如果表存在不用创建，如果不存在就创建。

create:每一次加载hibernate时都创建表结构

create-drop:加载hibernate时创建，退出时删除

持久化类：

映射文件：

客户端：

查询例子：

删除例子：

更新例子：

保存例子：

l  Cnfiguration 类负责管理 Hibernate 的配置信息。包括如下内容：

•    Hibernate运行的底层信息：数据库的URL、用户名、密码、JDBC驱动类，数据库Dialect,数据库连接池等（对应**hibernate.cfg.xml** 文件）。

•    持久化类与数据表的映射关系（\*.**hbm.xml** 文件）

l  创建 Configuration 的两种方式

•    属性文件（hibernate.**properties**）:

**Configurationcfg = new Configuration();**

•    Xml文件（hibernate.cfg.**xml**）

**Configurationcfg = new Configuration().configure();**

第二种创建方式较为常见。Hibernate.cfg.xml文件默认的目录为系统的根目录。

（展示源代码以得到证实）

也可以利用config.config方法来指定配置文件所在的目录。

l  Configuration对象根据当前的配置信息生成 SessionFactory 对象。SessionFactory 对象一旦构造完毕，即被赋予特定的配置信息(SessionFactory 对象中保存了当前的数据库配置信息和所有映射关系以及预定义的SQL语句。同时，SessionFactory还负责维护Hibernate的二级缓存)。

**Configurationcfg = new Configuration().configure();**

**  SessionFactory sf = cfg.buildSessionFactory();**

l  是线程安全的。

l  SessionFactory是生成Session的工厂：

**   Session session = sf.openSession();**

l  构造 SessionFactory 很消耗资源，一般情况下一个应用中只初始化一个 SessionFactory 对象。

l  在Hibernate中，Transaction tx = session.beginTransaction()相当于给数据库操作起事务。Session.commit()则为提交事务。

l  Hibernate的整个运行过程如下：

1、应用程序先调用Configuration类,该类读取Hibernate配置文件及映射文件中的信息，

2、并用这些信息生成一个SessionFactory对象，

3、然后从SessionFactory对象生成一个Session对象，

4、并用Session对象生成Transaction对象；

A、可通过Session对象的get(),load(),save(),update(),delete()和saveOrUpdate()等方法对PO进行加载、保存、更新、删除、等操作；

B、在查询的情况下，可通过Session对象生成一个Query对象，然后利用Query对象执行查询操作；如果没有异常，Transaction对象将提交这些操作到数据库中。

## ORM框架  ------hibernate ##

1.开源的持久层框架.

2.ORM(Object/Relational Mapping)映射工具，建立面向对象的域模型和关系数据模型之间的映射.

3.连接java应用和数据库的中间件.

4.对JDBC进行封装，负责java对象的持久化.

5.在分层结构中处于持久化层，封装对数据库的访问细节，

使业务逻辑层更专注于实现业务逻辑

Hibernate的优点：

1、Hibernate对JDBC访问数据库的代码做了封装，大大简化

了数据访问层繁琐的重复性代码。  
 2、Hibernate是一个基于jdbc的主流持久化框架，是一个优秀

的orm实现，它很大程度的简化了dao层编码工作。  
 3、Hibernate使用java的反射机制，而不是字节码增强程序类实现

透明性  
 4、Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵

活性很出色。它支持很多关系型数据库，从一对一到多对多的各

种复杂关系。

5、Hibernate使数据库的操作完全面向对象。而不是从前的面向关系进行操作。

## 建立ORM思想 ##

应用Hibernate意味着程序员将不直接操作SQL语句，也就是说以前对SQL的直接操作现在要用面向对象实现。实际上ORM到JDBC是紧密相连的。于此带来了一些问题：

### 主键是怎么样产生的 ###

### 一对多、多对一的关系在面向对象中是怎么样去实现的 ###

面向对象是怎么样由面向对象的操作映射到对SQL的操作

# 3.   主键生成机制 #

<table> 
 <tbody> 
 <tr> 
 <td> 表示符生成器 </td> 
 <td> 描述 </td> 
 </tr> 
 <tr> 
 <td> Increment </td> 
 <td> 由hibernate自动以递增的方式生成表识符，每次增量为1 </td> 
 </tr> 
 <tr> 
 <td> Identity </td> 
 <td> 由底层数据库生成表识符。条件是数据库支持自动增长数据类型。 </td> 
 </tr> 
 <tr> 
 <td> Sequence </td> 
 <td> Hibernate根据底层数据库序列生成标识符。条件是数据库支持序列。 </td> 
 </tr> 
 <tr> 
 <td> Native </td> 
 <td> 根据底层数据库对自动生成表示符的能力来选择identity、sequence、hilo </td> 
 </tr> 
 <tr> 
 <td> Uuid.hex </td> 
 <td> Hibernate采用128位的UUID算法来生成标识符。该算法 能够在网络环境中生成唯一的字符串标识符，这种策略并不流行，因为字符串类型的主键比整数类型的主键占用更多的数据库空间。 如果主键用字符类型，并且不代表任何含义。 </td> 
 </tr> 
 <tr> 
 <td> assigned </td> 
 <td> 适用于自然主键。由java程序负责生成标识符。不能把setID()方法声明为 Private的。尽量避免使用自然主键。 </td> 
 </tr> 
 </tbody> 
</table>

## increment 标识符生成器 ##

l  increment 标识符生成器**由 Hibernate** 以递增的方式为代理主键赋值

l  Hibernate 会先读取 NEWS 表中的主键的最大值, 而接下来向 NEWS 表中插入记录时, 就在 max(id) 的基础上递增, 增量为 1.(带走+1)

l  适用范围:

•    由于 increment 生存标识符机制不依赖于底层数据库系统, 因此它适合所有的数据库系统

•    适用于只有单个 Hibernate **应用进程**访问同一个数据库的场合

•    OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常

## identity 标识符生成器 ##

l  identity 标识符生成器由底层数据库来负责生成标识符, 它要求底层数据库把主键定义为自动增长字段类型（加1带走）

l  适用范围:

•    由于 identity 生成标识符的机制依赖于底层数据库系统, 因此, 要求底层数据库系统必须支持自动增长字段类型. 支持自动增长字段类型的数据库包括: DB2, Mysql, MSSQLServer,Sybase 等

•    OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常

## sequence 标识符生成器 ##

l  sequence  标识符生成器利用底层数据库提供的序列来生成标识符.

l  Hibernate 在持久化一个 News 对象时, 先从底层数据库的 news\_seq 序列中获得一个唯一的标识号, 再把它作为主键值

l  适用范围:

•    由于 sequence 生成标识符的机制依赖于底层数据库系统的序列, 因此, 要求底层数据库系统必须支持序列. 支持序列的数据库包括: DB2 Oracle 等

•    OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常

## native 标识符生成器 ##

l  native 标识符生成器依据底层数据库对自动生成标识符的支持能力, 来选择使用 identity,sequence 或 hilo 标识符生成器.

l  适用范围:

•    由于 native 能根据底层数据库系统的类型, 自动选择合适的标识符生成器, 因此很适合于跨数据库平台开发

•    OID 必须为 long, int 或 short 类型, 如果把 OID 定义为 byte 类型, 在运行时会抛出异常

## assigned 标识符生成器 ##

l  hibernate和底层数据库都不帮助你生成主键，也就是说得自己在程序中手动的设置主键的值。

l  适用范围：

主键有一定的含义，需要根据业务产生的情况。

## Uuid标识符生成器 ##

l  Hibernate采用128位的UUID算法来生成标识符。该算法能够在网络环境中生成唯一的字符串标识符，这种策略并不流行，因为字符串类型的主键比整数类型的主键占用更多的数据库空间

l  使用范围：

主键是字符串，而且必须是唯一

# 4.   Myeclipse开发hibernate #

## 开发步骤 ##

1、    新建一个JavaProject工程  myeclipsehibernate

2、    添加Hibernate到myeclipsehibernate.

3、    生成以后的结构如图所示：

4、    利用hibernate自带的工具自动生成持久化类和映射文件。

具体方法在课堂上进行演示。

5、    建立客户端进行编辑

## HibernateSessionFactory类 ##

利用ThreadLocal类保证了Session的线程安全。具体内容看代码是怎么样形成的。

# 5.   持久化对象的状态 #

持久化对象有3种状态：

持久化状态

临时状态

游离状态

Session 的特定方法能使对象从一个状态转换到另一个状态

## 临时对象(transient) ##

•    在使用代理主键的情况下, OID 通常为 null

•    不处于 Session 的缓存中

•    在数据库中没有对应的记录

## 持久化对象(也叫”托管”)（Persist） ##

•    OID 不为 null

•    位于 Session 缓存中

•    持久化对象和数据库中的相关记录对应

•    Session 在清理缓存时, 会根据持久化对象的属性变化, 来同步更新数据库

•    在同一个 Session 实例的缓存中, 数据库表中的每条记录只对应唯一的持久化对象

## 游离对象(也叫”脱管”)(Detached) ##

•    OID 不为 null

•    不再处于 Session 的缓存中

•    一般情况需下, 游离对象是由持久化对象转变过来的, 因此在数据库中可能还存在与它对应的记录

Session使用以下方法可以使持久化对象转变成游离对象：

## 测试hibernate中对象变化的状态： ##

<table> 
 <tbody> 
 <tr> 
 <td> 程序代码 </td> 
 <td> 生命周期 </td> 
 <td> 状态 </td> 
 </tr> 
 <tr> 
 <td> tx = session.beginTransaction(); Customer c = new Customer); </td> 
 <td> 开始生命周期 </td> 
 <td> 临时状态 </td> 
 </tr> 
 <tr> 
 <td> Session.save(c) </td> 
 <td> 处于生命周期中 </td> 
 <td> 转变为持久化状态 </td> 
 </tr> 
 <tr> 
 <td> Long id=c.getId(); c = null; Customer c2 = (Customer)session.load(Customer.class,id); tx.commit(); </td> 
 <td> 处于生命周期中 </td> 
 <td> 处于持久化状态 </td> 
 </tr> 
 <tr> 
 <td> session.close(); </td> 
 <td> 处于生命周期中 </td> 
 <td> 转变为游离态 </td> 
 </tr> 
 <tr> 
 <td> c2.getName(); </td> 
 <td> 处于生命周期中 </td> 
 <td> 处于游离态 </td> 
 </tr> 
 <tr> 
 <td> c2 = null; </td> 
 <td> 结束生命周期 </td> 
 <td> 结束生命周期 </td> 
 </tr> 
 </tbody> 
</table>

## 对象状态转化图 ##

## 对象状态的总结 ##

## 操纵持久化对象-save() ##

l  Session 的 save() 方法使一个临时对象转变为持久化对象

l  Session 的 save() 方法完成以下操作:

l 把 News 对象加入到 Session 缓存中, 使它进入持久化状态

l 选用映射文件指定的标识符生成器, 为持久化对象分配唯一的 OID. 在使用代理主键的情况下, setId() 方法为 News 对象设置 OID 使无效的.

l 计划执行一条 insert 语句,把Customer对象当前的属性值组装到insert语句中

l  Hibernate 通过持久化对象的 OID 来维持它和数据库相关记录的对应关系.当 News 对象处于持久化状态时, 不允许程序随意修改它的ID

## 操纵持久化对象-update() ##

l  Session 的 update() 方法使一个游离对象转变为持久化对象, 并且计划执行一条 update 语句.

## 操纵持久化对象-saveOrupdate() ##

saveOrUpdate:

该方法同时包含save和update方法，如果参数是临时对象就用save方

法，如果是游离对象就用update方法，如果是持久化对象就直接返回。

如果参数是临时对象就用save方法

如果是游离对象就用update方法

如果是持久化对象就直接返回,不执行操作

# 6.   映射一对多关联关系 #

## 6.1单向关联 ##

仅仅建立从Order到Customer的多对一关联，即仅仅在Order类中定义customer属性。或者仅仅建立从Customer到Order的一对多关联，即仅仅Customer类中定义orders集合。

单向 n-1 关联只需从 n 的一端可以访问 1 的一端

域模型: 从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Customer 属性, 而在 Customer 类中无需定义存放 Order 对象的集合属性

关系数据模型:ORDERS 表中的 CUSTOMER\_ID 参照 CUSTOMER 表的主键

Hibernate 使用<many-to-one> 元素来映射多对一关联关系

### 6.1.1保存操作 ###

实验1、

先保存订单，再保存客户

从这里可以看出执行了两条insert语句，一条update语句

先保存客户，再保存订单

可以看出这种情况程序是执行了两条insert语句，而没有执行update语句。

查询订单

先保存客户，再保存订单，在下面的代码中注释掉session.save(c),会有什么后果

级联保存和更新

当hibernate持久化一个临时对象时，在默认情况下，他不会自动持久化所关联的其他临时对象，会抛出TransientObjectException.如果设定many-to-one元素的cascade属性为save-update的话，可实现自动持久化所关联的对象。

## 6.2双向关联 ##

双向 1-n 与 双向 n-1 是完全相同的两种情形

双向 1-n 需要在 1 的一端可以访问 n 的一端, 反之依然.

### 域模型: ###

从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Customer 属性, 而在 Customer 类中需定义存放 Order 对象的集合属性

### 关系数据模型: ###

ORDERS 表中的 CUSTOMER\_ID 参照 CUSTOMER 表的主键

### 建立一对多的双向关联关系 ###

### Hibernate使用set元素来映射一对多关联关系 ###

### 保存客户和订单(客户和订单建立双向关联) ###

### 保存客户和不保存订单 ###

在下面的代码中注释掉session.save(order1),会有什么后果

### 级联保存和更新 ###

当hibernate持久化一个临时对象时，在默认情况下，他不会自动持久化所关联的其他临时对象，会抛出TransientObjectException.如果设定set元素的cascade属性为save-update的话，可实现自动持久化所关联的对象。

### 查询客户和订单 ###

### 查询客户和订单(图) ###

### 保存客户或订单的区别 ###

保存订单时会发出两条insert语句。

Hibernate:select max(id) from customers

Hibernate:insert into customers (name, id) values (?, ?)

Hibernate: insert into orders (order\_number, price, customer\_id)values (?, ?, ?)

而保存客户时会发出两条insert语句和一条update语句

Hibernate:select max(id) from customers

Hibernate:insert into customers (name, id) values (?, ?)

Hibernate:insert into orders (order\_number, price, customer\_id) values (?, ?, ?)

Hibernate: update orders set customer\_id=? where id=?

因为订单是多的一方，而客户是一的一方，所以在多对一的关系中，应该使用一的一方进行操作，这样效率更高。

### 订单变更客户 ###

上述例子产生了两条update语句：

Hibernate:update orders set order\_number=?, price=?, customer\_id=? where id=?

Hibernate: update orders set customer\_id=? where id=?

原因为：

Hibernate会自动清理缓存中的所有持久化对象，按照持久化对象的改变来同步更新数据库，因此执行了上述的两条更新语句所以会产生两条update语句

c4.getOrders().add(o6)执行了一条update语句

o6.setCustomer(c4)执行了一条update语句

### 级联删除 ###

### inverse属性 ###

#### Inverse来源 ####

在hibernate中通过对 inverse 属性的值决定是由双向关联的哪一方来维护表和表之间的关系. inverse=false 的为主动方，inverse=true 的为被动方, 由主动方负责维护关联关系

#### Inverse设值 ####

在没有设置 inverse=true 的情况下，父子两边都维护父子关系

#### Inverse设值原则 ####

在 1-n 关系中，将 n 方设为主控方将有助于性能改善(如果要国家元首记住全国人民的名字，不是太可能，但要让全国人民知道国家元首，就容易的多)

在 1-N 关系中，若将 1 方设为主控方 会额外多出 update 语句

在一的一方设值inverse为TRUE表明一的一方不维护其关系，这样就会发出一条update语句，这样效率也就提高了。

#### Inverse结论 ####

1.在映射一对多的双向关联关系时，应该在one方把inverse属性设为true，

这可以提高性能。

2.在建立两个对象的关联时，应该同时修改关联两端的相应属性：

customer.getOrders().add(order);

order.setCustomer(customer);

这样才会使程序更加健壮，提高业务逻辑层的独立性，使业务逻辑层的程序代码

不受Hibernate实现类的影响。同理，当删除双向关联的关系时，也应该修改

关联两端的对象的相应属性：

Customer.getOrders().remove(order);

Order.setCustomer(null);

### 解除关联关系 ###

#### 解除某个订单与某个客户的关系 ####

这样在order表中，ID为6的相应的外键为3的那行的外键会置为null;

### 级联删除 ###

### cascade属性 ###

### 在数据库中对集合进行排序 ###

<set> 元素有一个 order-by 属性, 如果设置了该属性, 当 Hibernate 通过select 语句到数据库中检索集合对象时, 利用 order by 子句进行排序

# 7.   映射多对多关联关系 #

# 8.   深入Session #

## session概述 ##

Session 接口是 Hibernate 向应用程序提供的操纵对数据库的最主要的接口, 它提供了基本的保存, 更新, 删除和加载Java 对象的方法.

## 理解session的缓存 ##

l  在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java 集合构成了 Session 缓存. 只要 Session 实例没有结束生命周期, 存放在它缓存中的对象也不会结束生命周期

l      当session的save()方法持久化一个对象时，该对象被载入缓存，以后即使程序中不再引用该对象，只要缓存不清空，该对象仍然处于生命周期中。当试图load()对象时，会判断缓存中是否存在该对象，有则返回。没有在查询数据库

## 清理session的缓存 ##

l  Session 具有一个缓存, **位于缓存中的对象称为持久化对象**, 它和数据库中的相关记录对应.Session 能够在某些时间点, 按照缓存中对象的变化来执行相关的 SQL 语句, 来同步更新数据库, 这一过程被称为清理缓存(flush)

l  默认情况下 Session 在以下时间点清理缓存：

•    当应用程序调用 **Transaction 的 commit（）**方法的时, 该方法先清理缓存(session.flush())，然后在向数据库提交事务(tx.commit())

•    当应用程序执行一些查询操作时，如果缓存中持久化对象的属性已经发生了变化，会先清理缓存，以保证查询结果能够反映持久化对象的最新状态

•    显式调用 **Session 的 flush()** 方法.

l  **区别：**

**flush:**进行清理缓存(此时缓存中的数据并不丢失)的操作,让缓存和数据库同步 执行一些列sql语句，但不提交事务,；

**commit:**先调用flush() 方法，然后提交事务. 则意味着提交事务意味着对数据库操作永久保存下来。

**reresh**:刷新,让session和数据库同步,执行查询,把数据库的最新信息显示出来,更新本地缓存的对象状态.

**clear**:清空缓存,等价于list.removeAll();

## 利用Session缓存读取持久化对象的数据 ##

1  Customer c = new Customer(“TOM”,new HashSet());

2  session.save(c); //customer对象被持久化，并且加入到session的缓存中

3  Long id = c.getId();

4   c= null; //c变量不再引用customer对象

5  //从session缓存中读取customer对象,使c2变量引用customer对象

6  Customer c2 = (Customer)session.load(Customer.class,id);

7  tx.commit();  //缓存中的对象和数据库同步

8  session.close(); //关闭session 清空缓存

9  System.out.println(c2.getName()); //访问customer对象

10 C2 = null; //C2对象不再引用customer对象,customer对象结束生命周期

\---------------------------------------------------------------------------------------------

缓存的作用：

1。减少访问数据库的频率。

2。保证缓存中的对象与数据库中的相关记录保持同步。

## Session执行批量操作 ##

可以写一个for循环，Session可以批量插入上万条数据。如下面的代码：

For(int i=0;i<10000;i++)\{

Session.save(object);

这样写的代码会产生一个什么问题？会使一万个对象的缓存全部存在于内存中，这样做加大了内存的压力。所以应该定期清理session的缓存，也就是flush一下，这样内存才能保证足够的空间。

# 9.   Session.load与session.get方法 #

## 不同场合的不同解决方案 ##

场合一：当用户要取数据库的一张表的一个字段，这个字段很可能就是一个字符，总而言之长度是比较短的。

场合二：当用户要取数据库的一张表的一个字段的值，而这个值很可能是blob类型，也许存取的是一个很大的视频文件。

两种场合的取数据的方法一样吗？是用load还是用get方法？

## 延迟加载 ##

### 类的延迟加载 ###

lazy 为true或者为false

### 集合的延迟加载 ###

True   false   extra

extra为更进一步的延迟加载策略。

当调用getStudents()时不会加载hql语句，当加载student的属性的时候才会发出SQL语句

调用getStudents().size()方法的时候，会触发类似于：Hibernate: select count(id) fromT\_Student where classid =? 这样的SQL查询语句（这是一种很聪明的做法，如果lazy=”true”，getStudents().size()将会使得hibernate加载所有集合的数据到内存中）。

调用getStudents().contains()方法的时候（即判断是否包含某个对象），会触发类似于：select 1 fromT\_Student where classid =? and id =? 这样的SQL查询语句。

### 单端关联 ###

False   proxy   no-proxy

proxy:当前对象的単值相关对象只有在调用它的主键外的其他属性的get方法时才加载它。

no-proxy:当前对象的単值相关对象只有在调用它的属性时才加载，需要字节码增强。

# 10.        Hibernate检索策略 #

## 初始化数据 ##

## 类级别检索策略 ##

### 立即检索 ###

### 延迟检索 ###

默认的检索策略是立即检索。在Hibernate映射文件中，通过在<class>上配置 lazy属性来确定检索策略。对于Session的检索方式，类级别检索策略仅适用于load方法；也就说，对于get、qurey检索，持久化对象都会被立即加载而不管lazy是false还是true.一般来说，我们检索对象就是要访问它，因此立即检索是通常的选择。由于load方法在检索不到对象时会抛出异常（立即检索的情况下），因此我个人并不建议使用load检索；而由于<class>中的lazy属性还影响到多对一及一对一的检索策略，因此使用load方法就更没必要了。

## 关联级别检索策略 ##

<table> 
 <tbody> 
 <tr> 
 <td> fetch (默认值select) </td> 
 <td> Lazy (默认值是true) </td> 
 <td> 策略 </td> 
 </tr> 
 <tr> 
 <td> Join </td> 
 <td> False </td> 
 <td> 采用迫切左外联接检索。 </td> 
 </tr> 
 <tr> 
 <td> Join </td> 
 <td> True </td> 
 <td> 采用迫切左外联接检索。 </td> 
 </tr> 
 <tr> 
 <td> join </td> 
 <td> Extra </td> 
 <td> 采用迫切左外联接检索。 </td> 
 </tr> 
 <tr> 
 <td> select </td> 
 <td> False </td> 
 <td> 采用立即检索 </td> 
 </tr> 
 <tr> 
 <td> select </td> 
 <td> True </td> 
 <td> 采用延迟检索 </td> 
 </tr> 
 <tr> 
 <td> select </td> 
 <td> Extra </td> 
 <td> 采用延迟检索 c.getOrders().size()&nbsp; 执行 select count(id) from orders where customer_id =? for(Order o:set){ o.getOrderNumber();} 将执行: select customer_id , id,order_number ,price from orders&nbsp; where customer_id=? </td> 
 </tr> 
 <tr> 
 <td> subselect </td> 
 <td> false/true/extra 也分为3中情况 </td> 
 <td> 嵌套子查询(检索多个customer对象时) Lazy属性决定检索策略) select customer_id,order_number,price from orders&nbsp; where customer_id &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; in (select id from customers) </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td> 检索策略 </td> 
 <td> 优点 </td> 
 <td> 缺点 </td> 
 <td> 优先考虑使用的场合 </td> 
 </tr> 
 <tr> 
 <td> 立即检索 </td> 
 <td> 对应用程序完全透明，不管对象处于持久化状态还是游离状态，应用程序都可以从一个对象导航到关联的对象 </td> 
 <td> (1)select语句多 (2)可能会加载应用程序不需要访问的对象，浪费许多内存空间。 </td> 
 <td> (1)类级别 (2)应用程序需要立即访问的对象 (3)使用了二级缓存 </td> 
 </tr> 
 <tr> 
 <td> 延迟检索 </td> 
 <td> 由应用程序决定需要加载哪些对象，可以避免执行多余的select语句，以及避免加载应用程序不需要访问的对象。因此能提高检索性能，并节省内存空间。 </td> 
 <td> 应用程序如果希望访问游离状态的代理类实例，必须保证她在持久化状态时已经被初始化。 </td> 
 <td> (1)一对多或者多对多关联 (2)应用程序不需要立即访问或者根本不会访问的对象 </td> 
 </tr> 
 <tr> 
 <td> 迫切左外连接检索 </td> 
 <td> (1)对应用程序完全透明，不管对象处于持久化状态还是游离状态，都可从一个对象导航到另一个对象。 (2)使用了外连接，select语句少 </td> 
 <td> (1)可能会加载应用程序不需要访问的对象，浪费内存。 (2)复杂的数据库表连接也会影响检索性能。 </td> 
 <td> (1)多对一 (2)需要立即访问的对象 (3)数据库有良好的表连接性能。 </td> 
 </tr> 
 </tbody> 
</table>

# 11.        Hibernate的检索方式 #

## HQL(Hibernate Query Language) ##

l  HQL(Hibernate Query Language) 是面向对象的查询语言, 它和 SQL 查询语言有些相似. 在 Hibernate 提供的各种检索方式中, HQL 是使用最广的一种检索方式. 它有如下功能:

l  在查询语句中设定各种查询条件

l  支持投影查询, 即仅检索出对象的部分属性

l  支持分页查询

l  支持连接查询

l  支持分组查询, 允许使用 HAVING 和 GROUP BY 关键字

l  提供内置聚集函数, 如 sum(), min() 和 max()

l  能够调用 用户定义的 SQL 函数或标准的 SQL 函数

l  支持子查询

l  支持动态绑定参数

## OID 检索方式 ##

按照对象的 OID 来检索对象

## QBC 检索方式 ##

使用 QBC(Query ByCriteria) API 来检索对象. 这种 API 封装了基于字符串形式的查询语句, 提供了更加面向对象的查询接口.

## 简单的查询 ##

## 使用别名 ##

## 对查询结果排序 ##

## 分页查询 ##

l  分页查询:

l setFirstResult(intfirstResult): 设定从哪一个对象开始检索, 参数 firstResult 表示这个对象在查询结果中的索引位置, 索引位置的起始值为 0. 默认情况下, Query 从查询结果中的第一个对象开始检索

l setMaxResult(int maxResults): 设定一次最多检索出的对象的数目. 在默认情况下, Query 和 Criteria 接口检索出查询结果中所有的对象

## 检索单个对象 ##

## 绑定参数的形式,按参数名称绑定 ##

## 绑定参数的形式,按参数位置绑定 ##

## 在映射文件中定义命名查询语句 ##

## hibernate检索方式 ##

<table> 
 <tbody> 
 <tr> 
 <td> 短语 </td> 
 <td> 含义 </td> 
 </tr> 
 <tr> 
 <td> Expression.eq </td> 
 <td> 等于= </td> 
 </tr> 
 <tr> 
 <td> Expression.allEq </td> 
 <td> 使用Map,使用key/value进行多个等于的判断 </td> 
 </tr> 
 <tr> 
 <td> Expression.gt </td> 
 <td> 大于&gt; </td> 
 </tr> 
 <tr> 
 <td> Expression.ge </td> 
 <td> 大于等于&gt;= </td> 
 </tr> 
 <tr> 
 <td> Expression.lt </td> 
 <td> 小于&lt; </td> 
 </tr> 
 <tr> 
 <td> Expression.le </td> 
 <td> 小于等于&lt;= </td> 
 </tr> 
 <tr> 
 <td> Expression.between </td> 
 <td> 对应sql的between子句 </td> 
 </tr> 
 <tr> 
 <td> Expression.like </td> 
 <td> 对应sql的like子句 </td> 
 </tr> 
 <tr> 
 <td> Expression.in </td> 
 <td> 对应sql的in子句 </td> 
 </tr> 
 <tr> 
 <td> Expression.and </td> 
 <td> and 关系 </td> 
 </tr> 
 <tr> 
 <td> Expression.or </td> 
 <td> or关系 </td> 
 </tr> 
 <tr> 
 <td> Expression.sqlRestriction </td> 
 <td> Sql限定查询 </td> 
 </tr> 
 <tr> 
 <td> Expression.asc() </td> 
 <td> 根据传入的字段进行升序排序 </td> 
 </tr> 
 <tr> 
 <td> Expression.desc() </td> 
 <td> 根据传入的字段进行降序排序 </td> 
 </tr> 
 </tbody> 
</table>

## HQL和QBC支持的各种运算 ##

<table> 
 <tbody> 
 <tr> 
 <td> 运算类型 </td> 
 <td> HQL运算符 </td> 
 <td> QBC运算方法 </td> 
 <td> 含义 </td> 
 </tr> 
 <tr> 
 <td> 比较运算 </td> 
 <td> = </td> 
 <td> Express.eq() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> &lt;&gt;&nbsp; </td> 
 <td> Express.not(Express.eq()) </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> &gt;= </td> 
 <td> Express.ge() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> &lt;&nbsp; </td> 
 <td> Express.lt() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> &lt;= </td> 
 <td> Express.le() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> is null </td> 
 <td> Express.isNull() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> is not null </td> 
 <td> Express.isNotNull() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> 范围运算符 </td> 
 <td> In </td> 
 <td> Express.in() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> not in </td> 
 <td> Express.not(Express.in()) </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> Between </td> 
 <td> Express.between() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> not between </td> 
 <td> Express.not(Express.between()) </td> 
 <td>&nbsp;</td> 
 </tr> 
 </tbody> 
</table>

HQL和QBC支持的各种运算

<table> 
 <tbody> 
 <tr> 
 <td> 运算类型 </td> 
 <td> HQL运算符 </td> 
 <td> QBC运算方法 </td> 
 <td> 含义 </td> 
 </tr> 
 <tr> 
 <td> 字符串模式匹配 </td> 
 <td> Like </td> 
 <td> Expression.like() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> 逻辑 </td> 
 <td> And </td> 
 <td> Expression.and()| Expression.conjunction() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> Or </td> 
 <td> Expression.or()| Expression.disjunction() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> Not </td> 
 <td> Expression.not() </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td>&nbsp;</td> 
 <td>&nbsp;</td> 
 <td>&nbsp;</td> 
 </tr> 
 </tbody> 
</table>

## 迫切左外连接 ##

# 12.        二级缓存 #

## 缓存的概念 ##

计算机领域非常通用的概念。它介于应用程序和永久性数据存储源(如硬盘上的文件或者数据库)之间，其作用是降低应用程序直接读写永久性数据存储源的频率，从而提高应用的运行性能。缓存中的数据是数据存储源中数据的拷贝。缓存的物理介质通常是内存

## Hibernate中提供了两个级别的缓存 ##

###  Session 级别的缓存 ###

它是属于事务范围的缓存。这一级别的缓存由 hibernate 管理的，一般情况下无需进行干预

### SessionFactory 级别的缓存 ###

它是属于进程范围的缓存

## 启用二级缓存的条件 ##

### 很少被修改 ###

### 很多系统模块都要用到 ###