Hibernate框架

web内容回顾：

javaee三层结构：

1.web层：Struts框架

2.service层：spring框架

3.dao层：hibernate框架

（1）对数据库进行crud操作

MVC思想：

1.m：模型

2.v：视图

3.c：控制器

Hibernate概述：

什么是框架

1.写程序，使用框架之后，帮我们实现一部分功能，使用框架好处，少写一部分代码实现功能

什么是hibernate框架（重点）

1.hibernate框架应用在javaee三层结构中的dao层

2.在dao层里面做对数据库crud操作，使用hibernate实现crud操作，hibernate底层代码就是jdbc，hibernate对jdbc进行封装，使用hibernate好处，不需要写复杂代码，不需要写sql语句实现

3.hibernate开源的轻量级的框架

4.hibernate版本

   hibernate3.x

   hibernate4.x

   hibernate5.x（学习）

什么是orm思想：

1.hibernate使用orm思想对数据库进行crud操作

2.在web阶段学习javabean，更正确的叫法实体类

3.orm：object  relational mapping ，对象关系映射

文字描述

（1）让实体类和数据库表进行一一对应关系

            让实体类首先和数据库表对应

            让实体类属性和表里面字段对应

（2）不需要直接操作数据库表，而操作表对应的实体类对象

                                                                                                                                                                                           

Hibernate入门：

搭建hibernate环境

第一步：导入hibernate的jar包

因为使用hibernate的时候，有日志信息输出，hibernate本身没有日志输出的jar包，导入其他日志的jar包

不要忘记还有MySQL驱动的jar包

第二步：创建实体类

（1）使用hibernate时候，不需要自己手动创建表，hibernate帮着把表创建

第三步：配置实体类和数据库一一对应关系（映射关系）

使用配置文件实现映射关系

（1）创建xml格式的配置文件

映射配置文件名称和位置没有固定要求

建议：在实体类所在包里面创建，实体类名称.hbm.xml

（2）配置文件是xml格式，在配置文件中首先引入xml约束

学过的约束：dtd、schema  

在hibernate里面引入的约束dtd约束

（3）配置映射关系

第四步  创建hibernate的核心配置文件

（1）核心配置文件格式xml，但是核心配置文件名称和位置是固定的

位置：必须src下面

名称：必须hibernate.cfg.xml

（2）引入dtd约束

（3）hibernate操作过程中，只会加载核心配置文件，其他配置文件不会加载

第一部分： 配置数据库信息必须的

第二部分： 配置hibernate信息 可选的

第三部分： 把映射文件放到核心配置文件中

实现添加操作

第一步 加载hibernate核心配置文件

 

第二步 创建SessionFactory对象

 

第三步 使用SessionFactory创建session对象

 

第四步 开启事务

 

第五步 写具体逻辑 crud操作

 

第六步 提交事务

 

第七步 关闭资源

 

@Test

public void testAdd() {

//第一步加载hibernate核心配置文件

// 到src下面找到名称是hibernate.cfg.xml

//在hibernate里面封装对象

Configuration cfg = new Configuration();

cfg.configure();

//第二步创建SessionFactory对象

//读取hibernate核心配置文件内容，创建sessionFactory

//在过程中，根据映射关系，在配置数据库里面把表创建

SessionFactory sessionFactory = cfg.buildSessionFactory();

//第三步使用SessionFactory创建session对象

// 类似于连接

Session session = sessionFactory.openSession();

//第四步开启事务

Transaction tx = session.beginTransaction();

 

//第五步写具体逻辑crud操作

//添加功能

User user = new User();

user.setUsername("小王");

user.setPassword("250");

user.setAddress("日本");

//调用session的方法实现添加

session.save(user);

//第六步提交事务

tx.commit();

 

//第七步关闭资源

session.close();

sessionFactory.close();

}

看到效果：

（1）是否生成表

（2）看表是否有记录

Hibernate配置文件详解

Hibernate映射配置文件（重点）

1 映射配置文件名称和位置没有固定要求

 

2 映射配置文件中，标签name属性值写实体类相关内容

（1）class标签name属性值实体类全路径

（2）id标签和property标签name属性值 实体类属性名称

 

3 id标签和property标签，column属性可以省略的

（1）不写值和name属性值一样的

 

4 property标签type属性，设置生成表字段的类型，自动对应类型

Hibernate核心配置文件

1 配置写位置要求

2 配置三部分要求

（1）数据库部分必须的

（2）hibernate部分可选的

（3）映射文件必须的

 

3 核心配置文件名称和位置固定的

（1）位置：src下面

（2）名称：hibernate.cfg.xml

Hibernate核心api

configuration

1.代码

（1）到src下面找到名称hibernate.cfg.xml配置文件，创建对象，把配置文件放到对象里面（加载核心配置文件）

SessionFactory（重点）

1 使用configuration对象创建sessionFactory对象

（1）创建sessionfactory过程中做事情：

- 根据核心配置文件中，有数据库配置，有映射文件部分，到数据库里面根据映射关系把表创建

2 创建sessionFactory过程中，这个过程特别耗资源的

（1）在hibernate操作中，建议一个项目一般创建一个sessionFactory对象

3 具体实现

（1）写工具类，写静态代码块实现

* 静态代码块在类加载时候执行，执行一次

Session（重点）

1 session类似于jdbc中connection

 

2 调用session里面不同的方法实现crud操作

（1）添加 save方法

（2）修改 update方法

（3）删除 delete方法

（4）根据id查询get方法

 

3 session对象单线程对象

（1）session对象不能共用，只能自己使用

Transaction

1 事务对象

2 事务提交和回滚方法

3 事务概念

（1）事务四个特性

原子性、一致性、隔离性、持久性

解决配置文件没有提示问题

1 可以上网

 

2 把约束文件引入到eclipse中

（1）在配置文件中复制一句话

重启eclipse开发工具

演示常见错误

1 在映射配置文件中，把name属性值写错了，和实体类属性名称不一样，出现异常

 

 

 

2 在核心配置文件中，没有引入映射配置文件

 

 

3 测试配置是否正确

（1）在工具类，写静态代码块，创建sessionFactory，过程中根据配置把表创建

（2）让工具类执行，在工具类写main方法可以了

 

（3）如果出现异常，弹出框

点击确定，在控制台有异常输出

4 配置文件里面属性值，双引号里面不能有空格

 

5 注意输入法全角问题

====================================================================================================================

1 实体类编写规则

 

2 hibernate主键生成策略

（1）native

（2）uuid

 

3 实体类操作

（1）crud操作

（2）实体类对象状态

 

4 hibernate的一级缓存

 

5 hibernate的事务操作

（1）事务代码规范写法

 

6 hibernate其他的api（查询）

（1）Query

（2）Criteria

（3）SQLQuery

============================================================

实体类编写规则

1 实体类里面属性私有的

 

2 私有属性使用公开的set和get方法操作

 

3 要求实体类有属性作为唯一值（一般使用id值）

 

4 实体类属性建议不使用基本数据类型，使用基本数据类型对应的包装类

（1）八个基本数据类型对应的包装类

- int – Integer

- char—Character、

- 其他的都是首字母大写 比如 double – Double

（2）比如 表示学生的分数，假如int score;

- 比如学生得了0分 ，int score = 0;

- 如果表示学生没有参加考试，int score = 0;不能准确表示学生是否参加考试

l 解决：使用包装类可以了， Integer score = 0，表示学生得了0分，

表示学生没有参加考试，Integer score = null;

Hibernate主键生成策略

1 hibernate要求实体类里面有一个属性作为唯一值，对应表主键，主键可以不同生成策略

 

2 hibernate主键生成策略有很多的值

 

 

3 在class属性里面有很多值

（1）native： 根据使用的数据库帮选择哪个值

 

（2）uuid：之前web阶段写代码生成uuid值，hibernate帮我们生成uuid值

4 演示生成策略值 uuid

（1）使用uuid生成策略，实体类id属性类型 必须 字符串类型

 private String uid;

（2）配置部分写出uuid值

实体类操作

对实体类crud操作

添加操作

1 调用session里面的save方法实现

根据id查询

修改操作

1 首先查询，修改值

（1）根据id查询，返回对象

删除操作

1 调用session里面delete方法实现

实体类对象状态（概念）

1 实体类状态有三种

（1）瞬时态：对象里面没有id值，对象与session没有关联

 

（2）持久态：对象里面有id值，对象与session关联

 

 

（3）托管态：对象有id值，对象与session没有关联

 

 

2 演示操作实体类对象的方法

（1）saveOrUpdate方法：实现添加、实现修改

Hibernate的一级缓存

什么是缓存

1 数据存到数据库里面，数据库本身是文件系统，使用流方式操作文件效率不是很高。

（1）把数据存到内存里面，不需要使用流方式，可以直接读取内存中数据

（2）把数据放到内存中，提供读取效率

Hibernate缓存

1 hibernate框架中提供很多优化方式，hibernate的缓存就是一个优化方式

 

2 hibernate缓存特点：

第一类 hibernate的一级缓存

（1）hibernate的一级缓存默认打开的

（2）hibernate的一级缓存使用范围，是session范围，从session创建到session关闭范围

（3）hibernate的一级缓存中，存储数据必须 持久态数据

 

第二类 hibernate的二级缓存

（1）目前已经不使用了，替代技术redis

（2）二级缓存默认不是打开的，需要配置

（3）二级缓存使用范围，是sessionFactory范围

验证一级缓存存在

1 验证方式

（1）首先根据uid=1查询，返回对象

（2）其次再根据uid=1查询，返回对象

 

第一步执行get方法之后，发送sql语句查询数据库

第二个执行get方法之后，没有发送sql语句，查询一级缓存内容

Hibernate一级缓存执行过程

Hibernate一级缓存特性

1 持久态自动更新数据库

2 执行过程（了解）

Hibernate事务操作

事务相关概念

1 什么是事务

 

2 事务特性

 

3 不考虑隔离性产生问题

（1）脏读

（2）不可重复读

（3）虚读

 

4 设置事务隔离级别

（1）mysql默认隔离级别repeatable read

Hibernate事务代码规范写法

1 代码结构

try {

  开启事务

  提交事务

}catch() {

  回滚事务

}finally {

  关闭

}

@Test

public void testTx() {

SessionFactory sessionFactory = null;

Session session = null;

Transaction tx = null;

try {

sessionFactory = HibernateUtils.getSessionFactory();

session = sessionFactory.openSession();

//开启事务

tx = session.beginTransaction();

//添加

User user = new User();

user.setUsername("小马");

user.setPassword("250");

user.setAddress("美国");

session.save(user);

int i = 10/0;

//提交事务

tx.commit();

}catch(Exception e) {

e.printStackTrace();

//回滚事务

tx.rollback();

}finally {

//关闭操作

session.close();

sessionFactory.close();

}

}

Hibernate绑定session

1 session类似于jdbc的connection，之前web阶段学过ThreadLocal

 

2 帮实现与本地线程绑定session

 

3 获取与本地线程session

（1）在hibernate核心配置文件中配置

（2）调用sessionFactory里面的方法得到

 

 

4 获取与本地线程绑定session时候，关闭session报错，不需要手动关闭了

Hibernate的api使用

Query对象

1 使用query对象，不需要写sql语句，但是写hql语句

（1）hql：hibernate query language，hibernate提供查询语言，这个hql语句和普通sql语句很相似

（2）hql和sql语句区别：

- 使用sql操作表和表字段

- 使用hql操作实体类和属性

 

2 查询所有hql语句：

（1）from实体类名称

 

3 Query对象使用

（1）创建Query对象

（2）调用query对象里面的方法得到结果

Criteria对象

1 使用这个对象查询操作，但是使用这个对象时候，不需要写语句，直接调用方法实现

 

2 实现过程

（1）创建criteria对象

（2）调用对象里面的方法得到结果

SQLQuery对象

1 使用hibernate时候，调用底层sql实现

 

2 实现过程

（1）创建对象

（2）调用对象的方法得到结果

返回list集合每部分是数组

返回list中每部分是对象形式

===============================================================================================================

列表功能实现

 

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）在客户实体类里面表示多个联系人

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

 

 

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

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

 

 

第三步 配置映射关系

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

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

 

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

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

 

 

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

 

 

第四步 创建核心配置文件，把映射文件引入到核心配置文件中

 

 

测试：

一对多级联操作

级联操作

1 级联保存

（1）添加一个客户，为这个客户添加多个联系人

 

2 级联删除

（1）删除某一个客户，这个客户里面的所有的联系人也删除

一对多级联保存

1 添加客户，为这个客户添加一个联系人

（1）复杂写法：

//演示一对多级联保存

@Test

public void testAddDemo1() {

SessionFactory sessionFactory =null;

Session session = null;

Transaction tx = null;

try {

//得到sessionFactory

sessionFactory = HibernateUtils.getSessionFactory();

//得到session

session = sessionFactory.openSession();

//开启事务

tx = session.beginTransaction();

// 添加一个客户，为这个客户添加一个联系人

//1 创建客户和联系人对象

Customer customer = new Customer();

customer.setCustName("传智播客");

customer.setCustLevel("vip");

customer.setCustSource("网络");

customer.setCustPhone("110");

customer.setCustMobile("999");

LinkMan linkman = new LinkMan();

linkman.setLkm_name("lucy");

linkman.setLkm_gender("男");

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) {

tx.rollback();

}finally {

session.close();

//sessionFactory不需要关闭

sessionFactory.close();

}

}

 

 

 

（2）简化写法

- 一般根据客户添加联系人

第一步 在客户映射文件中进行配置

- 在客户映射文件里面set标签进行配置

 

 

第二步 创建客户和联系人对象，只需要把联系人放到客户里面就可以了，最终只需要保存客户就可以了

//演示一对多级联保存

@Test

public void testAddDemo2() {

SessionFactory sessionFactory =null;

Session session = null;

Transaction tx = null;

try {

//得到sessionFactory

sessionFactory = HibernateUtils.getSessionFactory();

//得到session

session = sessionFactory.openSession();

//开启事务

tx = session.beginTransaction();

// 添加一个客户，为这个客户添加一个联系人

//1 创建客户和联系人对象

Customer customer = new Customer();

customer.setCustName("百度");

customer.setCustLevel("普通客户");

customer.setCustSource("网络");

customer.setCustPhone("110");

customer.setCustMobile("999");

LinkMan linkman = new LinkMan();

linkman.setLkm_name("小宏");

linkman.setLkm_gender("男");

linkman.setLkm_phone("911");

//2 把联系人放到客户里面

customer.getSetLinkMan().add(linkman);

//3 保存客户

session.save(customer);

//提交事务

tx.commit();

}catch(Exception e) {

tx.rollback();

}finally {

session.close();

//sessionFactory不需要关闭

sessionFactory.close();

}

}

一对多级联删除

1 删除某个客户，把客户里面所有的联系人删除

 

2 具体实现

第一步 在客户映射文件set标签，进行配置

（1）使用属性cascade属性值delete

 

第二步 在代码中直接删除客户

（1）根据id查询对象，调用session里面delete方法删除

 

 

3 执行过程：

（1）根据id查询客户

 

（2）根据外键id值查询联系人

 

（3）把联系人外键设置为null

 

（4）删除联系人和客户

一对多修改操作（inverse属性）

1 让lucy联系人所属客户不是传智播客，而是百度

 

 

 

2 inverse属性

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

 

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

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

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

 

（3）具体实现：

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

Hibernate多对多操作

多对多映射配置

以用户和角色为例演示

 

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

 

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

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

 

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

 

 

第三步 配置映射关系

（1）基本配置

（2）配置多对多关系

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

 

 

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

 

 

 

第四步 在核心配置文件中引入映射文件

 

 

测试：

多对多级联保存

根据用户保存角色

 

第一步 在用户配置文件中set标签进行配置，cascade值save-update

 

 

第二步 写代码实现

（1）创建用户和角色对象，把角色放到用户里面，最终保存用户就可以了

//演示多对多修级联保存

@Test

public void testSave() {

SessionFactory sessionFactory = null;

Session session = null;

Transaction tx = null;

try {

//得到sessionFactory

sessionFactory = HibernateUtils.getSessionFactory();

//得到session

session = sessionFactory.openSession();

//开启事务

tx = session.beginTransaction();

//添加两个用户，为每个用户添加两个角色

//1 创建对象

User user1 = new User();

user1.setUser_name("lucy");

user1.setUser_password("123");

User user2 = new User();

user2.setUser_name("mary");

user2.setUser_password("456");

Role r1 = new Role();

r1.setRole_name("总经理");

r1.setRole_memo("总经理");

Role r2 = new Role();

r2.setRole_name("秘书");

r2.setRole_memo("秘书");

Role r3 = new Role();

r3.setRole_name("保安");

r3.setRole_memo("保安");

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

//提交事务

tx.commit();

 

}catch(Exception e) {

tx.rollback();

}finally {

session.close();

//sessionFactory不需要关闭

sessionFactory.close();

}

}

多对多级联删除（了解）

第一步 在set标签进行配置，cascade值delete

第二步 删除用户

 

维护第三张表关系

1 用户和角色多对多关系，维护关系通过第三张表维护

 

2 让某个用户有某个角色

第一步 根据id查询用户和角色

 

第二步 把角色放到用户里面

（1）把角色对象放到用户set集合

 

 

3 让某个用户没有某个角色

第一步 根据id查询用户和角色

 

 

第二步 从用户里面把角色去掉

（1）从set集合里面把角色移除

===============================================================================================================

1 hibernate的查询方式

 

2 对象导航查询

 

3 hql查询

（1）查询所有

（2）条件查询

（3）排序查询

（4）分页查询

（5）投影查询

（6）聚集函数使用

 

4 qbc查询

（1）查询所有

（2）条件查询

（3）排序查询

（4）分页查询

（5）统计查询

（6）离线查询

 

5 hql多表查询

（1）mysql多表查询回顾

（2）hql多表查询

- 内连接、迫切内连接、左外连接、迫切左外连接、右外连接

 

6 hibernate的检索策略

（1）概念

- hibernate分成 ：立即和延迟查询

- 延迟查询分成：类级别和关联级别延迟

（2）具体操作

Hibernate查询方式

1 对象导航查询

（1）根据id查询某个客户，再查询这个客户里面所有的联系人

 

2 OID查询

（1）根据id查询某一条记录，返回对象

 

3 HQL查询

（1）Query对象，写hql语句实现查询

 

4 QBC查询

（1）Criteria对象

 

5 本地sql查询

（1）SQLQuery对象，使用普通sql实现查询

对象导航查询

1 查询某个客户里面所有联系人过程，使用对象导航实现

 

2 代码

OID查询

1 根据id查询记录

（1）调用session里面的get方法实现

HQL查询

1 hql：hibernate query language，hibernate提供一种查询语言，hql语言和普通sql很相似，区别：普通sql操作数据库表和字段，hql操作实体类和属性

 

2 常用的hql语句

（1）查询所有：from实体类名称

（2）条件查询：from实体类名称where属性名称=?

（3）排序查询：from实体类名称order by实体类属性名称asc/desc

 

3 使用hql查询操作时候，使用Query对象

（1）创建Query对象，写hql语句

（2）调用query对象里面的方法得到结果

查询所有

1 查询所有客户记录

（1）创建Query对象，写hql语句

（2）调用query对象里面的方法得到结果

 

2 查询所有： from实体类名称

 

条件查询

1 hql条件查询语句写法：

（1）  from  实体类名称where实体类属性名称=? and实体类属性名称=?

from  实体类名称 where 实体类属性名称like ?

 

2 代码

 

 

模糊查询

排序查询

1 hql排序语句写法

（1）from实体类名称order by实体类属性名称asc/desc

 

分页查询

1 mysql实现分页

（1）使用关键字limit实现

 

 

2 在hql中实现分页

（1）在hql操作中，在语句里面不能写limit，hibernate的Query对象封装两个方法实现分页操作

 

投影查询

1 投影查询：查询不是所有字段值，而是部分字段的值

 

2 投影查询hql语句写法：

（1）select实体类属性名称1,实体类属性名称2  from实体类名称

（2）select后面不能写*，不支持的

 

3 具体实现

聚集函数使用

1 常用的聚集函数

（1）count、sum、avg、max、min

 

2 hql聚集函数语句写法

（1）查询表记录数

- select count(*) from 实体类名称

 

 

QBC查询

1 使用hql查询需要写hql语句实现，但是使用qbc时候，不需要写语句了，使用方法实现

 

2 使用qbc时候，操作实体类和属性

 

3 使用qbc，使用Criteria对象实现

查询所有

1 创建Criteria对象

2 调用方法得到结果

 

条件查询

1 没有语句，使用封装的方法实现

 

 

排序查询

分页查询

 

 

开始位置计算公式： （当前页-1）*每页记录数

统计查询

离线查询

1 servlet调用service，service调用dao

（1）在dao里面对数据库crud操作

（2）在dao里面使用hibernate框架，使用hibernate框架时候，调用session里面的方法实现功能

 

（3）在后面ssh练习中具体应用

HQL多表查询

Mysql里面多表查询

1 内连接

 

 

2 左外连接

 

 

3 右外连接

HQL实现多表查询

Hql多表查询

（1）内连接

（2）左外连接

（3）右外连接

（4）迫切内连接

（5）迫切左外连接

HQL内连接

1 内连接查询hql语句写法：以客户和联系人为例

（1）from  Customer  c  inner  join c.setLinkMan

 

返回list，list里面每部分是数组形式

 

 

2 演示迫切内连接

（1）迫切内连接和内连接底层实现一样的

（2）区别：使用内连接返回list中每部分是数组，迫切内连接返回list每部分是对象

（3）hql语句写法

- from  Customer  c  inner  join  fetch  c.setLinkMan

HQL左外连接

1 左外连接hql语句：

（1）from  Customer  c  left  outer  join c.setLinkMan

（2）迫切左外连接from  Customer  c  left  outer  join  fetch c.setLinkMan

 

2 左外连接返回list中每部分是数组，迫切左外连接返回list每部分是对象

 

 

 

1 右外连接hql语句：

（1）from  Customer  c  right  outer  join c.setLinkMan

Hibernate检索策略

检索策略的概念

1 hibernate检索策略分为两类：

（1）立即查询：根据id查询，调用get方法，一调用get方法马上发送语句查询数据库

 

 

（2）延迟查询：根据id查询，还有load方法，调用load方法不会马上发送语句查询数据，只有得到对象里面的值时候才会发送语句查询数据库

 

 

2 延迟查询分成两类：

（1）类级别延迟：根据id查询返回实体类对象，调用load方法不会马上发送语句

 

（2）关联级别延迟：

- 查询某个客户，再查询这个客户的所有联系人，查询客户的所有联系人的过程是否需要延迟，这个过程称为关联级别延迟

关联级别延迟操作

1 在映射文件中进行配置实现

（1）根据客户得到所有的联系人，在客户映射文件中配置

 

2 在set标签上使用属性

（1）fetch：值select（默认）

（2）lazy：值

- true：延迟（默认）

- false：不延迟

- extra：极其延迟

 

 

 

（1）调用get之后，发送两条sql语句

 

 

（1）极其懒惰，要什么值给什么值

批量抓取

1 查询所有的客户，返回list集合，遍历list集合，得到每个客户，得到每个客户的所有联系人

（1）上面操作代码，发送多条sql语句

 

 

2 在客户的映射文件中，set标签配置

（1）batch-size值，值越大发送语句越少