一．Hibernate检索方式概述

  1. OID检索方式：按照对象的OID来检索对象（get/load）
  2. HQL检索方式：使用面向对象的HQL查询语言
  3. QBC检索方式：使用QBC(Query By Criteria)API来检索对象，这种api封装了基于字符串形式的查询语句，提供了更加面向对象的查询接口（功能较弱）
  4. 本地SQL检索方式：使用本地数据库的SQL查询语句。

二．Hibernate检索策略

Hibernate提供了多种查询检索方式，每种方式查询数据的方式与时间段都不同，

Hibernate提供了延迟加载(load)、立即加载(get)两种检索策略。

延迟加载(懒加载)：延迟加载检索方法指定的对象，也就是查询的时候并不是马上去查询并加载持久化对象，而是在调用持久化对象的方法时再去加载。

立即加载：立即加载检索方法指定的对象。

->使用load方法获取对象，默认是延迟加载的，通过观察sql语句执行的位置可以看出，检索持久化对象时并不查询数据库，而当调用持久化对象的方法时才去查询数据库，这种策略就叫延迟加载。使用get方法获取持久化对象，会马上执行sql语句，这种策略叫立即加载。

  1. public class Demo {
  2.     @Test
  3.     public void test(){
  4.       Configuration cfg = new Configuration().configure();
  5.         SessionFactory sf = cfg.buildSessionFactory();
  6.         Session session = sf.openSession();
  7.         Transaction ts = session.beginTransaction();
  9.         Dept dept = (Dept)session.load(Dept.class, 1);
  10.         System.out.println("此时不查询数据库");
  11.         System.out.println(dept.getDname());
  13.         ts.commit();
  14.         session.close();
  15.         sf.close();
  16.     }
  18. }

使用load方法时，返回的是一个代理对象，该代理对象的特点：

1 .是持久化类的子类对象。

2 .包含持久化类的全部属性以及属性的get/set函数。

3. 对get函数进行了覆盖：原理如下

public String getName（） {

this.name = queryFromDb();//数据库查询

return this.name;

}

4.Hibernate使用javassist-3.9.0.GA.jar包创建代理

类级别检索策略： session的方法直接检索持久化对象，hibernate加载该持久化对象的策略。

关联级别检索策略：查询持久化对象的关联对象的加载策略。

三．关联级别检索策略（一对多，多对多检索策略）

lazy属性：是否延迟加载，

true ：延迟加载  (默认)：查询持久化对象，使用相关联对象时再去查询

false：即时加载  ：查询持久化对象时会查询出所有与持久化对象相关联的对象

一般情况下都要设置Lazy=true, 这样可以少查无用的数据, 提高性能. 但是有的时候需要一次性把关联的数据都查出来, 这个时候就需要使用积极加载去避免lazy loading了. 具体情况具体分析。

* 类级别的检索:＜class>标签上配置lazy

* 关联级别的检索: <set>/<many-to-one>上面的lazy。

注意：无论 <class> 元素的 lazy 属性是 true 还是 false, Session 的 get() 方法在类级别总是使用立即检索策略

比较检索策略

四.HQL检索方式

1>HQL(Hibernate Query Language) 是面向对象的查询语言,确切的说他是以脚本的方式查询对象的语言。 它和SQL查询语言有些相似. 在Hibernate提供的各种检索方式中, HQ是使用最广的一种检索方式. 它有如下功能:

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

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

支持分页查询；

支持连接查询；

支持分组查询，允许使用having和group by关键字

提供内置聚集函数，如sum(),min(),max();

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

支持子查询；

支持动态绑定参数；

  1. /**
  2.  * Created by jiatp
  3.  */
  4. public class HqlTest {
  5.     //1.基本查询
  6.     @Test
  7.     public void test1(){
  8.         Session session = HibernateUtils.openSession();
  9.         Transaction ts = session.beginTransaction();
  10.         //查询所有部门信息
  11.         String hql = "from Dept";
  12.         Query query = session.createQuery(hql);
  13.         List<Dept> list = query.list();
  14.         for(Dept dept:list) {
  15.             System.out.println(dept.getDname());
  16.             System.out.println(dept.getEmps().size());
  17.         }
  18.         ts.commit();
  19.         session.close();
  21.     }
  22.     //2.条件查询  1.占位符 2.参数命名
  23.     @Test
  24.     public void test2(){
  25.         Session session = HibernateUtils.openSession();
  26.         Transaction ts = session.beginTransaction();
  27.         //查询所有部门信息
  28.         String hql1 = "from Dept where did=?";
  29.         String hql2 = "from Dept where did=:did";
  30.         Query query1 = session.createQuery(hql1);
  31.         Query query2 = session.createQuery(hql2);
  32.         //占位符赋值
  33.         query1.setInteger(0,1);
  34.         //参数命名赋值
  35.         query2.setInteger("did",1);
  36.         //查询
  37.         Dept dept1 = (Dept)query1.uniqueResult();
  38.         Dept dept2 = (Dept)query2.uniqueResult();
  39.         System.out.println(dept1.getDname());
  40.         System.out.println(dept2.getDname());
  41.         ts.commit();
  42.         session.close();
  44.     }
  45.     //3.分页查询
  46.     @Test
  47.     public void test3(){
  48.         Session session = HibernateUtils.openSession();
  49.         Transaction ts = session.beginTransaction();
  50.         //查询所有部门信息
  51.         String hql = "from Dept where dname like ?";
  52.         Query query = session.createQuery(hql);
  53.         query.setParameter(0,"%发%"); //变量用+连接"+"+ 变量+"%"
  54.         //分页
  55.         query.setFirstResult(0);
  56.         query.setMaxResults(3);
  57.         List<Dept> list = query.list();
  58.         for(Dept dept: list) {
  59.             System.out.println(dept.getDid()+"==="+dept.getDname());
  60.         }
  61.         ts.commit();
  62.         session.close();
  64.     }
  65.     //4.投影查询 返回一个数组
  66.     @Test
  67.     public void test5(){
  68.         Session session = HibernateUtils.openSession();
  69.         Transaction ts = session.beginTransaction();
  70.         //查询所有部门信息
  71.         String hql1 = "select did,dname from Dept";//返回对象数组
  72.         Query query = session.createQuery(hql1);
  73.         List<Object[]> list = query.list();
  74.         for(int i=0;i<list.size();i++) {
  75.             Object[] object = list.get(i);
  76.             System.out.println(object[0]+"===="+object[1]);
  77.         }
  78.         String hql2 = "select dt from Dept dt"; //返回集合对象
  79.         Query query1 = session.createQuery(hql2);
  80.         List<Dept> list1 = query1.list();
  81.         for(Dept dept:list1) {
  82.             System.out.println(dept.getDid()+"=="+dept.getDname());
  83.         }
  85.         //Dept类中要提供构造方法
  86.         String hql3 = "select new Dept(did,dname) from Dept";
  87.         Query query2 = session.createQuery(hql3);
  88.         List<Dept> list2 = query2.list();
  89.        for(Dept dept:list2) {
  90.             System.out.println(dept.getDid()+"=="+dept.getDname());
  91.         }
  92.         ts.commit();
  93.         session.close();
  94.     }
  95.     // 5.排序
  96.     @Test
  97.     public void test6(){
  98.         Session session = HibernateUtils.openSession();
  99.         Transaction ts = session.beginTransaction();
  100.         String hql = "select dt from Dept d t order by dt.did desc";
  101.         Query query = session.createQuery(hql);
  102.         List<Dept> list = query.list();
  103.         for(Dept dept:list) {
  104.             System.out.println(dept.getDid()+"=="+dept.getDname());
  105.         }
  106.         ts.commit();
  107.         session.close();
  108.     }
  109.     //6.查询聚合函数
  110.     @Test
  111.     public void test7(){
  112.         Session session = HibernateUtils.openSession();
  113.         Transaction ts = session.beginTransaction();
  114.         String hql1 = "select COUNT (*) FROM Dept";
  115.         String hql2 = "select sum (did) FROM Dept";
  116.         String hql3 = "select avg (did) FROM Dept";
  117.         String hql4 = "select max (did) FROM Dept";
  118.         String hql5 = "select min (dit) FROM Dept";
  119.         Query query = session.createQuery(hql1);
  120.         Number i =(Number) query.uniqueResult();
  121.         System.out.println(i);
  122.         ts.commit();
  123.         session.close();
  124.     }
  125.     //7.增加一个部门 广告部
  126.     @Test
  127.     public void test8(){
  128.         Session session = HibernateUtils.openSession();
  129.         Transaction ts = session.beginTransaction();
  130.        Dept dept = new Dept();
  131.        dept.setDname("广告部");
  132.        session.save(dept);
  133.         ts.commit();
  134.         session.close();
  136.     }
  138.     //8.删除
  139.     @Test
  140.     public void test9(){
  141.         Session session = HibernateUtils.openSession();
  142.         Transaction ts = session.beginTransaction();
  143.         String hql = "delete from Dept dt where dt.did=? ";
  144.         Query query = session.createQuery(hql);
  145.         query.setParameter(0,7);
  146.         query.executeUpdate();
  147.         ts.commit();
  148.         session.close();
  150.     }
  151.     //外联(左外联，右外联)/迫切
  152.     //内联，
  153.     @Test
  154.     public void test8() {
  155.         Session session = HibernateUtils.openSession();
  156.         Transaction tx = session.beginTransaction();
  157.         //************************************
  158.         String hql="from Dept d inner join d.emps";
  159.         Query query = session.createQuery(hql);
  160.         List list = query.list();
  161.         for(int i=0;i<list.size();i++){
  162.             Object[] obj = (Object[]) list.get(i);
  163.             System.out.println(((Dept)obj[0]).getDname()+"===="+((Emp)obj[1]).getEname());
  164.         }
  165.         //************************************
  166.         tx.commit();
  167.         session.close();
  168.     }
  169.     //内联，/迫切
  170.     @Test
  171.     public void test9() {
  172.         Session session = HibernateUtils.openSession();
  173.         Transaction tx = session.beginTransaction();
  174.         //*****************************************
  175.         String hql="from Dept d inner join fetch d.emps";
  176.         Query query = session.createQuery(hql);
  177.         List<Dept> list = query.list();
  178.         //创建集合保存部门名称
  179.         List<String> lstr = new ArrayList<String>();
  180.         for (Dept dept : list) {
  181.             Set<Emp> emps = dept.getEmps();
  182.             Iterator<Emp> it = emps.iterator();
  183.             while(it.hasNext()){
  184.                 Emp emp = it.next();
  185.                 if(lstr.contains(emp.getDept().getDname())){
  186.                     continue;
  187.                 }else{
  188.                     System.out.println(dept.getDname()+"==="+emp.getEname());
  189.                 }
  190.             }
  191.             //处理重复部门名
  192.             lstr.add(dept.getDname());
  193.         }
  194.         //****************************************
  195.         tx.commit();
  196.         session.close();
  197.     }
  198.     //左外联
  199.     @Test
  200.     public void test10() {
  201.         Session session = HibernateUtils.openSession();
  202.         Transaction tx = session.beginTransaction();
  203.         //************************************
  204.         String hql="from  Dept d left join d.emps";
  205.         Query query = session.createQuery(hql);
  206.         List list = query.list();
  207.         for(int i=0;i<list.size();i++){
  208.             Object[] obj = (Object[]) list.get(i);
  209.             if(obj!=null){
  210.                 System.out.print(((Dept)obj[0]).getDname());
  211.                 if(((Emp)obj[1])!=null){
  212.                     System.out.print("\t"+((Emp)obj[1]).getEname());
  213.                 }
  214.                 System.out.println();
  215.             }
  216.         }
  218.         //************************************
  219.         tx.commit();
  220.         session.close();
  221.     }
  222.     //右外联，
  223.     @Test
  224.     public void test11() {
  225.         Session session = HibernateUtils.openSession();
  226.         Transaction tx = session.beginTransaction();
  227.         //************************************
  228.         String hql="from Dept d right join d.emps";
  229.         Query query = session.createQuery(hql);
  230.         List list = query.list();
  231.         for(int i=0;i<list.size();i++){
  232.             Object[] obj = (Object[]) list.get(i);
  233.             if(obj!=null){
  234.                 if(((Dept)obj[0])!=null){
  235.                     System.out.print(((Dept)obj[0]).getDname());
  236.                 }
  237.                 if(((Emp)obj[1])!=null){
  238.                     System.out.print("\t"+((Emp)obj[1]).getEname());
  239.                 }
  240.                 System.out.println();
  241.             }
  242.         }
  244.         //************************************
  245.         tx.commit();
  246.         session.close();
  247.     }
  248.     //左外联，/迫切
  249.     @Test
  250.     public void test12() {
  251.         Session session = HibernateUtils.openSession();
  252.         Transaction tx = session.beginTransaction();
  253.         //************************************
  254.         String hql="from Dept d left join fetch d.emps";
  255.         Query query = session.createQuery(hql);
  256.         List<Dept> list = query.list();
  257.         for(Dept dept : list){
  258.             Set<Emp> emps = dept.getEmps();
  259.             Iterator<Emp> it = emps.iterator();
  260.             //
  261.             if(dept.getDname()!=null){
  262.                 System.out.print(dept.getDname());
  263.             }
  264.             while(it.hasNext()){
  265.                 Emp emp = it.next();
  266.                 if(emp.getDept().getDname()!=dept.getDname()){
  267.                     System.out.print(dept.getDname());
  268.                 }
  269.                 if(emp.getEname()!=null){
  270.                     System.out.print("\t"+emp.getEname());
  271.                 }
  272.                 System.out.println();
  273.             }
  274.         }
  276.         //************************************
  277.         tx.commit();
  278.         session.close();
  279.     }
  280.     //分组
  281.     @Test
  282.     public void test13(){
  283.         Session session = HibernateUtils.openSession();
  284.         Transaction tx = session.beginTransaction();
  285.         //************************************
  286.         //查询部门中的员工的人数
  287.         String hql ="select count(*),e.dept.dname from Emp e group by e.dept.dname";
  288.         Query query = session.createQuery(hql);
  289.         List<Object[]> list = query.list();
  290.         for(int i = 0 ;i<list.size();i++){
  291.             Object[] o =  list.get(i);
  292.             System.out.println(o[0]+"====="+o[1]);
  293.         }
  294.         //************************************
  295.         tx.commit();
  296.         session.close();
  297.     }
  298. }

五.QBC检索方式

QBC查询就是通过使用Hibernate提供的Query By Criteria API来查询对象，这种API封装了SQL语句的动态拼装，对查询提供了更加面向对象的功能接口。

  1. public class TestQbc {
  3. 	//简单的查询  (无sql)
  4. 	@Test
  5. 	public void test() {
  6. 		Session session = HibernateUtils.openSession();
  7. 		Transaction tx = session.beginTransaction();
  8. 		//************************************
  9. 		//查询所有部门信息
  10. 		Criteria criteria = session.createCriteria(Dept.class);
  11. 		List<Dept> list = criteria.list();
  12. 		System.out.println(list);
  13. 		//************************************
  14. 		tx.commit();
  15. 		session.close();
  16. 	}
  17. 	//按条件查询
  18. 	//==        	eq
  19. 	//>=			ge
  20. 	//>				gt
  21. 	//<=			le
  22. 	//<				lt
  23. 	//<> !=			ne
  24. 	//in			in
  25. 	//between 		between
  26. 	//like 			like
  27. 	//is null		isNull
  28. 	//is not null	isNotNull
  29. 	//and 			and
  30. 	//or			or
  31. 	@Test
  32. 	public void test1() {
  33. 		Session session = HibernateUtils.openSession();
  34. 		Transaction tx = session.beginTransaction();
  35. 		//************************************
  36. 		//查询did=2 部门名称
  37. 		Criteria criteria = session.createCriteria(Dept.class);
  38. 		criteria.add(Restrictions.eq("did", 2));
  39. 		Dept dept = (Dept) criteria.uniqueResult();
  41. 		System.out.println(dept.getDname());
  42. 		//************************************
  43. 		tx.commit();
  44. 		session.close();
  45. 	}
  46. 	//分页
  47. 	@Test
  48. 	public void test2() {
  49. 		Session session = HibernateUtils.openSession();
  50. 		Transaction tx = session.beginTransaction();
  51. 		//************************************
  52. 		//limit 0,3
  53. 		Criteria criteria = session.createCriteria(Dept.class);//.setFirstResult(0).setMaxResults(3).list();
  54. 		criteria.setFirstResult(0);  //起始值
  55. 		criteria.setMaxResults(3);    //条数
  56. 		List<Dept> list = criteria.list();
  57. 		System.out.println(list);
  58. 		//************************************
  59. 		tx.commit();
  60. 		session.close();
  61. 	}
  62. 	//查询总记录数
  63. 	@Test
  64. 	public void test3() {
  65. 		Session session = HibernateUtils.openSession();
  66. 		Transaction tx = session.beginTransaction();
  67. 		//************************************
  68. 		//limit 0,3
  69. 		Criteria criteria = session.createCriteria(Dept.class);
  70. 		criteria.setProjection(Projections.rowCount());
  71. 		Long iter = (Long) criteria.uniqueResult();
  72. 		System.out.println(iter);
  73. 		//************************************
  74. 		tx.commit();
  75. 		session.close();
  76. 	}
  78. }

Criteria:限制符

六.本地SQL检索方式

  1. public class TestSql {
  3. 	//简单部门信息
  4. 	@Test
  5. 	public void test1() {
  6. 		Session session = HibernateUtils.openSession();
  7. 		Transaction tx = session.beginTransaction();
  8. 		//************************************
  9. 		String sql="select dname,ename from Dept d,emp e where d.did=e.deptid";
  10. 		SQLQuery sqlquery = session.createSQLQuery(sql);
  11. 		List list = sqlquery.list();
  12. 		for(int i=0;i<list.size();i++){
  13. 			Object[] obj = (Object[]) list.get(i);
  14. 			System.out.println(obj[0]+"===="+obj[1]);
  15. 		}
  16. 		//************************************
  17. 		tx.commit();
  18. 		session.close();
  19. 	}
  20. 	//条件
  21. 	@Test
  22. 	public void test2() {
  23. 		Session session = HibernateUtils.openSession();
  24. 		Transaction tx = session.beginTransaction();
  25. 		//************************************
  26. 		String sql="select * from Dept where dname like ?";
  27. 		SQLQuery sqlquery = session.createSQLQuery(sql);
  28. 		sqlquery.setParameter(0, "%发%");
  29. 		//返回实体
  30. 		sqlquery.addEntity(Dept.class);
  31. 		List<Dept> list = sqlquery.list();
  32. 		for (Dept dept : list) {
  33. 			System.out.println(dept.getDname());
  34. 		}
  35. 		//************************************
  36. 		tx.commit();
  37. 		session.close();
  38. 	}
  39. 	//分页
  40. 	@Test
  41. 	public void test3() {
  42. 		Session session = HibernateUtils.openSession();
  43. 		Transaction tx = session.beginTransaction();
  44. 		//************************************
  45. 		String sql="select * from Dept limit ?,?";   //hql语句：count(*)
  46. 		SQLQuery sqlQuery = session.createSQLQuery(sql);
  47. 		sqlQuery.setParameter(0, 0);
  48. 		sqlQuery.setParameter(1, 2);
  49. 		sqlQuery.addEntity(Dept.class);
  50. 		List<Dept> list = sqlQuery.list();
  51. 		for(Dept dept : list){
  52. 			System.out.println(dept.getDname());
  53. 		}
  54. 		//************************************
  55. 		tx.commit();
  56. 		session.close();
  57. 	}
  58. }

HQL和QBC比较：

04_Hibernate检索方式的更多相关文章

  1. Hibernate —— HQL、QBC检索方式

    一.HQL 检索方式 以双向的一对多来测试 HQL 检索方式.以 Department 和 Employee 为例. 建表语句: CREATE TABLE department ( dept_id ) ...

  2. Hibernate的检索方式

    Hibernate的检索方式 检索方式(查询的方式) 导航对象图检索方式: 根据已经加载的对象导航到其他对象 Customer customer = (Customer)session.get(Cus ...

  3. 攻城狮在路上（壹） Hibernate（十四）--- Hibernate的检索方式（下）

    本节介绍HQL和QBC的高级用法:各种连接查询.投影查询.报表查询.动态查询.集合过滤和子查询等.另外将归纳优化查询程序代码,从而提高查询性能的各种技巧.一.连接查询: HQL与QBC支持的各种连接类 ...

  4. 攻城狮在路上（壹） Hibernate（十三）--- Hibernate的检索方式（上）

    Hibernate提供了以下几种检索对象的方式: A.导航对象图检索方式. B.OID检索方式.Session.get() load(); C.HQL检索方式.Query. D.QBC检索方式.Que ...

  5. hibernate检索方式（HQL 检索方式，QBC 检索方式，本地 SQL 检索方式）

    hibernate有五种检索方式,这儿用 单向的一对多的映射关系 例子,这儿有后三种的方式: 导航对象图检索方式: 根据已经加载的对象导航到其他对象 OID 检索方式: 按照对象的 OID 来检索对象 ...

  6. Hibernate 检索方式

    概述 •Hibernate 提供了以下几种检索对象的方式 –导航对象图检索方式:  根据已经加载的对象导航到其他对象 –OID 检索方式:  按照对象的 OID 来检索对象 –HQL 检索方式: 使用 ...

  7. Hibernate入门6.Hibernate检索方式

    Hibernate入门6.Hibernate检索方式 20131128 代码下载 链接: http://pan.baidu.com/s/1Ccuup 密码: vqlv Hibernate的整体框架已经 ...

  8. [原创]java WEB学习笔记89：Hibernate学习之路-- -Hibernate检索方式(5种)，HQL介绍，实现功能，实现步骤，

    本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...

  9. Hibernate的三种常用检索方式

    Hibernate 提供了以下几种检索对象的方式 ¨       导航对象图检索方式:  根据已经加载的对象导航到其他对象 ¨       OID 检索方式:  按照对象的 OID 来检索对象 ¨   ...

随机推荐

  1. vue项目使用history模式打包应该注意的地方

    1.在config/index.js中将assetsPublicPath原来的’/‘修改为‘./’. build: { env: require('./prod.env'), index: path. ...

  2. Mybatis使用Mapper方式CURD

    Mybatis 使用Dao代码方式进行增.删.改.查和分页查询. 1.Maven的pom.xml 2.配置文件 2.1.db.properties 2.2.mybatis.xml <?xml v ...

  3. java 与日期转换相关的方法（java.util.date类型和java.sql.date类型互相转换）、随机字符串生成方法、UUID生产随机字符串

    package com.oop.util; import java.text.*; import java.util.UUID; import org.junit.Test; /* * 与日期相关的工 ...

  4. vba增删改查数据库

    你在EXCEL中增加一个列名为ID,后在VBA中写以下代码,并引用Microsoft ActiveX Data Objects 2.8后执行Public Sub 写入SQL2008()Dim cnn ...

  5. 字典配合split分裂填充

    Sub 配送日报()lastrow = Sheets("运营日报").Range("a1048576").End(xlUp).Rowarr = Sheets(& ...

  6. Linux 常用命令：解压缩篇

    前言 Linux常用命令中,有很多用于对文件的压缩或解压,本文将介绍这些解压缩命令中不常见却非常实用的用法. tar tar是linux中最常用的解压缩命令.tar命令可用于处理后缀名为tar,tar ...

  7. flask 使用hashlib加密

    flask 使用hashlib加密 import hashlib #引入hashlib #使用方法: password = ' sha1 = hashlib.sha1() #使用sha1加密方法,你还 ...

  8. 用while实现登录操作(3次过后，输入yes,使counter置0,还可以玩)

    用while实现登录操作(输入yes,使counter置0,还可以玩)#_author:Administrator#date:2019/10/24user_name="star"p ...

  9. 基于vue的环信基本实时通信功能

    本篇文章借鉴了一些资料,然后在这个基础上,我将环信的实现全部都集成在一个组件里面进行实现: https://blog.csdn.net/github_35631540/article/details/ ...

  10. LUOGU P2290 [HNOI2004]树的计数(组合数，prufer序)

    传送门 解题思路 \(prufer\)序,就是所有的不同的无根树,都可以转化为唯一的序列.做法就是每次从度数为\(1\)的点中选出一个字典序最小的,把这个点删掉,并把这个点相连的节点加入序列,直到只剩 ...