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

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 + "]";//客户这里去掉订单集合的打印

    }

}