查询机制（一）

    数据查询与检索是Hibernate中的一个亮点。相对于其它ORM实现而言，Hibernate提供了灵活多样的查询机制。

    【概述】

    一、标准化对象查询（Criteria Query)

    定义：以对象的方式进行查询，将查询语句封装为对象操作。

    优点：可读性好，符合Java程序员的编码习惯。

    缺点：不够成熟，不支持投影或统计函数。

    查询用户名以“J”开头的所有用户：

    二、Hibernate语言查询（Hibernate Query Language,HQL)

        1. 定义：它是完全面向对象的查询语句，查询功能非常强大，具备多态、关联等特性。

        2. HQL用面向对象的方式生成SQL：

（1）以类和属性代替表和数据列

（2）支持多态

（3）支持各种关联

（4）减少了SQL的冗余

        3.HQL支持所有的关系数据库操作

            连接、投影、聚合、排序、子查询和SQL函数

    查询用户名以“J”开头的所有用户：

    三、Native SQL Queryies（原生SQL查询）

        直接使用标准SQL语言或跟特定数据库相关的SQL进行查询。

    从User和Group中查询属于“admin”组的所有用户：

    

    【HQL查询】

        在hql中关键字不区分大小写，通常小写，类的名称和属性名称必须区分大小写

    一、简单属性查询

        1. 单一属性查询（查询学生的姓名）：

            //返回结果集属性列表，元素类型和实体类中的属性类型一致
            List students = session.createQuery("select name from Student").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                //name返回的String类型
                String name = (String)iter.next();
                System.out.println(name);
            }  

        2. 多个属性查询（查询学生的id和name）：

            //查询多个属性，返回对象数组集合
            //数组元素的类型与查询的属性类型一致
            //数组的长度与select中查询的属性个数一致
            List students = session.createQuery("select id, name from Student").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Object[] obj = (Object[])iter.next();
                System.out.println(obj[0] + ", " + obj[1]);
            }  

    二、实体对象查询

        1. 无select关键字：

            //返回Student对象的集合
            List students = session.createQuery("from Student").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }

        2. 无select关键字，使用别名：

            List students = session.createQuery("from Student s").list();
            //采用as命名
            List students = session.createQuery("from Student as s").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }

        3. 用select关键字，必须加上别名：

            List students = session.createQuery("select s from Student s").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }  

        4. 不支持select * from 语法

            List students = session.createQuery("select * from Student s").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }  

    【补充】list和iterate的区别

     list： 默认情况下list每次都会发出sql语句，list会将数据放到缓存中，而不利用缓存

     iterate：默认情况下iterate利用缓存，如果缓存中不存在会出现N+1问题(发出了N+1条sql语句,1：首先发出查询对象id列表的语句;N：根据id到缓存中查询，如果缓存中不存在与之匹配的数据，那么会根据id发出相应的sql语句)

1. 采用list查询
            /**
             * 采用list查询实体对象会发出一条查询语句，取得实体对象数据
             * 
             * Hibernate: select student0_.id as id0_, student0_.name as name0_, 
             * student0_.createTime as createTime0_, student0_.classesid as classesid0_ 
             * from t_student student0_
             */
            List students = session.createQuery("from Student").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            } 
2. 采用iterator查询
            /**
             * 会出现N+1问题，所谓的N+1指的是发出了N+1条sql语句
             * 
             * 1:发出一条查询id列表的语句
             * Hibernate: select student0_.id as col_0_0_ from t_student student0_
             * 
             * N:根据id发出N条sql语句，加载相关的对象
             * Hibernate: select student0_.id as id0_0_, student0_.name as name0_0_, 
             * student0_.createTime as createTime0_0_, student0_.classesid as classesid0_0_ 
             * from t_student student0_ where student0_.id=?
             * 
             */
            Iterator iter = session.createQuery("from Student").iterate();
            while (iter.hasNext()) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            } 
3. 先采用list后采用iterator
            List students = session.createQuery("from Student").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            System.out.println("-----------------------------------------------------");
            /**
             * 避免了N+1问题
             * 
             * 因为执行list操作后会将数据放到session的缓存中（一级缓存），所以采用iterate的时候
             * 首先会发出一条查询id列表的语句，再根据id到缓存中加载相应的数据，如果缓存中存在与之匹配的数据
             * 则不再发出根据id查询的sql语句，直接使用缓存中的数据
             * 
             * Iterate方法如果缓存中存在数据，它可以提高性能，否则出现N+1问题
             * 
             */
            Iterator iter = session.createQuery("from Student").iterate();
            while (iter.hasNext()) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
4. 两次都采用list
            List students = session.createQuery("from Student").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            System.out.println("-----------------------------------------------------");
            
            /**
             * 再此发出查询语句
             * 
             * 在默认情况下，每次执行list查询实体对象都会发出查询语句，除非配置了查询缓存
             * 虽然一级缓存中存在Student数据，但list不用，所以仍然发出查询语句，
             * 
             * 其实list就是只向缓存中放入数据，而不利用缓存中的数据
             */
            students = session.createQuery("from Student").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }

    三、原生SQL查询

        //直接写表名进行查询
        List students = session.createSQLQuery("select * from t_student").list();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Object[] obj = (Object[])iter.next();
                System.out.println(obj[0] + ", " + obj[1]);
            }

    【总结】

    如果项目采用Hibernate框架，最好的查询语言无疑是HQL。直接接触的HQL只是觉得和SQL差不多，并没有细致地分析各种查询方式。所以，通过本篇博客的简单属性查询、实体对象查询和熟悉的原生SQL查询，对HQL的应用更加深刻了。下篇博客会继续分析其它重要的查询。