Day45 Java框架 Hibernate框架(四)HQL_QBC查询详解--抓取策略优化机制

一.Hibernate的查询方式

  1. 在Hibernate中提供了5种查询方式,
  2. OID检索
     - 1 - 根据对象的OID(主键)进行检索
     - 2 - 使用get , load方法
  3. 对象导航检索
     - 1 - 根据一个已经查询到的对象,获取其关联的对象的一种查询方式
     - 2 - LinkMan linkMan = session.get(LinkMan.class, 1L);
             Customer customer = linkMan.getCustomer();        //这就是对象导航
  4. HQL检索
          Hibernate Query Language , Hibernate的查询语言,是一种面向对象的查询语言,语法类似SQL,
    通过session.createQuery(),用于接收一个HQL进行查询方式.
    1. HQL的简单查询
      Query query  =   session.createQuery("from Customer");   //里边的Customer 是类名
      List list = query.list();
    2. HQL的排序查询
      List list = session.createQuery("from Customer order by cust_id").list();  //默认升序, 也可以用asc
      List list = session.createQuery("from Customer order by cust_id desc").list();  //降序排序 用desc
    3. HQL的条件查询
      一.按位置绑定
                          Query query  =   session.createQuery("from Customer where cust_name = ?");  
                          query.setParameter(0,"张三");       //0是索引,代表第一个问号                   
                          List list = query.list();
      二.按名称绑定
                          Query query  =   session.createQuery("from Customer where cust_name = aaa"); 
                          query.setParameter("aaa","张三");   //aaa是参数名称
                          List list = query.list();  
    4. HQL的投影查询
      一.查单个属性
      List list = session.createQuery("select c.cust_name from Customer c").list(); 
      二.查多个属性
      List list = session.createQuery("select c.cust_name c.cust_source from Customer c").list(); 
      三.查多个属性,且封装到对象中
           首先需要在对象中添加要查询项的构造方法, public Customer(String cust_name , String cust_source){...}
      List list =  session.createQuery("select new Customer(cust_name,cust_source) from Customer").list();
    5. HQL的分页查询
      Query query  =   session.createQuery("from LinkMan");
      query.setFirstResult(0);         //第一页起始索引,   
      query.setMaxResults(10);      //每页十条
      List list = query.list();
    6. HQL的分组统计查询
      // 聚合函数的使用 :  count(), max(), min(), avg(), sum()

      Object object = session.createQuery("select count(*) from Customer").uniqueResult();
    7. HQL的多表查询
      - - 连接查询
      - - - - -交叉连接 :
      - - - - -内连接   :
                     -1-隐式内连接            //封装成数组
                     -2-显式内连接
                     -3-迫切内连接 : 其实就是在普通的内连接inner join后添加一个关键字fetch  //封装成对象
      - - - - -外连接 
                     -1-左外连接
                     -2-右外连接
                     -3-迫切左外连接
    8. QBC检索
            Query By Criteria : 条件查询 , 是一种更加面向对象化的查询的方式
      //   add                            : 普通的条件, where后面条件
      //   addOrder                   : 排序
      //   setProjection              : 聚合函数 和 group by having
      1. QBC的简单查询
        Criteria criteria =   session.createCriteria(Customer.class); 
        List list = criteria.list();
      2. QBC的排序查询
        Criteria criteria = session.createCriteria (Customer.class); 
        criteria.addOrder(Order.asc("cust_id"));  //升序     criteria.addOrder(Order.desc("cust_id"));  //降序
        List list = criteria.list();
      3. QBC的分页查询
        Criteria criteria =   session.createCriteria("from LinkMan");
        criteria .setFirstResult(0);         //第一页起始索引,   
        criteria .setMaxResults(10);      //每页十条
        List list = criteria .list();
      4. QBC的条件查询
        Criteria criteria = session.createCriteria (Customer.class); 
        //  =eq  >gt  >=ge  ne    like  in  and  or
        criteria.add(Restrictions.eq("cust_source" , "某个来源"));  //   参数是属性,属性值
        List list = criteria.list();
      5. QBC的统计查询
        Criteria criteria = session.createCriteria (Customer.class); 
        criteria.setProjection(Projections.rowCount());
        Long num = (Long)criteria.uniqueResult();
      6. 离线条件查询(SSH)  ---DetachedCriteria----离线(脱离session使用)
        DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);
        //设置条件
        dc.add(Restrictions.eq(****));
        service.query(dc);    
        //1. 传到业务层,dao.query(dc)   
        //2.传到持久层 然后绑定session
        Criteria criteria = detachedCriteria.getExecutableCriteria(session);
        List list = criteria.list();
    9. SQL检索
      SQL的多表查询
      - - 连接查询
      - - - - -交叉连接 : 笛卡儿积         select * from A,B
      - - - - -内连接   : inner join (inner 可以省略)
                     -1-隐式内连接  select * from A,B where A.id=B.aid;
                     -2-显式内连接  select * from A inner join B on A.id=B.aid;
      - - - - -外连接  outer join (outer 可以省略)
                     -1-左外连接 select * from A left outer join B on A.id=B.aid;
                     -2-右外连接 right outer join
    10. 二.Hibernate的抓取策略(优化)

      1. 延迟加载 : lazy(懒加载)  .执行到该行代码的时候,不会发送语句去进行查询,在真正使用这个对象的属性的时候才会去发送SQL语句进行查询
      2. 延迟加载的分类
        1. 类级别的延迟加载
          指的是通过load方法查询某个对象的时候,是否采用延迟加载  session.load(Customer.class , 1L);
          类级别延迟加载通过上的lazy进行配置,如果想让lazy失效
                  *  将lazy设置成false
                  *  将持久化类使用final修饰
                  *  Hibernate.initialize(customer);
        2. 关联级别的延迟加载
          指的是在查询到某个对象的时候,查询其关联的对象的时候,是否采用延迟加载
               Customer customer = session.get(Customer.class , 1L);
               customer.getLinkMans();  -----通过客户获得联系人的时候,联系人对象是否采用了延迟加载,称为是关联级别的延迟
          抓取策略往往会和关联级别的延迟加载一起使用,优化语句
      3. 抓取策略 :
        1. 通过一个对象抓取到关联对象需要发送SQL语句,SQL语句如何发送,发送成的格式需要策略去配置
                  *  通过或者上通过fetch属性进行设置
                  *  Fetch和这些标签上的lazy如何设置优化发送的SQL语句
        2. 上的fetch和lazy
                  *  fetch: 抓取策略,控制SQL语句格式
                          - select            : 默认值  ,发送普通的select语句,查询关联对象
                          - join                : 发送一条迫切左外连接查询关联对象
                          - subselect      : 发送一条子查询查询其关联对象
                  *  lazy: 延迟加载,控制查询关联对象的时候是否采用延迟
                          - true               : 默认值  ,查询关联对象的时候,采用延迟加载
                          - false              : 查询关联对象的时候,不采用延迟加载
                          - extra              : 极其懒惰
                  *  在实际开发中,一般都采用默认值 , 如果有特殊需求,可能需要配置join
        3. 上的fetch和lazy
                  *  fetch: 抓取策略,控制SQL语句格式
                          - select            : 默认值  ,发送普通的select语句,查询关联对象
                          - join                : 发送一条迫切左外连接查询关联对象
                  *  lazy: 延迟加载,控制查询关联对象的时候是否采用延迟
                          - proxy               : 默认值  ,proxy具体的取值,取决于另一端的上的lazy值
                          - false                : 查询关联对象的时候,不采用延迟加载
                          - no-proxy          : 不会使用
                  *  在实际开发中,一般都采用默认值 , 如果有特殊需求,可能需要配置join
      4. 批量抓取
        1. 概述: 一批关联对象一起抓取, batch-size
        2. 在Customer的配置文件中,标签设置参数 batch-size="num"         num代表的是要批量抓取的个数

      你可能感兴趣的:(Java框架)