Query对象

　　　　方便的对数据库和持久化对象进行查询，两种表达方式：HQL和SQL;

　　　　Query经常用来绑定查询参数，限制查询条数。并最终执行查询语句。

HQL

查询一个简单类（查询所有）

@Test //修改方法
    public void test3(){
        Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
        // 操作
        Query query = session.createQuery("from User");
        List list = query.list();
        System.out.println(list);
        //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
        //configuration相当于连接池
        session.close();
    }

　分页查询

@Test //修改方法
public void test3(){
    Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
    // 操作
    Query query = session.createQuery("from User");
    query.setFirstResult(0);//设置开始的位置
    query.setMaxResults(10);//设置查询多少条
    List list = query.list();
    for (Object object : list) {
        System.out.println(object);
    }
    //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
    //configuration相当于连接池
    session.close();
}

　查看指定列

　　@Test //查询指定列
public void test4(){
    Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
    // 操作
    //查询指定列时,必须在javabean中提供该字段的构造方法  其他列为空
    Query query = session.createQuery("select new User(username,password) from User");
    List<User> list = query.list();
    for (User u : list) {
        System.out.println(u);
    }
    //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
    //configuration相当于连接池
    session.close();
}

条件查询

@Test //条件查询(无名称参数)
    public void test5(){
        Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
        // 操作
        //查询指定列时,必须在javabean中提供默认的构造方法（无参构造）  
        //因为有参会替换无参  然而在条件查询时会调用无参构造
        /*条件查询(无名称参数)
         * Query query = session.createQuery("from User where username=?");
        query.setParameter(0, "zhangsan111");*/
        //条件查询(有名称参数)
        Query query = session.createQuery("from User where username=:myusername");
        query.setParameter("myusername", "zhangsan111");
        User user = (User) query.uniqueResult();
        System.out.println(user);
        //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
        //configuration相当于连接池
        session.close();
    }

　命名查询

在customer.hbm.xml中class标签外定义一个<query>标签

<query name="select1">
   from Customer where id=?
   </query>

　　测试方法

    @Test   //测试命名查询
public void test03(){
    Session session = HibernateUtils.getSession();
    Transaction bt = session.beginTransaction();
    Query qy = session.getNamedQuery("select1");
    qy.setParameter(0, 1);//添加参数
    Customer ct = (Customer) qy.uniqueResult();
    System.out.println(ct.getId());
    //操作
    bt.commit();
    session.close();
}    

　SQL

　　查询所有

　　@Test //sql查询
public void test6(){
    Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
    // 操作
    SQLQuery query = session.createSQLQuery("select * from user");
     
    List<Object[]> list = query.list();
    for (Object object : list) {
        //打印地址值
        System.out.println(object);
    }
    /*object对象指向User类
     * query.addEntity(User.class);
    List<User> list = query.list();
    for (User user : list) {
        System.out.println(user);
    }*/
    //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
    //configuration相当于连接池
    session.close();
}

　　条件查询

　　@Test //sql条件查询()
public void test7(){
    Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
    // 操作
    SQLQuery query = session.createSQLQuery("select * from user where username=?");
    query.setParameter(0, "zhangsan111");
    //object对象指向User类
    query.addEntity(User.class);
    User user = (User) query.uniqueResult();//转换时还是会让Query对象识别到User这个类
    System.out.println(user);
    //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
    //configuration相当于连接池
    session.close();
}

Criteria对象

查询所有

　　@Test //Criteria查询全部
public void test8(){
    Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
    // 操作
    Criteria criteria = session.createCriteria(User.class);
    List list = criteria.list();
    for (Object object : list) {
        System.out.println(object);
    }
    //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
    //configuration相当于连接池
    session.close();
}

　　单条件查询/多条件查询

　　@Test //Criteria条件查询查询
public void test9(){
    Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
    // 操作
    Criteria criteria = session.createCriteria(User.class);<br>　　　　　　　　　　　　　　　//条件1
    criteria.add(Restrictions.eq("username", "zhangsan111"));<br>　　　　　　　　　　　　　　　//条件2<br>　　　　　　　　　　　　　　 criteria.add(Restrictions.eq("username","zhangsan111"));<br>
    List list = criteria.list();
    for (Object object : list) {
        System.out.println(object);
    }
    //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
    //configuration相当于连接池
    session.close();
}

　　条件或

@Test //Criteria条件查询查询or
        public void test10(){
            Session session = HibernateUtils.getSession(); // 相当于得到一个Connection。
            // 操作
            Criteria criteria = session.createCriteria(User.class);
            //条件1
            criteria.add(Restrictions.or(Restrictions.eq("username", "zhangsan111"),Restrictions.eq("username", "fanjiankang")));
         
            List list = criteria.list();
            for (Object object : list) {
                System.out.println(object);
            }
            //不需要关闭Configuration  因为Configuration不是轻量级的。这样一个项目就只产生一个Configuration
            //configuration相当于连接池
            session.close();
        }

　　Cariteria只是对于criteria的方法进行对于sql语句的控制，这样整个开发过程及其检索;

使用离线查询

@Test   //测试离线查询
    public void test04(){
        DetachedCriteria dc=DetachedCriteria.forClass(Order.class);
        dc.add(Restrictions.between("id", 10, 20));
        Session session = HibernateUtils.getSession();
        Transaction bt = session.beginTransaction();
        Criteria criteria = dc.getExecutableCriteria(session);
        List list = criteria.list();
        System.out.println(list);
        bt.commit();
        session.close();
    }

　　多表关联查询

　　　　交叉连接

　　　　内连接

　　　　　　显式内连接　　inner join with(where)　

   @Test    //测试显式连接查询
public void test05(){
    Session session = HibernateUtils.getSession();
    Transaction bt = session.beginTransaction();<br>　　　　　　　　　　//  表一  inner join 表二
    String hql="from Customer c inner join c.orders";//"from Customer c inner join c.orders with c.id=1"
    Query query = session.createQuery(hql);
    List<Object[]> list = query.list();
    for (Object[] objects : list) {
        for (Object obj : objects) {
            System.out.println(obj);
        }
    }
    //操作
    bt.commit();
    session.close();
}

　　　　　　隐式内连接

　　　　　　　　　　隐式内连接: 使用 "逗号"将表分开，使用 WHERE 来消除迪卡尔积

@Test   //测试隐式内连接查询
public void test06(){
    Session session = HibernateUtils.getSession();
    Transaction bt = session.beginTransaction();
    String hql="from Order o where  o.c.id=1";
    Query query = session.createQuery(hql);
    List<Order> list = query.list();
    for (Order o : list) {
            System.out.println(o);
    }
    //操作
    bt.commit();
    session.close();
}

　　　　　　迫切连接

迫切内连接得到的结果是直接封装到 PO 类中，而内连接得到的是 Object[]数组，数组中封
装的是 PO 类对象。
@Test   //测试迫切内连接查询
    public void test08(){
        Session session = HibernateUtils.getSession();
        Transaction bt = session.beginTransaction();
        String hql="from Order o inner join fetch  o.c";
        Query query = session.createQuery(hql);
        List<Order> list = query.list();
        for (Order o : list) {
                System.out.println(o);
        }
        //操作
        bt.commit();
        session.close();
    }

　　　　外连接

　　　　　　左外连接

    @Test   //测试左外连接查询
public void test09(){
    Session session = HibernateUtils.getSession();
    Transaction bt = session.beginTransaction();
    String hql="from Customer c left outer join c.orders";
    Query query = session.createQuery(hql);
    List<Object[]> list = query.list();
    for (Object[] objects : list) {
        for (Object obj : objects) {
            System.out.println(obj);
        }
    }
    //操作
    bt.commit();
    session.close();
}

　　　　　　迫切左外连接

    @Test   //测试左迫切外连接查询
public void test10(){
    Session session = HibernateUtils.getSession();
    Transaction bt = session.beginTransaction();
    String hql="from Order o left outer join fetch o.c ";
    Query query = session.createQuery(hql);
    List<Order> list = query.list();
    for (Order o : list) {
            System.out.println(o);
    }
    //操作
    bt.commit();
    session.close();
}

　　　　　　右外连接

@Test   //测试左外连接查询
public void test11(){
    Session session = HibernateUtils.getSession();
    Transaction bt = session.beginTransaction();
    String hql="from Customer c right outer join c.orders";
    Query query = session.createQuery(hql);
    List<Object[]> list = query.list();
    for (Object[] objects : list) {
        for (Object obj : objects) {
            System.out.println(obj);
        }
    }
    //操作
    bt.commit();
    session.close();
}