HIbernate查询

一、Oid查询（根据oid主键查询）

    oid查询方式：

　　　1.get()方法：当调用get方法时，它会立即发出sql语句，并且返回的就是实际的对象，和普通查询没有区别，当查不到的时候返回null。

　　　2.load()方法：当调用load时，不是立马发送一个sql语句，而是返回目标对象的代理对象，在这个代理对象中只存储了目标对象的id值，只有调用id值以外的属性值时，才会发出SQL查询语句，当查询不到时，会报错。  

二、对象导航查询

　　HIbernate根据一个已经查到的对象，获得其关联对象的一种查询方式，

三、HQL查询

　　是Hibernate自带的

　　类别：

　　1.简单查询

　　　　　“from 表名"

    @Test
    public void test(){
        /*简单查询*/
        //查询不需要绑定到事务
        Session session = HibernateUtil.openSession();
        Query query = session.createQuery(" from com.ual.domain.user");
        List<user> list = query.list();
        System.out.println(list);
    }

   2.别名查询

　　createQuery(select 别名 from 类名 别名）

  @Test
    public void test(){
    /*别名查询*/
        /*
        * HQL中不支持*的写法
        * createQuery(select 别名 from 类名 别名）
        * */
        Session session = HibernateUtil.openSession();
        Query query = session.createQuery(" select  c from user c");
        List<user> list = query.list();
        System.out.println(list);
    }

3.排序查询

　createQuery("select c from 表名 c order by u_id desc")

    @Test
    public void test(){
   /*排序查询*/
        /*
        * createQuery("select c from 表名 c order by u_id desc")
        * desc 降序，asc升序*/
        Session session = HibernateUtil.openSession();
        Query query = session.createQuery(" select  c from user c order by u_id desc ");
        List<user> list = query.list();
        System.out.println(list);
    }

4.条件查询

　　4.1 位置绑定：根据参数的位置进行绑定（现在不用）

　　4.2别名绑定：把参数对应的值起一个名称，再设定名称的值

　　from 表名 where 属性名=：别名

 @Test
    public void test2(){
         /*条件查询*/
        Session session = HibernateUtil.openSession();
        Query query = session.createQuery("from user where u_name=:uname");//为参数起一个别名
        query.setParameter("uname","user1");//在别名中设置值
        List<user> list = query.list();
        System.out.println(list);

    }

5.投影查询

　　查询对象的某个或某些属性

　　1.单个属性：

　　2.多个属性：

　　3.查询多个属性，封装到对象中（要在类中提供构造器）

  @Test
    public void test3(){
        //投影查询，查询单个属性
        Session session = HibernateUtil.openSession();
        List<Object> list = session.createQuery("select  c.u_name from  user c").list();//返回的集合中装的是Object对象
        System.out.println(list);
        System.out.println("----------------------------");
        //投影查询，查询多个属性
        List<Object[]> list1 = session.createQuery("select c.id,c.u_name from user c").list();//返回的集合中装的的Object数组
        for (Object[] objects : list1) {
            for(int i=0;i<objects.length;i++){
                System.out.println(objects[i]);
            }
        }
        System.out.println("-------------------------");
        //投影查询，把查询到的结果封装成对象,需要在domain类中加入带参构造器，同时不要忘了加上其无参构造器
        List<user> list2 = session.createQuery("select new user(u_id,u_name) from user c").list();
        System.out.println(list2);
    }

6.分页查询

　　

    @Test
    public void test4(){
        //分页查询
        Session session = HibernateUtil.openSession();
        Query query = session.createQuery("from user");
        query.setFirstResult(0);//设置开始角标,角标是从0开始的
        query.setMaxResults(2);//查询多少条
        List<user> list = query.list();
        System.out.println(list);

    }

7.统计查询

　　1.查询的结果只有一个

　　　　

 @Test
    public void test5(){
        /*查询所有的记录数*/
        Session session = HibernateUtil.openSession();
        Query query = session.createQuery("select  count(*) from user ");
        Object o = query.uniqueResult();//这里查出来的是单一的值，不用list，用uniqueResult
        System.out.println(o);
    }

8.分组查询

    @Test
    public void test6(){
        /*分组查询*/
        Session session = HibernateUtil.openSession();
        Query query = session.createQuery("select u_name,count (*) from  user group by  u_name");
        List<Object[]> list = query.list();//因为查出来的是两个字段，所以是list中存的是Object 数组
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
    }

9.多表查询

　　普通连接：

    @Test
    public void test7(){
        /*连接查询*/
        Session session = HibernateUtil.openSession();
        List<Object[]> list = session.createQuery("from user c inner join c.roles").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
    }

　　迫切连接：

  @Test
    public void test8(){
        /*迫切连接,会自动封装成对象*/
        Session session = HibernateUtil.openSession();
        List<user> list = session.createQuery("from user c inner  join fetch  c.roles").list();//返回的是user对象，而不是数组
        for (user user : list) {
            System.out.println(user);
        }

    }

四、QBC查询（Query By  Criteria)

　　是一种更加面向对象化的查询方式，多用于条件查询。

　　1.普通查询

　　

     @Test
    public void test(){
            Session session = HibernateUtil.openSession();
            Criteria criteria = session.createCriteria(user.class);
            List<user> list = criteria.list();
            System.out.println(list);

        }

2.可对查询结果添加排序

//添加排序

criteria.addOrder(Order.desc("u_id"));

3.设置分页

    //设置分页
            criteria.setFirstResult(0);
            criteria.setMaxResults(2);

4.条件查询

　　= ：eq

　　>：gt

　　>=：ge

　　<：lt

　　<=：le

　　<>：ne

　　like 

　　in

　　and

　　or

多条件就是多加几个add

     @Test
    public void test2(){
            Session session = HibernateUtil.openSession();
            Criteria criteria = session.createCriteria(user.class);
            criteria.add(Restrictions.eq("u_name","user1"));//添加查询条件，u_name="user1"
            List<user> list = criteria.list();
            System.out.println(list);
        }

多条件查询

　　

     @Test
    public void test2(){
            Session session = HibernateUtil.openSession();
            Criteria criteria = session.createCriteria(user.class);
          //  criteria.add(Restrictions.eq("u_name","user1"));//添加查询条件，u_name="user1"
            criteria.add(Restrictions.like("u_name","%1"));
            List<user> list = criteria.list();
            System.out.println(list);
        }

5.统计查询(聚合函数）

　　

        @Test
    public void test3(){
            Session session = HibernateUtil.openSession();
            Criteria criteria = session.createCriteria(user.class);
            criteria.setProjection(Projections.rowCount());//设置要查询的条件,即聚合函数
            //执行查询
            Object o = criteria.uniqueResult();
            System.out.println(o);
        }

6.离线条件查询

　　　　指脱离session，添加条件。可以在外部提前使用DetachedCriteria对象提前设置好条件，最后再绑定到session。

　　　　条件可以在任意层写

       @Test
    public void test4(){
            /*离线条件查询*/
            DetachedCriteria detachedCriteria = DetachedCriteria.forClass(user.class);//获取离线条件对象
            //设置条件
            detachedCriteria.add(Restrictions.like("u_name","%2"));
            /*以上部分一般不写在dao层，由参数传入*/
            Session session = HibernateUtil.openSession();
            Criteria criteria = detachedCriteria.getExecutableCriteria(session);//获得criteria对象
            List<user> list = criteria.list();
            for (user user : list) {
                System.out.println(user);
            }

        }