Hibernate学习（三）

Hibernate的查询方法（五种）

一、OID查询：按主键查询

--get( )

--load( )

二、对象导航查询：通过已经查询到的联系人，得到起关联的对象

三、SQL查询

四、HQL查询（***）

1、String hql = “ 查询语句”

Query query = session.createQuery( ) ; // 得到query对象

（1）简单查询

hql = “from Customer”;//查询Customer所有信息

List<Customer> list = query.list( ) ;//得到一个List集合，通过遍历即可

（2）排序查询：默认升序

hql = “from Customer order by 属性名 ASC(升)/DESC(降序)”

List<Customer> list = query.list( ) ;//得到一个List集合，通过遍历即可

（3）条件查询

a、hql = “form Customer where 属性名= ？（and/or ,,,,,,）”

query.setParameter(0 , 属性值)：0表示第一个问号

b、名称绑定

hql = “form Customer where 属性名= : a（and/or ,,,,,,）”(冒号 + 名称（任意）)

query.setParameter(a , 属性值)：a表示名称

（4）投影查询：查询特定的属性

例如：查询所有客户的名称

a、使用别名.属性，返回一个类型为Object的集合

hql = “select c.cust_name（，c.cust_source可以多个） from Customer c”

List<Object> list = query.list( ) ;//得到一个List集合，通过遍历即可,Object更通用

b、使用构造函数，在持久化类中创建一个构造函数,返回值类型为Customer

hql = “ select new Customer(cust_name, cust_source) from Customer”

List<Customer> list = query.list( ) ;//得到一个List集合，通过遍历即可

（5）分页查询

query.setFirstResult( 0) : 表数据的第1 行开始

query.setMaxResult( 0) : 每一页共10 行

（6）分组查询：

用聚合函数：count( ) max( ) min( ) 结合 group by

select 属性名，count(*) from Customer group by 属性名

（7）HQL的多表查询

SQL的多表查询

　　　　连接查询：交叉连接：笛卡尔积

　　　　　　-select * from A,B;

　　　　内连接 :inner join (inner 可以省略)

　　　　　　-隐式内连接：

　　　　　　　　select * from A,B where A.id = B.aid;

　　　　　　-显示内连接：

　　　　　　　　select * from A inner join B on A.id = B.aid;

　　　　外连接 :

　　　　　　-左外连接:left outer join(outer 可以省略)

　　　　　　　　　　select * from A left outer join B on A.id= B.aid;

　　　　　　-右外连接:right outer join(outer 可以省略)

　　　　　　　　　　select * from A right outer join B on A.id = B.aid;

HQL的多表查询

　　　　　内连接

　　　　　　　　显示内连接

　　　　　　　　隐式内连接

　　　　　　　　迫切内连接

　　　　　外连接

　　　　　　　　左外连接

　　　　　　　　右外连接

　　　　　　　　迫切左外连接

五、QBC查询：Query By Criteria(完全面向对象查询)

1、得到一个Criteria 对象

Criteria c = session.createCriteria(Customer.class)

2、查询所有 c.list( )

3、排序查询 c.addOrder(order.asc/desc( 属性名))

4、分页查询 c.setFirstResult( 0) : 表数据的第1 行开始

c.setMaxResult( 0) : 每一页共10 行

5、条件查询

c.add(Restriction.eq(属性名，属性值))：查询名=值

　　eq = and

　　gt > like

　　ge >= or

　　lt <

　　le <=

　　需要多添加查询就在add( )

6、离散条件查询（DetachedCriteria）: 隔离session的查询

　　DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);

　　设置条件

　　 dc. add(Restriction.eq(属性名，属性值))

Hibernate的抓取策略（优化）

1、什么是延迟加载

　　延迟加载：lazy（懒加载）。执行到该行代码的时候，不会发送语句去进行查询，在真正使用这个对象的属性的时候才会发送SQL语句进行查询。

2、延迟加载的分类

（1）类级别的延迟加载：指的是通过load方法查询某个对象的时候，是否采用延迟。session.load(Customer.class,1l);

　　类级别延迟加载通过<class>上的lazy进行配置

　　如果让lazy失效，

　　　--　将lazy设置为false

　　　--　将持久化类使用final修饰

　　　--　Hibernate. Initialize()

（2）关联级别的延迟加载：指的是在查询到某个对象的时候，查询其关联的对象的时候，是否采用延迟加载。

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

　　　　customer.getLinkMans();----通过客户获得联系人的时候，联系人对象是否采用了延迟加载，称为是关联级别的延迟。

　　　　 抓取策略往往会和关联级别的延迟加载一起使用，优化语句。

3 抓取策略的概述

　　通过一个对象抓取到关联对象需要发送SQL语句，SQL语句如何发送，发送成什么样格式通过策略进行配置。通过<set>或者<many-to-one>上

　　通过fetch属性进行设置 fetch和这些标签上的lazy如何设置优化发送的SQL语句

3.1 <set>上的fetch和lazy

fetch：抓取策略，控制SQL语句格式

--select ：默认值，发送普通的select语句，查询关联对象

--join ：发送一条迫切左外连接查询关联对象

--subselect ：发送一条子查询查询其关联对象

lazy：延迟加载，控制查询关联对象的时候是否采用延迟

　 --- true ：默认值，查询关联对象的时候，采用延迟加载

　　---false ：查询关联对象的时候，不采用延迟加载

　　---extra ：极其懒惰。

在实际开发中，一般都采用默认值。如果有特殊的需求，可能需要配置join。

3.2 <many-to-one>上的fetch和lazy

fetch ：抓取策略，控制SQL语句格式。

　　--select ：默认值，发送普通的select语句，查询关联对象。

　　--join ：发送一条迫切左外连接。

lazy ：延迟加载，控制查询关联对象的时候是否采用延迟。

　　--proxy ：默认值，proxy具体的取值，取决于另一端的<class>上的lazy的值。

　　--false ：查询关联对象，不采用延迟。

　　--no-proxy ：（不会使用）

在实际开发中，一般都采用默认值。如果有特殊的需求，可能需要配置join。

4、批量抓取

4.1什么是批量抓取？指一批关联对象一起抓取，batch-size