dljd_(040-046)_hibernate中的单表查询/排序查询

一、查询接口

　　1.1Query接口：

　　　　Hibernate进行HQL查询的接口，支持动态绑定参数的功能。使用Seesion对象的createQuery方法可获取Query对象。Query query=session.createQuery(hql);
　　1.2SQLQuery接口

　　　　Hibernate进行SQL远程查询的接口，支持动态绑定参数的功能，是Query接口的子接口。使用Session对象的createdSQLQuery()方法可获取SQLQuery对象。

　　　　SQLQuery sqlQuery=session.createSQLQuery(sql);
　　　　其查询出的结果对象默认为Object，当然，若结果为List，则其元素为Object。使用SQLQuery的addEntity(Xxxx.class)方法，可以将其结果泛型设定为指定类型。
　　1.3Criteria接口
　　　　Criteria,标准，准则，Hibernate进行Criteria查询的接口，与Query接口无关。使用Session对象的createCriteria()方法可获取Criteria对象。
　　　　Criteria criteria=session.createCriteria(Xxx.class);　　

　　hibernate是Dao层技术，对数据的使用，查询是最为重要的。hibernate的查询技术非常强大，支持原始sql语句查询，支持QBC查询及hibernate特有的HQL查询。
　　HQL hibernate Query Language, hibernate查询语言，它与SQL非常相似。但HQL是面向对象的查询语言，而SQL是面向二维表的。HQL查询语言中使用的是类名与属性名，而SQL语句使用的是表名与字段名。
　　QBC，query by criteria,标准查询，一种比HQL更为面向对象的查询方法。
二、利用原生sql进行查询

　　

package edu.aeon.hibernate.test;


import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import edu.aeon.aeonutils.hibernate.getsessionutil.GetSessionUtil;
import edu.aeon.beans.Student;
/**    
 * [说明]:测试单表查询
 * @author aeon
 *
 */
public class Test {
    /**
     * 循环插入10条测试数据
     */
    public static void testForInsert() {
        try {
            Session session = GetSessionUtil.getSession();
            session.beginTransaction();
            for(int i=1;i<=10;i++){
                Student student = new Student("username"+i, i, (50+i));
                session.save(student);
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
        }
    }
    /**
     * 利用原生SQL进行查询
     */
    public static void testSelectBySql() {
        Transaction transaction = null;
        try {
            Session session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            String sql="select stu_id,stu_name,stu_age,stu_score from student";
            List<Student> stuList = session.createSQLQuery(sql).addEntity(Student.class).list();
            for(Student stu:stuList){
                System.out.println(stu);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }
    }
    
    public static void main(String[] args) {
        //testForInsert();
        testSelectBySql();
    }
}

数据库数据截图：

　　

结果截图

　　

 三、利用hql语句进行查询

　　

package edu.aeon.hibernate.test;


import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import edu.aeon.aeonutils.hibernate.getsessionutil.GetSessionUtil;
import edu.aeon.beans.Student;
/**    
 * [说明]:测试save前后对象的变化
 * @author aeon
 *
 */
public class Test {
    /**
     * 循环插入100条测试数据
     */
    public static void testForInsert() {
        try {
            Session session = GetSessionUtil.getSession();
            session.beginTransaction();
            for(int i=1;i<=10;i++){
                Student student = new Student("username"+i, i, (50+i));
                session.save(student);
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
        }
    }
    /**
     * 利用原生SQL进行查询
     */
    public static void testSelectBySql() {
        Transaction transaction = null;
        try {
            Session session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            String sql="select stu_id,stu_name,stu_age,stu_score from student";
            List<Student> stuList = session.createSQLQuery(sql).addEntity(Student.class).list();
            for(Student stu:stuList){
                System.out.println(stu);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }
    }
    
    /**
     * 利用hql语句进行查询
     */
    public static void testSelectByHql() {
        Transaction transaction = null;
        try {
            Session session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            String hql="from Student"; //此处Student一定为表名
            //这里已经封装成对象了，所以我们不再调用封装对象的方法
            List<Student> stuList = session.createQuery(hql).list(); 
            for(Student stu:stuList){
                System.out.println(stu);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }
    }
    
    public static void main(String[] args) {
        //testForInsert();
        //testSelectBySql();
        testSelectByHql();
    }
}

查询结果截图：

　　

四、qbc查询、标准查询

　　

package edu.aeon.hibernate.test;


import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import edu.aeon.aeonutils.hibernate.getsessionutil.GetSessionUtil;
import edu.aeon.beans.Student;
/**    
 * [说明]:测试save前后对象的变化
 * @author aeon
 *
 */
public class Test {
    /**
     * 循环插入100条测试数据
     */
    public static void testForInsert() {
        try {
            Session session = GetSessionUtil.getSession();
            session.beginTransaction();
            for(int i=1;i<=10;i++){
                Student student = new Student("username"+i, i, (50+i));
                session.save(student);
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
        }
    }
    /**
     * 利用原生SQL进行查询
     */
    public static void testSelectBySql() {
        Transaction transaction = null;
        try {
            Session session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            String sql="select stu_id,stu_name,stu_age,stu_score from student";
            List<Student> stuList = session.createSQLQuery(sql).addEntity(Student.class).list();
            for(Student stu:stuList){
                System.out.println(stu);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }
    }
    
    /**
     * 利用hql语句进行查询
     */
    public static void testSelectByHql() {
        Transaction transaction = null;
        try {
            Session session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            String hql="from Student"; //此处Student一定为表名
            //这里已经封装成对象了，所以我们不再调用封装对象的方法
            List<Student> stuList = session.createQuery(hql).list(); 
            for(Student stu:stuList){
                System.out.println(stu);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }
    }
    /**
     * 标准行查询
     */
    public static void testSelectQBC() {
        Transaction transaction = null;
        try {
            Session session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            List<Student> userList = session.createCriteria(Student.class).list();
            for(Student stu:userList){
                System.out.println(stu);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }
    }
    
    public static void main(String[] args) {
        //testForInsert();
        //testSelectBySql();
        //testSelectByHql();
        testSelectQBC();
    }
}

结果截图：

　　

五、sql/hql/qbc 排序查询：

package edu.aeon.hibernate.test;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Order;
import org.junit.Test;

import edu.aeon.aeonutils.hibernate.getsessionutil.GetSessionUtil;
import edu.aeon.beans.Student;
/**    
 * [说明]:测试sql/hql/qbc的排序查询
 * @author aeon
 *
 */
public class TestQuery {
    /**
     * 循环插入10条测试数据
     */
    @Test
    public void testData(){
        Transaction transaction=null;
        Session session=null;
        try {
             session= GetSessionUtil.getSession();
            transaction = session.getTransaction();
            transaction.begin();
            
            //操作
            for(int i=1;i<=10;i++){
                Student student=new Student();
                student.setStuName("name_"+i);
                student.setStuAge((int)(Math.random()*30));
                student.setStuScore(Math.random()*80);
                session.save(student);
            }
            transaction.commit();
            System.out.println("插入数据成功！");
        } catch (Exception e) {
            transaction.rollback();
            e.printStackTrace();
            System.out.println("插入数据失败！");
        }finally {
            /*
             * 其实这种getCurrentSession获取到的session我们无需手动关闭
             * 因为当事务提交或者回滚的时候已经做了关闭session操作
             * 而用openSession获取到的session我们一定要用手动去关闭
             * */
            if(null!=session){
                session.close();
            }
        }
        
    }
    
    /**
     * 测试sql排序查询
     */
    @Test
    public  void testSqlQuery() {
        Transaction transaction=null;
        Session session=null;
        try {
            session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            String sql="select stuid,stuname,stuage,stuscore from student order by stuage desc";
            List<Student> stuList = session.createSQLQuery(sql).addEntity(Student.class).list();
            for (Student stu : stuList) {
                System.out.println(stu);
            }
            System.out.println("sql查询！");
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }finally {
            /*
             * 其实这种getCurrentSession获取到的session我们无需手动关闭
             * 因为当事务提交或者回滚的时候已经做了关闭session操作
             * 而用openSession获取到的session我们一定要用手动去关闭
             * */
            if(null!=session){
                session.close();
            }
        }
    }
    /**
     * 测试hql排序查询
     */
    @Test
    public  void testHqlQuery() {
        Transaction transaction=null;
        Session session=null;
        try {
            session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            String hql="from Student order by stuAge desc";
            List<Student> stuList = session.createQuery(hql).list();
            for (Student stu : stuList) {
                System.out.println(stu);
            }
            System.out.println("hql查询！");
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }finally{
            /*
             * 其实这种getCurrentSession获取到的session我们无需手动关闭
             * 因为当事务提交或者回滚的时候已经做了关闭session操作
             * 而用openSession获取到的session我们一定要用手动去关闭
             * */
            if(null!=session){
                session.close();
            }
        }
    }
    /**
     * 测试qbc排序查询
     */
    @Test
    public  void testCriteriaQuery() {
        Transaction transaction=null;
        Session session=null;
        try {
            session = GetSessionUtil.getSession();
            transaction=session.getTransaction();
            transaction.begin();
            //这里的stuAge必须为student里面的属性，严格区分大小写，因为这种方式是纯面向对象的查询。
            List<Student> stuList = session.createCriteria(Student.class).addOrder(Order.desc("stuAge")).list();
            for (Student stu : stuList) {
                System.out.println(stu);
            }
            System.out.println("qbc查询！");
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事物的回滚操作
            transaction.rollback();
        }finally{
            /*
             * 其实这种getCurrentSession获取到的session我们无需手动关闭
             * 因为当事务提交或者回滚的时候已经做了关闭session操作
             * 而用openSession获取到的session我们一定要用手动去关闭
             * */
            if(null!=session){
                session.close();
            }
        }
    }
}

测试结果截图：

　　插入测试数据执行截图：

　　

此时数据库数据信息截图如下：

　　

执行sql排序查询结果截图：

　　

 执行hql排序查询结果截图：

　　

执行qbc查询结果截图：

　　

总结：

　　　sql:

　　　hql:　

　　　qbc: