Hibernate各种查询方式及查询策略

在了解Hibernate的基本知识后，重点让我们看下相关查询方式和查询优化策略吧！
话不多说，先来张思维导图看下：

1.一对多情况

*以实例呈现：

如下：

1. JavaWEB中一对多的设计及其建表原则

2. 先导入SQL的建表语句

* 创建今天的数据库：create database hibernate_day03;
* 在资料中找到客户和联系人的SQL脚本

3. 编写客户和联系人的JavaBean程序（注意一对多的编写规则）

*客户的JavaBean如下:

public class Customer {
            private Long cust_id;
            private String cust_name;
            private Long cust_user_id;
            private Long cust_create_id;
            private String cust_source;
            private String cust_industry;
            private String cust_level;
            private String cust_linkman;
            private String cust_phone;
            private String cust_mobile;

            private Set linkmans = new HashSet();

        }

*联系人的JavaBean如下:

public class Linkman {
            private Long lkm_id;
            private String lkm_name;
            private String lkm_gender;
            private String lkm_phone;
            private String lkm_mobile;
            private String lkm_email;
            private String lkm_qq;
            private String lkm_position;
            private String lkm_memo;

            private Customer customer;

        }

4. 编写客户和联系人的映射配置文件（注意一对多的配置编写）

* 客户的映射配置文件如下

<class name="com.itheima.domain.Customer" table="cst_customer">
            <id name="cust_id" column="cust_id">
                class="native"/>
            id>
            <property name="cust_name" column="cust_name"/>
            <property name="cust_user_id" column="cust_user_id"/>
            <property name="cust_create_id" column="cust_create_id"/>
            <property name="cust_source" column="cust_source"/>
            <property name="cust_industry" column="cust_industry"/>
            <property name="cust_level" column="cust_level"/>
            <property name="cust_linkman" column="cust_linkman"/>
            <property name="cust_phone" column="cust_phone"/>
            <property name="cust_mobile" column="cust_mobile"/>

            <set name="linkmans">
                "lkm_cust_id"/>
                to-many class="com.itheima.domain.Linkman"/>
            set>
        class>

联系人的映射配置文件如下:

<class name="com.itheima.domain.Linkman" table="cst_linkman">
            <id name="lkm_id" column="lkm_id">
                class="native"/>
            id>
            <property name="lkm_name" column="lkm_name"/>
            <property name="lkm_gender" column="lkm_gender"/>
            <property name="lkm_phone" column="lkm_phone"/>
            <property name="lkm_mobile" column="lkm_mobile"/>
            <property name="lkm_email" column="lkm_email"/>
            <property name="lkm_qq" column="lkm_qq"/>
            <property name="lkm_position" column="lkm_position"/>
            <property name="lkm_memo" column="lkm_memo"/>

            to-one name="customer" class="com.itheima.domain.Customer" column="lkm_cust_id"/>
        class>

*级联保存操作

** 1. 测试：如果现在代码只插入其中的一方的数据

* 如果只保存其中的一方的数据，那么程序会抛出异常。
* 如果想完成只保存一方的数据，并且把相关联的数据都保存到数据库中，那么需要配置级联！！

* 级联保存是方向性

** 2. 级联保存效果

* 级联保存：保存一方同时可以把关联的对象也保存到数据库中！！
* 使用cascade="save-update"

*级联删除操作

在数据库中演示含有外键的删除客户功能，那么SQL语句是会报出错误的
* 例如：delete from customers where cid = 1;如果使用Hibernate框架直接删除客户的时候，测试发现是可以删除的，这是简单地删除操作，而还有另一种删除，即级联删除，* ，这也是具有方向性的，但是需要慎用！

* cascade的用法

取值如下：
* none – 不使用级联
* save-update – 级联保存或更新
* delete – 级联删除
* delete-orphan – 孤儿删除.(注意：只能应用在一对多关系)
* all – 除了delete-orphan的所有情况.（包含save-update delete）
* all-delete-orphan – 包含了delete-orphan的所有情况.（包含save-update delete delete-orphan）
注意的是，孤儿删除（孤子删除），只有在一对多的环境下才有孤儿删除：
* 在一对多的关系中,可以将一的一方认为是父方.将多的一方认为是子方.孤儿删除:在解除了父子关系的时候.将子方记录就直接删除。
*

* 外键的放弃

如果双方都维护外键的时候，会产生多余的SQL语句。产生的原因：session的一级缓存中的快照机制，会让双方都更新数据库，产生了多余的SQL语句。如果不想产生多余的SQL语句，那么需要一方来放弃外键的维护！
* 在标签上配置一个inverse=”true”.true:放弃.false:不放弃.默认值是false
*

2.多对多情况

* 实例展示

1. 编写用户和角色的JavaBean

//用户的JavaBean代码如下:
     public class User {
            private Long user_id;
            private String user_code;
            private String user_name;
            private String user_password;
            private String user_state;

            private Set roles = new HashSet();
        }
     //角色的JavaBean代码如下
        public class Role {
            private Long role_id;
            private String role_name;
            private String role_memo;

            private Set users = new HashSet();
        }

2. 用户和角色的映射配置文件如下:

 * 用户的映射配置文件如下:
        <class name="com.itheima.domain.User" table="sys_user">
            <id name="user_id" column="user_id">
                class="native"/>
            id>
            <property name="user_code" column="user_code"/>
            <property name="user_name" column="user_name"/>
            <property name="user_password" column="user_password"/>
            <property name="user_state" column="user_state"/>

            <set name="roles" table="sys_user_role">
                "user_id"/>
                to-many class="com.itheima.domain.Role" column="role_id"/>
            set>
        class>

 * 角色的映射配置文件如下
        <class name="com.itheima.domain.Role" table="sys_role">
            <id name="role_id" column="role_id">
                class="native"/>
            id>
            <property name="role_name" column="role_name"/>
            <property name="role_memo" column="role_memo"/>

            <set name="users" table="sys_user_role">
                "role_id"/>
                to-many class="com.itheima.domain.User" column="user_id"/>
            set>
        class>

3. 多对多进行双向关联的时候:必须有一方去放弃外键维护权

* 级联保存

* <set cascade="save-update">

* 双方必须有一方放弃对外键的维护

 "true">

3.查询方式

*通过OID方式查询

 * session.get(对象.class,OID)
 * session.load(对象.class,OID)

注意：load具有延迟缓存的效果！

*对象的导航的方式

* HQL的检索方式（ Hibernate Query Language）

1. HQL的介绍

* HQL(Hibernate Query Language) 是面向对象的查询语言, 它和 SQL 查询语言有些相似
* 在 Hibernate 提供的各种检索方式中, HQL 是使用最广的一种检索方式

2. HQL与SQL的关系

* HQL 查询语句是面向对象的,Hibernate负责解析HQL查询语句, 然后根据对象-关系映射文件中的映射信息, 把 HQL 查询语句翻译成相应的 SQL 语句. 
* HQL 查询语句中的主体是域模型中的类及类的属性
* SQL 查询语句是与关系数据库绑定在一起的. SQL查询语句中的主体是数据库表及表的字段

3.一些基本查询实例

1.HQL基本的查询格式
* 支持方法链的编程，即直接调用list()方法
* 简单的代码如下
* session.createQuery(“from Customer”).list();

1. 使用别名的方式

   • 可以使用别名的方式
     
     • session.createQuery(“from Customer c”).list();
     • session.createQuery(“select c from Customer c”).list();

2. 排序查询

   • 排序查询和SQL语句中的排序的语法是一样的

     • 升序

       • session.createQuery(“from Customer order by cust_id”).list();

     • 降序

       • session.createQuery(“from Customer order by cust_id desc”).list();

3. 分页查询

   • Hibernate框架提供了分页的方法，咱们可以调用方法来完成分页

   • 两个方法如下

     • setFirstResult(a) – 从哪条记录开始，如果查询是从第一条开启，值是0
     • setMaxResults(b) – 每页查询的记录条数

   • 演示代码如下

     • List list = session.createQuery(“from LinkMan”).setFirstResult(0).setMaxResults().list();

4. 带条件的查询

   • setParameter(“?号的位置，默认从0开始”,”参数的值”); 不用考虑参数的具体类型
   • 按位置绑定参数的条件查询（指定下标值，默认从0开始）
   • 按名称绑定参数的条件查询（HQL语句中的 ? 号换成 :名称 的方式）

 //例如代码如下:
        Query query = session.createQuery("from Linkman where lkm_name like ? order by lkm_id desc");
        query.setFirstResult(0).setMaxResults(3);
        query.setParameter(0, "%熊%");
        List list = query.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }

6.聚合查询
例如：

// 获取总的记录数
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List list = session.createQuery("select count(c) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

// 获取某一列数据的和
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List list = session.createQuery("select sum(c.cust_id) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

7.投影查询
* 如果查询多个字段，例如下面这种方式

List list = session.createQuery("select c.cust_name,c.cust_level from Customer c").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }

* 如果查询两个字段，也可以把这两个字段封装到对象中
    * 先在持久化类中提供对应字段的构造方法
    * 使用下面这种HQL语句的方式

List list = session.createQuery("select new Customer(c.cust_name,c.cust_level) from Customer c").list();
            for (Customer customer : list) {
                System.out.println(customer);
            }

8.HQL多表查询
1. 多表的查询进来使用HQL语句进行查询，HQL语句和SQL语句的查询语法比较类似。
* 内连接查询
* 显示内连接
* select * from customers c inner join orders o on c.cid = o.cno;
* 隐式内连接
* select * from customers c,orders o where c.cid = o.cno;

* 外连接查询
    * 左外连接
        * select * from customers c left join orders o on c.cid = o.cno;
    * 右外连接
        * select * from customers c right join orders o on c.cid = o.cno;

1. HQL的多表查询

   • 迫切和非迫切：
     
     • 非迫切返回结果是Object[]
     • 迫切连接返回的结果是对象，把客户的信息封装到客户的对象中，把订单的信息封装到客户的Set集合中。

2. 内连接查询

   • 内连接使用 inner join ，默认返回的是Object数组

Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List list = session.createQuery("from Customer c inner join c.linkmans").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        tr.commit();

* 迫切内连接:inner join fetch ，返回的是实体对象
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List list = session.createQuery("from Customer c inner join fetch c.linkmans").list();
    Set set = new HashSet(list);
    for (Customer customer : set) {
        System.out.println(customer);
    }
    tr.commit();

1. 左外连接查询

   • 左外连接: 封装成List

Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List list = session.createQuery("from Customer c left join fetch c.linkmans").list();
        Set set = new HashSet(list);
        for (Customer customer : set) {
            System.out.println(customer);
        }
        tr.commit();

* QBC的检索方式——Query By Criteria – 条件查询

1. 简单查询，使用的是Criteria接口

List list = session.createCriteria(Customer.class).list();
    for (Customer customer : list) {
        System.out.println(customer);
    }

1. 排序查询
   
   • 需要使用addOrder()的方法来设置参数，参数使用org.hibernate.criterion.Order对象

* 具体代码如下：
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 设置排序
        criteria.addOrder(Order.desc("lkm_id"));
        List list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

1. 分页查询
   
   • QBC的分页查询也是使用两个方法
     
     • setFirstResult();
     • setMaxResults();

* 代码如下;
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 设置排序
        criteria.addOrder(Order.desc("lkm_id"));
        criteria.setFirstResult(0);
        criteria.setMaxResults(3);
        List list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

1. 条件查询（Criterion是查询条件的接口，Restrictions类是Hibernate框架提供的工具类，使用该工具类来设置查询条件）
   
   • 条件查询使用Criteria接口的add方法，用来传入条件。
   • 使用Restrictions的添加条件的方法，来添加条件，例如：
     
     • Restrictions.eq – 相等
     • Restrictions.gt – 大于号
     • Restrictions.ge – 大于等于
     • Restrictions.lt – 小于
     • Restrictions.le – 小于等于
     • Restrictions.between – 在之间
     • Restrictions.like – 模糊查询
     • Restrictions.in – 范围
     • Restrictions.and – 并且
     • Restrictions.or – 或者

* 测试代码如下
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 设置排序
        criteria.addOrder(Order.desc("lkm_id"));
        // 设置查询条件
        criteria.add(Restrictions.or(Restrictions.eq("lkm_gender", "男"), Restrictions.gt("lkm_id", 3L)));
        List list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

* 聚合函数查询（Projection的聚合函数的接口，而Projections是Hibernate提供的工具类，使用该工具类设置聚合函数查询）

* 使用QBC的聚合函数查询，需要使用criteria.setProjection()方法
* 具体的代码如下
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    Criteria criteria = session.createCriteria(Linkman.class);
    criteria.setProjection(Projections.rowCount());
    List list = criteria.list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit(); 

*离线查询

1. 离线条件查询使用的是DetachedCriteria接口进行查询，离线条件查询对象在创建的时候，不需要使用Session对象，只是在查询的时候使用Session对象即可。

2. 创建离线条件查询对象

   • DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);

3. 具体的代码如下

Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
    // 设置查询条件
    criteria.add(Restrictions.eq("lkm_gender", "男"));
    // 查询数据
    List list = criteria.getExecutableCriteria(session).list();
    for (Linkman linkman : list) {
        System.out.println(linkman);
    }
    tr.commit();

* SQL检索方式（了解）

* 本地的SQL检索
例如：

 Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    SQLQuery sqlQuery = session.createSQLQuery("select * from cst_linkman where lkm_gender = ?");
    sqlQuery.setParameter(0,"男");
    sqlQuery.addEntity(Linkman.class);
    List list = sqlQuery.list();
    System.out.println(list);
    tr.commit();

4.查询优化策略

*延迟加载

1. 延迟加载先获取到代理对象，当真正使用到该对象中的属性的时候，才会发送SQL语句，是Hibernate框架提升性能的方式

2. 类级别的延迟加载

* Session对象的load方法默认就是延迟加载
* Customer c = session.load(Customer.class, 1L);没有发送SQL语句，当使用该对象的属性时，才发送SQL语句.

* 使类级别的延迟加载失效
** 在标签上配置lazy=”false”
** Hibernate.initialize(Object proxy);

3. 关联级别的延迟加载（查询某个客户，当查看该客户下的所有联系人是是否是延迟加载）

!!!默认是延迟加载………

Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Customer c = session.get(Customer.class, 1L);
        System.out.println("=============");
        System.out.println(c.getLinkmans().size());
        tr.commit();

*Hibernate框架查询策略

1. 查询策略：使用Hibernate查询一个对象的时候，查询其关联对象.应该如何查询.是Hibernate的一种优化手段!!!

2. Hibernate框架的检索策略解决的问题

• 查询的时机

Customer c1 = (Customer) session.get(Customer.class, 1);
        System.out.println(c1.getLinkmans().size());

• lazy属性解决查询的时机的问题，需要配置是否采用延迟加载！！

• 查询的语句形式

List list = session.createQuery("from Customer").list();
        for(Customer c : list){
            System.out.println(c.getLinkmans());
        }

• fetch属性就可以解决查询语句的形式的问题！！

*Set标签上配置策略

1. 在标签上使用fetch和lazy属性

• fetch的取值 – 控制SQL语句生成的格式

  • select – 默认值.发送查询语句
  • join – 连接查询.发送的是一条迫切左外连接!!!配置了join.lazy就失效了
  • subselect – 子查询.发送一条子查询查询其关联对象.(需要使用list()方法进行测试)

• lazy的取值 – 查找关联对象的时候是否采用延迟!

  • true – 默认.延迟
  • false – 不延迟
  • extra – 及其懒惰

2. set标签上的默认值是fetch=”select”和lazy=”true”

3. 总结：Hibernate框架都采用了默认值，开发中基本上使用的都是默认值。特殊的情况。

*many-to-one标签上配置策略

1. 在标签上使用fetch和lazy属性

• fetch的取值 – 控制SQL的格式.

  • select – 默认。发送基本select语句查询
  • join – 发送迫切左外连接查询

• lazy的取值 – 控制加载关联对象是否采用延迟.

  • false – 不采用延迟加载.
  • proxy – 默认值.代理.现在是否采用延迟.
    
    • 由另一端的上的lazy确定.如果这端的class上的lazy=”true”.proxy的值就是true(延迟加载).
    • 如果class上lazy=”false”.proxy的值就是false(不采用延迟.)

2. 在标签上的默认值是fetch=”select”和proxy。