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<Customer> list = query.list();
   2. HQL的排序查询
      List<Customer> list = session.createQuery("from Customer order by cust_id").list();  //默认升序, 也可以用asc
      List<Customer> 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<Customer> list = query.list();
      二.按名称绑定
                          Query query  =   session.createQuery("from Customer where cust_name = aaa"); 
                          query.setParameter("aaa","张三");   //aaa是参数名称
                          List<Customer> list = query.list();  
   4. HQL的投影查询
      一.查单个属性
      List<Object> list = session.createQuery("select c.cust_name from Customer c").list(); 
      二.查多个属性
      List<Object[ ]> list = session.createQuery("select c.cust_name c.cust_source from Customer c").list(); 
      三.查多个属性,且封装到对象中
           首先需要在对象中添加要查询项的构造方法, public Customer(String cust_name , String cust_source){...}
      List<Customer> 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<LinkMan> 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-迫切左外连接
5. QBC检索
         Query By Criteria : 条件查询 , 是一种更加面向对象化的查询的方式
   //   add                            : 普通的条件, where后面条件
   //   addOrder                   : 排序
   //   setProjection              : 聚合函数 和 group by having
   1. QBC的简单查询
      Criteria criteria =   session.createCriteria(Customer.class); 
      List<Customer> list = criteria.list();
   2. QBC的排序查询
      Criteria criteria = session.createCriteria (Customer.class); 
      criteria.addOrder(Order.asc("cust_id"));  //升序     criteria.addOrder(Order.desc("cust_id"));  //降序
      List<Customer> list = criteria.list();
   3. QBC的分页查询
      Criteria criteria =   session.createCriteria("from LinkMan");
      criteria .setFirstResult(0);         //第一页起始索引,   
      criteria .setMaxResults(10);      //每页十条
      List<LinkMan> list = criteria .list();
   4. QBC的条件查询
      Criteria criteria = session.createCriteria (Customer.class); 
      //  =eq  >gt  >=ge  <lt  <=le  <>ne    like  in  and  or
      criteria.add(Restrictions.eq("cust_source" , "某个来源"));  //   参数是属性,属性值
      List<Customer> 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<Customer> list = criteria.list();
6. 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

二.Hibernate的抓取策略(优化)

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