Hibernate入门最后一天第四天，我们进行查询方式的更进一步的细化：
先看一下大致的Hibernate的提供的查询的方式：
1.对象导航查询
2.OID查询
3.HQL查询
4.QBC查询
5.本地SQL查询
使用框架，我们更加关注的是前四种查询的方式。
接下来逐条介绍：
1.对象导航查询
例如昨天的客户联系人的一对多：
根据id查询到客户，再根据客户下的所有联系人
这个查询过程称为对象导航
就是得到表示的那个set就可以
Set<LinkMan> set = cust.getSet_LinkMan();
/**
* 对象导航查询(顺便OID也在里面了)
* @author jiangbei01
*
*/
@Test
public void query1(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//查询客户中的所有联系人
Customer cust = session.get(Customer.class, 1);
//利用对象导航查询到所有联系人
//做法就是 得到那个表示所有联系人的set集合
Set<LinkMan> set = cust.getSet_LinkMan();
System.out.println(set.size());
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
2.OID查询
根据id查询某一条记录（返回的是对象）
也就是session.get方法实现
Customer cust = session.get(Customer.class, 1);
3.HQL查询
使用HQL语言（用到Query对象，昨天只演示了查询所有）==写语句
HQL与SQL最大的不同是：
HQL操作实体类
SQL操作表
HQL常用语句：
查询所有 === from 实体类名称
/**
* HQL Query对象查询所有
* @author jiangbei01
*
*/
@SuppressWarnings("deprecation")
@Test
public void query2(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//得到Query对象 ，显示已过时，待解决
Query query = session.createQuery("from Customer");
//调用方法
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer.getCustLevel());
}
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
条件查询 === from 实体类名称 where 实体类属性=? ... 写法与SQL基本类似:
from 实体类名称 where 属性 like ?
/**
* HQL条件查询 第一步都是创建query对象
* 模糊查询极其类似，不再赘述举例这里 参数为String类型的即可（%浪%）
*/
@Test
public void query3(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//得到Query对象 ，显示已过时，待解决
Query query = session.createQuery(
"from Customer c where c.cid=?");
//设置条件值，也就是向?设置值,一般都是用这个方法，而较少去使用其它重载方法
//第一个参数为int ?问号的位置，第二个为Object，这里必须注意：！！
//pstmt里面？从1 开始 ，这里从0开始！
query.setParameter(0, 1);
//调用方法
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer.getCustLevel());
}
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
排序查询 === from 实体类名称 order by 属性 acs
/**
*演示排序
*/
@Test
public void query4(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//得到Query对象 ，显示已过时，待解决
Query query = session.createQuery(
"from Customer order by cid asc");
//调用方法
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer.getCid());
}
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
分页查询 === mysql中实现分页使用的是关键字 limit,注意此时hibernate不认识Limit这个方言！
/**
*演示分页
*/
@Test
public void query5(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//得到Query对象 ，显示已过时，待解决
Query query = session.createQuery(
"from Customer");
//设置开始位置
query.setFirstResult(0);
//设置每页的记录数
query.setMaxResults(5);
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
使用的是query的封装的两个方法：
投影查询 === （用的不是很多，原因是查到所有后部分也简单）
投影的概念：查的是部分字段 例如 SELECT cid FROM t_stu
HQL与SQL这里也是极其相似
select 属性名1，属性名2 from 实体类名称（注意不能 写* ，写*查询所有应直接 from ...）
聚合函数 === 常用的COUNT() SUM() MAX/MIN() AVG()
HQL写法：
select count(*) from 实体类名称
使用这种接收只有某个的结果
Object o = query.uniqueResult();
注意此处返回值不能直接强转成int,因为此处o是long类型
应当先转成long类型，再转
Long不能直接强转，而是使用intValue()返回基本类型的值
/**
*演示聚合函数
*/
@Test
public void query6(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//得到Query对象 ，显示已过时，待解决
Query query = session.createQuery(
"select count(*) from Customer");
//只返回某个值，而不用list
Object o = query.uniqueResult();
System.out.println(o);
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
}
4.QBC查询 （实际开发更倾向于此而少写HQL）
用到的是 Criteria对象 ==不写语句，这是与HQL不同的部分，而是使用方法操作实体类进行的操作
包含的也是这些：
查询所有：
得到对象，调用方法即可
/**
*演示QBC查询所有
*/
@Test
public void query6(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//创建对象 ，显示已过时，待解决
Criteria criteria = session.createCriteria(Customer.class);
//调用方法实现
List<Customer> list = criteria.list();
//遍历结果集
for (Customer customer : list) {
System.out.println(customer.getCustName());
}
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
条件查询：
通过方法控制条件
/**
*演示QBC条件查询
*/
@Test
public void query5(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//创建对象 ，显示已过时，待解决
Criteria criteria = session.createCriteria(Customer.class);
//使用add()方法设置条件的值，更多请百度Restrictions静态类的用法
criteria.add(Restrictions.eq("cid", 1));
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer.getCustName());
}
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
以下概念不再赘述，直接见案例
排序查询：
/**
*演示QBC排序查询
*/
@Test
public void query4(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//创建对象 ，显示已过时，待解决
Criteria criteria = session.createCriteria(Customer.class);
//设置对哪个属性进行排序，包括排序方式和排序规则（似乎不如HQL方便）
criteria.addOrder(Order.desc("cid"));
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer.getCustName());
}
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
分页查询：
/**
*演示QBC分页查询
*/
@Test
public void query3(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//创建对象 ，显示已过时，待解决
Criteria criteria = session.createCriteria(Customer.class);
//也是调方法，和HQL有点相似,设置分页的两个数据,注意：凡是设置的方法，一般都是先打set前缀
criteria.setFirstResult(0);
criteria.setMaxResults(2);
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer.getCustName());
}
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
统计查询：
， 统计记录条数等：
/**
*演示QBC统计查询
*/
@Test
public void query2(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//创建对象 ，显示已过时，待解决
Criteria criteria = session.createCriteria(Customer.class);
//设置操作，其它操作举一反三
criteria.setProjection(Projections.rowCount());
//调用方法
Object o = criteria.uniqueResult();
Long l = (Long) o;
int r = l.intValue();
System.out.println(r);
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
离线查询：
步骤：
创建对象
设置操作
调用方法
离线查询：
之前的criteria是通过session查询的，是依赖session的
场景例子：希望在条件查询时就在servlet中实现条件的拼接
就是可以离线的操作
/**
*演示QBC离线查询
*/
@Test
public void query1(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//创建离线
DetachedCriteria detachedCriteria = DetachedCriteria
.forClass(Customer.class);
//最终执行的时候才用session
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
//再执行
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer.getCustPhone());
}
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
5.本地SQL查询
SQLQuery对象，使用本地SQL查询（前面有类似的案例，用的少的不再赘述）
当然，这里重点应该关注前4种查询方式
使用了上面的单表查询后，来看看HQL如何进行多表查询：
HQL多表查询（达到会用的水平先）
回顾mysql的一般多表查询：
内连接 INNER JOIN ON
左外连接 LEFT OUTER JOIN ON
右外连接 RIGHT OUTER JOIN ON
HQL实现多表查询：
1.内连接
2.左外连接
3.右外连接
4.迫切内连接
5.迫切左外连接（没有右外！勿擅自创造）
再次强调，HQL操作的是实体类，而不是表！
1.HQL内连接：
from Customer c inner join c.set_LinkMan
注意点：join后加的是表示联系人的set集合，并且后面没有on!
/**
*演示HQL内连接
*/
@Test
public void query1(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//HQL使用的是Query对象
Query query = session.createQuery("from Customer c inner join c.set_LinkMan");
List list = query.list();
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
2.迫切内连接和内连接的底层实现是一样的
迫切内连接返回的list每部分是对象
而内连接返回的list每部分是数组
from Customer c inner join fetch c.set_LinkMan
3.左外连接与迫切左外连接：
from Customer c left outer join c.set_LinkMan
from Customer c left outer join fetch c.set_LinkMan
同样的，左外连接返回的每部分是数组
迫切左外连接返回的是对象
迫切与普通连接查询的区别：
以上两种用法与1都相差无几。
Hibernate检索策略：
主要分为两类：
立即检索：
一调用get()方法马上发送SQL语句去查询
延迟检索：
调用load()方法，不会马上发送语句，
只有得到对象里面的值的时候，也就是什么时候用那个值
才发送语句，查询数据库，调用load()时，初始里面只有传入的id值
验证的方式是debug看发送语句的时机（F6一步一步走）
延迟查询中又分两类：（默认会有相关的延迟优化方式，自己修改的机会少）
类级别的延迟：
返回一个实体类的对象
在class标签上设置lazy值（选值见下）
关联级别的延迟：
查询某个客户，再查询客户里的所有联系人，
查询客户所有联系人的过程是否需要延迟
关联级别的延迟方式也可以自己修改（当然，默认的优化已经可以，作了解）
修改方式是在映射文件中进行配置
根据客户得到联系人，则配置客户的映射文件
在set标签上设置属性：
fetch:值select（默认）
lazy:值true 延迟（默认）
false 不延迟(遇到要用时都查出来给你)
extra 极其延迟（要什么给的什么，用size就只发送count(*)）
/**
*演示立即查询与延迟查询
*/
@Test
public void query1(){
//注意规范写法
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//得到工厂
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//一调用get方法，马上去查询
Customer cust = session.get(Customer.class, 1);
System.out.println(cust.getCustName());
Customer cust1 = session.load(Customer.class, 2);//此时Customer中只有一个id值
System.out.println(cust1.getCustName());//去拿它的名字时才发语句去查询
//提交事务
tx.commit();
}catch(Exception e){
//事务回滚
tx.rollback();
}finally{
//关闭资源
session.close();
sessionFactory.close();
}
}
Hibernate的批量抓取（会用）
比如使用场景，需要查询所有客户（返回list）的联系人
可以先查出list,再逐个遍历（性能低）
这种对象导航仅仅实现了功能，却使得性能低下（发送了很多次的语句）
完成批量抓取的优化是通过映射文件的配置完成的
在set标签上配置属性 batch-size=""
这里面配置一个整形，没有固定值，值越大发的语句越少，性能越高（当然应当根据数据库记录数调优）
（可以查看底层SQL，使用的是in(?,?...)的形式，减少了语句的发送）