day36 03-Hibernate检索方式：排序、参数绑定、投影查询

---

排序之后是分页查询。

---

检索单个对象

---

还可以进行参数的绑定。

HQL的参数绑定,按参数名称绑定或者是按参数位置绑定。

---

还可以用投影的操作,投影的操作是只查询这里面的某几个属性。只查询某一个属性,查询多个属性,查询完以后还把这些属性装到一个实体类对象里面那你就用投影这种形式。

---

---

---

模糊查询

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.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 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();
}
}

package cn.itcast.vo;

import java.util.HashSet;
import java.util.Set;

/**
 * 客户的实体:
 * @author 姜涛
 *
 */
public class Customer {
    private Integer cid;
    private String cname;

    public Customer() {//无参构造函数
        super();
        // TODO Auto-generated constructor stub
    }

    public Customer(String cname) {//有参构造
        super();
        this.cname = cname;
    }

    // 一个客户有多个订单.
    private Set<Order> orders = new HashSet<Order>();
    public Integer getCid() {
        return cid;
    }
    public void setCid(Integer cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    @Override
    public String toString() {//客户这里打印也打印出订单的集合。这是死循环了，所以这里应该去掉一方的打印。
    /*    return "Customer [cid=" + cid + ", cname=" + cname + ", orders="
                + orders + "]";*/
            return "Customer [cid=" + cid + ", cname=" + cname + "]";//客户这里去掉订单集合的打印

    }

}