day36 05-Hibernate检索方式：离线条件查询

图二 离线条件查询

Struts 2是web层的框架。session得在dao层才有。有的时候这些数据是没在你的对象里面的。像是否上传简历。这个字段不在我的数据库里面。例如是否上传简历这个条件不在我们的数据库里面。你只是通过你的数据库里面的某个字段判断它是否为空而已。假设这几个字段都没在你的对象(User)里面,你得在web层把这些数据都通过通拿到。假设我的高级查询里面字段特别多呢,传起来特别麻烦。你传统方式只能这样去调用了。

咱们的Criteria得session的session.createCriteria()才能创建它啊。在web层就可以拿到一个离线的Criteria。我这个dao里面有这个session对象，所以离线的条件查询就是为了做这种的。有些数据是没有办法封装的,你可以直接在web层把这些数据封装到传到dao层调用session的方法去执行。

package cn.itcast.test;

import java.util.Arrays;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import cn.itcast.utils.HibernateUtils;
import cn.itcast.vo.Customer;
import cn.itcast.vo.Order;

/**
 * Hibernate的检索方式
 * @author zhongzh
 *
 */
public class HibernateDemo1 {
    @Test
    /*
     * 离线条件查询
     * 
     */
    public void demo15(){
        //web层的封装
        DetachedCriteria criteria = DetachedCriteria.forClass(Customer.class);
        criteria.add(Restrictions.eq("cname", "小明"));
        criteria.add(Restrictions.eq("cid", 2));
        

        //传递到DAO层
        Session session = HibernateUtils.openSession();
        Transaction tx=                  session.beginTransaction();
        Criteria c1 = criteria.getExecutableCriteria(session);
        List<Customer> list = c1.list();//不用在DAO层去设置这些条件 直接在这儿就拿到一个对象
        System.out.println(list);
        
        tx.commit();
        session.close();
    }
    @Test
    /*
     * 命名查询
     * 
     */
    public void demo14(){
        Session session = HibernateUtils.openSession();
        Transaction   tx  =  session.beginTransaction();
        List<Customer> list = session.getNamedQuery("findAll").list();//带有名称的query接口
        System.out.println(list);
        tx.commit();
        session.close();
    }
    
    @Test
    /*
     * 聚集函数:
     * 
     */

    public void demo13(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        
        Long count = (Long) session.createQuery("select count(*) from Order").uniqueResult();
        System.out.println(count);
        /*Query query =  session.createQuery("select count(*) from Order");
        List<Integer>  list = query.list();
        System.out.println(list);
        List<Long>  list = query.list();
        for (Long long1 : list) {
            System.out.println(long1);
        }*/
        tx.commit();
        session.close();
    }
    @Test
    /*
     * 
     * 多表查询:
     * 
     */
    public void demo12(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        //内连接查询的是两个表的交集部分:
        Query query = session.createQuery("from Customer c inner join c.orders");//Query接口
        //List list  = query.list();
        //Query query = session.createQuery("from Customer c inner join c.orders");//Query接口
        //Query query = session.createQuery("from Order o inner join o.customer");//Query接口
        //Query query = session.createQuery("select distinct c from Customer c inner join c.orders");//Query接口
        //Query query = session.createQuery("select distinct o from Order o inner join o.customer");//Query接口
        List<Object[]> list  = query.list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        // 迫切内连接:使用一个关键字 fetch(HQL)
        //Query query = session.createQuery("from Customer c  inner join fetch c.orders");//Query接口
        //List list  = query.list();
                //Query query = session.createQuery("from Customer c  inner join fetch c.orders");//Query接口
                //Query query = session.createQuery("select distinct c from Customer c  inner join fetch c.orders");//Query接口
        //Query query = session.createQuery("from Order o  inner join fetch o.customer");//Query接口
        //Query query = session.createQuery("select distinct o from Order o  inner join fetch o.customer");//Query接口
              
/*        List<Customer> list  = query.list();
        for (Customer customer : list) {//关联查询的时候会得到多少条记录?
            System.out.println(customer);//两个表的关联查询,内连接查询会得到30条记录
            //为什么会有重复的数据？因为这是封装的问题
        }*/
/*        List<Order> list = query.list();
        for (Order order : list) {
            System.out.println(order);
        }*/
        
        tx.commit();
        session.close();
    }
    
    
    @Test
    /*模糊查询
     * 
     * 
     */
    public void demo11(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        
        //HQL
/*        Query query= session.createQuery("from Customer where cname like ?");
        query.setParameter(0, "小%");
        List<Customer> list = query.list();
        System.out.println(list);*/
    
        
        //QBC:
        Criteria criteria = session.createCriteria(Customer.class);
        //criteria.add(Restrictions.ilike("cname", "小%"));
        criteria.add(Restrictions.ilike("cname", "大%"));
        List<Customer> list = criteria.list();
        System.out.println(list);
        
        
        tx.commit();
        session.close();
        
    }
    
    
    @Test
    /*
     * in like is null....
     * QBC条件查询
     * 
     */
    public void demo10(){
        Session session= HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        //类似于这种条件查询用?号进行绑定的你都可以用QBC进行替换
        //QBC如何替换?QBC进行条件检索
        
        /*List<Customer> list = session.createCriteria(Customer.class).add(Restrictions.eq("cname", "小明")).list();
        System.out.println(list);//这是绑定一个条件的
        */
        
        List<Customer> list = session.createCriteria(Customer.class)
                .add(Restrictions.eq("cname", "小明")).add(Restrictions.eq("cid", 2)).list();
        System.out.println(list);//这是绑定多个条件的
        
        
        
        tx.commit();
        session.close();
    }
    
    
    @Test
    /*
     * 
     * 投影操作:查询对象的某几个属性
     */
    public void demo9(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        
        //查询客户的名称:
    /*    List list = session.createQuery("select c.cname from Customer c").list();
        System.out.println(list);*/
    /*    List<Object[]> list = session.createQuery("select c.cid,c.cname from Customer c").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        System.out.println(list);*/
        
        List<Customer> list = session.createQuery("select new Customer(cname) from Customer").list();
        //可以用这种类似于我们对象的这种构造的形式来进行查询 类似于对象构造的形式来进行查询
        System.out.println(list);
        tx.commit();
        session.close();
    }
    @Test
    /*
     * 
     * 绑定参数
     */
    public void demo8(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        
        //HQL的参数绑定
        //1.使用?号方式绑定
    /*    Query query = session.createQuery("from Customer where cname = ?");
        query.setString(0, "小沈");
        List<Customer> list = query.list();
        //query.uniqueResult();
        System.out.println(list);*/
    
        /*Query query = session.createQuery("from Customer where cname = ? and cid=?");
        query.setString(0, "小沈");//0是第一个?号 第一个?号的值是小沈
        query.setInteger(1, 3);//1是第二个?号  第二个?号的值是3
        List<Customer> list = query.list();
        System.out.println(list);*/
        
        //2.使用名称的方式绑定
        /*Query query = session.createQuery("from Customer where cname=:name and cid=:id");//返回的是一个Query接口
        query.setString("name", "小沈");
        query.setInteger("id", 3);
        query.setParameter("name", "小沈");//setParameter()你不用判断到底是什么类型 了
        query.setParameter("id", 3);
        List<Customer> list = query.list();
        System.out.println(list);*/
        //查询的时候相当于两表关联,两表关联是通过外键关联的
        Customer customer = new Customer();//
        customer.setCid(1);//1号客户  这里只需要给Customer设置一个id即可
        //持久化对象根据id可以唯一确定这个对象
        //所以它的写法是相当的灵活的
        List<Order> list = session.createQuery("from Order o where o.customer = ?").setEntity(0, customer).list();//设置的是一个实体类Customer
        for (Order order : list) {
            System.out.println(order);
        }
        
        tx.commit();
        session.close();
    }
    @Test
    /*
     * 
     * 
     */
    public void demo7(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        //HQL获取单个对象 这里你可以list()也可以uniqueResult() uniqueResult()就拿到了一个结果
        
        /*Customer customer = (Customer) session.createQuery("from Customer where cname = ? ").setString(0, "小明").uniqueResult();
        
        System.out.println(customer);*/
        
        //QBC方式获取单个对象
        //Customer customer = (Customer) session.createCriteria(Customer.class).setMaxResults(1).add(((Criteria) Restrictions.eq("cname", "小明")).uniqueResult();//session.createCriteria(Customer.class)查到所有。从0开始只查一个。
        Customer customer = (Customer) session.createCriteria(Customer.class).add( Restrictions.eq("cname", "小明")).uniqueResult();//session.createCriteria(Customer.class)查到所有。从0开始只查一个。
        //FirstResult是从哪儿开始,你没有设置的话它就默认从0开始。查1个。setMaxResults(1)查一个
        System.out.println(customer);
        tx.commit();
        session.close();
    }
    @Test
    /*
     * 分页查询
     * 
     */
    public void demo6(){
        Session session = HibernateUtils.openSession();
        Transaction tx =  session.beginTransaction();
        
        //1.HQL进行分页
        /*Query query = session.createQuery("from Order");
        //query.setFirstResult(0);
        //query.setMaxResults(10);
        
        query.setFirstResult(10);
        query.setMaxResults(10);
        query.setFirstResult(20);
        query.setMaxResults(10);
        
        
        List<Order> list = query.list();//查询订单的时候把它的客户也关联出来.这种是导航的形式,查询订单的时候把订单所关联的客户信息都打印出来
        for (Order order : list) {
            System.out.println(order);
        }*/
        //2.QBC进行分页
        Criteria criteria = session.createCriteria(Order.class);
/*        criteria.setFirstResult(0);
        criteria.setMaxResults(10);*/
                criteria.setFirstResult(10);
        criteria.setMaxResults(10);
        
          List<Order> list = criteria.list();
          for (Order order : list) {
            System.out.println(order);
        }
        tx.commit();
        session.close();
    }
    @Test
    public void demo5(){
        Session session = HibernateUtils.openSession();
        Transaction tx =  session.beginTransaction();
        //1.使用HQL进行排序
/*        List<Customer> list = session.createQuery("from Customer c order by c.id desc").list();
        
        for(Customer customer : list){
            System.out.println(customer);
        }*/
        
        //2.使用QBC的方式进行排序
        List<Customer> list = session.createCriteria(Customer.class).addOrder(org.hibernate.criterion.Order.desc("id")).list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        
        tx.commit();
        session.close();    
    }
    
   @Test
   /*
    * 
    * 多态检索
    */
   public void demo4(){
       Session session = HibernateUtils.openSession();
       Transaction tx = session.beginTransaction();
       List<Object[]> list = session.createQuery("from java.lang.Object").list();
       //System.out.println(list);
/*       for(Object[] objects:list){
           System.out.println(objects);//在hibernate3核心配置文件里面配置的映射继承自某个类就给它显示出来
       }
       */
       System.out.println(list);//在hibernate3核心配置文件里面配置的映射继承自某个类就给它显示出来
       //正常HQL语句例如之前写的 from Customer c要加上包名from cn.itcast.vo.Customer.但是因为在Customer.hbm.xml
       //中已经配置了包名.所以在这里的HQL语句已经知道是哪个包下面的Customer.
       tx.commit();
       session.close();
   }
    
    
   @Test
   /*
    * 使用别名:
    * 
    */
    public void demo3(){
       Session session = HibernateUtils.openSession();
       Transaction tx = session.beginTransaction();
       
       //使用别名
       //List<Customer> list = session.createQuery("from Customer as c where c.cname = ?").list();
/*       List<Customer> list = session.createQuery("from Customer as c").list();
       System.out.println(list);*/
       
       //使用别名:带参数
/*       List<Customer> list = session.createQuery("from Customer as c where c.cname = ?").setString(0, "小沈").list();
       System.out.println(list);*/
       
       //别名as可以省略
/*              List<Customer> list = session.createQuery("from Customer  c").list();
              System.out.println(list);*/
      //不支持 select * from Customer写法.可以写成select 别名  from Customer as 别名;
      //List<Customer> list =  session.createQuery("select * from Customer").list();//createQuery不支持select *的写法,会报语法错误
       List<Customer> list =  session.createQuery("select c from Customer c").list();//createQuery不支持select *的写法,会报语法错误
      
       System.out.println(list);
       tx.commit();
       session.close();
   }
    
@Test
public void demo2(){
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    
    //1.使用HQL查询所有客户信息:
/*    Query query =  session.createQuery("from Customer");//"from Customer"是一个HQL语句。返回一个Query接口
    query.list();
    *
    */
    //session.createQuery("from Customer").setString("", "").list();//HQL支持方法链编程
/*    List<Customer> list = session.createQuery("from Customer").list();//HQL支持方法链编程
    for(Customer customer:list){
        System.out.println(customer);
    }*/
    
    //2.使用QBC的方式查询所有记录:
/*    List<Customer>  list=  session.createCriteria(Customer.class).list();//返回Criteria接口
    for (Customer customer:list){
        System.out.println(customer);
    }*/
    
    //3.使用SQL语句查询所有记录:
/*    List<Object[]> list = session.createSQLQuery("select * from customer").list();//这里要写SQL语句 这里操作的是数据库表
    //但是HQL和QBC方式操作的都是对象  这种SQL查询的方式得到的List集合不会直接装到实体对象里面。而是放到Object数组中。
    for(Object[] objects:list){
        System.out.println(Arrays.toString(objects));//把Object数组打印一下
    }*/
    //4.使用SQL语句查询所有记录:封装到实体对象中
    List<Customer> list = session.createSQLQuery("select * from customer").addEntity(Customer.class).list();//这里要写SQL语句 这里操作的是数据库表
    //但是HQL和QBC方式操作的都是对象  这种SQL查询的方式得到的List集合不会直接装到实体对象里面。而是放到Object数组中。这也是方法链编程
    for(Customer customer:list){
        System.out.println(customer);//这个时候就是打印出实体对象的方式
    }
    tx.commit();
    session.close();
}
@Test
/*
 * 
 * 初始化数据
 */
public void demo1(){
  Session session = HibernateUtils.openSession();
  Transaction tx = session.beginTransaction();
  
  Customer customer = new Customer();
  //customer.setCname("小金");
  //customer.setCname("小明");
  customer.setCname("小沈");
  
  for(int i=0;i<=10;i++){
      Order order = new Order();
      //order.setAddr("西三旗"+i);
      order.setAddr("山东"+i);
      order.setCustomer(customer);
      
      customer.getOrders().add(order);
  }
  session.save(customer);
  //还需要设置订单,如果不想设置订单那就要配置级联才行
  tx.commit();
  session.close();
}
}

 所以可以用这种离线条件查询做这种高级的查询的方式。

如果是条件特别复杂,建议使用QBC;如果是操作比较简单,那就使用HQL;