全面解析Hibernate框架--小白必看 4

hibernate 查询实现

方式一：criteria

特点：拼接sql查询条件。
创建一个criteria接口对象，
Criteria c=s1.createCriteria(User.class);
添加查询条件
现在建议采用Restrictions的子类Restrictions

Criteria使用代码：
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import ytu.group.entity.Student;
import ytu.group.util.HibernateUtils;


public class TestCriteria {

    private Session session;


    @Before
    public void before(){

        session = HibernateUtils.getSession();
    }

    /**
     * 查询所有学生，不带查询条件
     */
    @Test
    public void testQueryAll(){
        Criteria c=session.createCriteria(Student.class);//得到了一个criteria对象
        List<Student> list = c.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }
    /**
     * 查询年龄小于18岁的学生
     */
    @Test
    public void testQueryByCondition1(){
        Criteria c=session.createCriteria(Student.class);//得到了一个criteria对象
        //增加一个age<18条件
        c.add(Restrictions.lt("studentAge", 18));
        //获取结果
        List<Student> list = c.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }
    /**
     * 查询姓王的
     */
    @Test
    public void testQueryByCondition2(){
        Criteria c=session.createCriteria(Student.class);//得到了一个criteria对象
        //增加一个age<18条件
        c.add(Restrictions.like("studentName", "王%"));
        //获取结果
        List<Student> list = c.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }
    /**
     * 查询多条件的，要求班级是2班的，而且年龄大于30岁的
     * 
     */
    @Test
    public void testQueryByCondition3(){
        Criteria c=session.createCriteria(Student.class);//得到了一个criteria对象
        //增加一个age<18条件
        c.add(Restrictions.eq("classes.id", 2));
        c.add(Restrictions.gt("studentAge", 30));
        //获取结果
        List<Student> list = c.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }

    /**
     * 查询多条件的，要求班级是2班的或者而且年龄大于30岁的
     * 
     */
    @Test
    public void testQueryByCondition4(){
        Criteria c=session.createCriteria(Student.class);//得到了一个criteria对象
        //增加一个age<18条件
        c.add(Restrictions.or(Restrictions.eq("classes.id", 2),Restrictions.gt("studentAge", 30)));

        //获取结果
        List<Student> list = c.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }
    /**
     * 查询多条件的，年龄在25到30岁之间
     * 
     */
    @Test
    public void testQueryByCondition5(){
        Criteria c=session.createCriteria(Student.class);//得到了一个criteria对象
        //增加条件
        /*c.add(Restrictions.gt("studentAge", 25));
        c.add(Restrictions.lt("studentAge", 30));*/
        c.add(Restrictions.between("studentAge", 25, 30));
        //获取结果
        List<Student> list = c.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }

    /**
     * 数据分页，每一页5条数据，要求查询第二页6-8。
     */
    @Test
    public void testQueryByCondition6(){
        Criteria c=session.createCriteria(Student.class);//得到了一个criteria对象
        //查询start，end第几条
        int start=6;//第二页从第六条开始

        c.setFirstResult(start).setMaxResults(5);
        //获取结果
        List<Student> list = c.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }





    @After
    public void after(){

        //关闭session
        HibernateUtils.closeSession(session);
    }

}

方式二：hql

HQL 面向对象的查询语言Hiberante QL（实体类） StructureQL（表）
Query接口
注意：
1、应用中存在同名类（包不同），要注意使用全类名方式
2、HQL子句本身大小写无关，但是其中出现的类名和属性名必须注意区分大小写
使用方式：
1.创建一个query对象，session.createQuery 返回值是query类型
2.里面传递一个hql的查询语句作为参数
3.通过query.list获取查询结果，返回类型是list 默认list里面元素类型是object

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import ytu.group.entity.Classes;
import ytu.group.entity.Student;
import ytu.group.util.HibernateUtils;


public class TestHql {

    private Session session;


    @Before
    public void before(){

        session = HibernateUtils.getSession();
    }

    /**
     * 查询所有学生select * from tbl_student
     */
    @Test
    public void testHQL1(){
        String hql="from Student";
        //创建query对象
        Query query = session.createQuery(hql);
        List<Student> list = query.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }

    /**
     * 查询所有学生select * from tbl_student order by student_age desc ,按照年龄排序
     */
    @Test
    public void testHQL2(){
        String hql="from Student order by studentAge";
        //创建query对象
        Query query = session.createQuery(hql);
        List<Student> list = query.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }
    /**
     * 查询所有学生年龄大于30岁的
     */
    @Test
    public void testHQL3(){
        String hql="from Student where studentAge>30";
        //创建query对象
        Query query = session.createQuery(hql);
        List<Student> list = query.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }
    /**
     * 查询所有学生年龄大于30岁的年龄和姓名。查询部分列
     */
    @Test
    public void testHQL4(){
        String hql="select studentName,studentAge from Student where studentAge>30";
        //创建query对象
        Query query = session.createQuery(hql);
        List<Object[]> list = query.list();
        for(Object[] arr:list){
            System.out.println("学生姓名："+arr[0]+"\t学生年龄："+arr[1]);
        }

    }
    /**
     * 查询所有学生年龄大于30岁的姓王
     */
    @Test
    public void testHQL5(){
        String hql="select s from Student s where studentAge>30 and studentName like '王%'";
        //创建query对象
        Query query = session.createQuery(hql);
        List<Student> list = query.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }
    /**
     * 查询所有学生年龄大于30岁的姓王,不安全，动态参数下表是从0开始的。
     */
    @Test
    public void testHQL6(){
        String hql="select s from Student s where studentAge>? and studentName like ?";
        //创建query对象
        Query query = session.createQuery(hql);
        query.setParameter(0, 30);
        query.setParameter(1, "王%");
        List<Student> list = query.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }

    }
    /**
     * 分组查询：查出每个班级id以及该班级的学生的平均年龄
     * select avg(student_age) pj,class_id from tbl_student group by CLASS_ID;
     */
    @Test
    public void testHQL7(){
        String hql="select s.classes.id , avg(s.studentAge) from Student s group by s.classes.id";
        //创建query对象
        Query query = session.createQuery(hql);

        List<Object[]> list = query.list();
        for(Object[] arr:list){
            System.out.println("班级id："+arr[0]+"\t平均年龄："+arr[1]);
        }

    }
    /**
     * 命名查询，查询一开始定义在实体中adult_std
     */
    @Test
    public void testHQL9(){

        Query query = session.getNamedQuery("adult_std");
        query.setParameter(0, 18);
        List<Student> list = query.list();
        for(Student s:list){
            System.out.println("学生姓名："+s.getStudentName()+"\t学生年龄："+s.getStudentAge());
        }
    }
    /**
     * 多态查询（了解）
     */
    @Test
    public void testHQL10(){
        String hql="from java.lang.Object";//hql entity，查询父类
        //创建query对象
        Query query = session.createQuery(hql);
        List<Object> list = query.list();
        for(Object s:list){
            System.out.println(s);
        }

    }
    /**
     * 张三，修改张三的年龄为30岁
     */
    @Test
    public void testHQL11(){
        /* Student s = (Student)session.get(Student.class, 1);
         s.setStudentAge(30);
         Transaction tx = session.beginTransaction();
         session.save(s);
         tx.commit();*/
        String hql="update Student s set s.studentAge=32 where s.studentName='张三'";
        Query query = session.createQuery(hql);
        Transaction tx = session.beginTransaction();
        query.executeUpdate();
        tx.commit();
    }

    /**
     * 删除一个学生，
     */
    @Test
    public void testHQL12(){
        Student s = (Student)session.get(Student.class, 1);

        Transaction tx = session.beginTransaction();
        session.delete(s);
        tx.commit();
    }



    @After
    public void after(){

        //关闭session
        HibernateUtils.closeSession(session);
    }

}

分页：为什么要分页？

Sql语句：
Select sub.age,sub.name from (Select rownum as rn,t.* from tbl_user t ) sub where sub.rn>=start and sub.rn<=end

一次性读取数据如果过多，查询速度慢，加载到页面显示速度更慢。
不便于用户阅读。

前台页面：通过get或者post方式传递参数到后台，参数有哪些？
当前第几页—page
后台：默认一页显示多少条pageSize，当前是哪一页？currentPage，总的记录数目
TotalCount，
总的页数：totalPages=totalCount%pageSize==0? totalCount/pageSize: totalCount/pageSize+1

后台知道的是：currentPage
Start: (currentPage-1)*pageSize+1
End:currentPage*pageSize

int pageSize=10;
        int currentPage=3;
        int begin=(currentPage-1)*pageSize+1;
        int end=currentPage*pageSize;
         //查询年龄在30-40之间，并且按照年龄升序排列
        Criteria c=session.createCriteria(User.class);

        List<User> users=c.setFirstResult(begin).setMaxResults(pageSize).list();
        for(User u:users)
        {
            System.out.println(u.getUserAge()+"--"+u.getUserName());
        }

分页查询：
/**
     * 分页查询
     * 给与一个页码，返回该页码对应的数据
     */
    @Test
    public void testQueryByPage(){
        int page=2;//第二页
        int pageCount=2;//每一页多少条数据
        int start=(page-1)*pageCount;//起始记录
        Query query=session.createQuery("from Student");
        query.setFirstResult(start).setMaxResults(pageCount);
        List<Student> list = query.list();
         for(Student s:list){
             System.out.println(s);
         }
    }

方式三 SQL查询 SqlQuery

1.  简单的select * 转实体

String sql="select * from tbl_user";
        List<User> users=session.createSQLQuery(sql).addEntity(User.class).list();
        for(User user:users)
        {
            System.out.println(user.getUserName());
        }




2.默认是数组object[]
String sql="select u.user_id   ,u.user_Name ,u.user_Age   from Tbl_USER u";
        List<Object[]> r11=session.createSQLQuery(sql).list();
        for(Object[] objs:r11){
            System.out.println(objs[0]);
        }


3.结果集转Map
String sql = "select user_id  ,user_age   from tbl_user ";
        List<Map> lst=session.createSQLQuery(sql).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).list();
        for (Map u : lst) {
            System.out.println(u.get("USER_ID"));
        }       

SQLQuery q=session.createSQLQuery("select age,name from student");
        List<Map<String,Object>> lst=q.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).list();
        for(Map m:lst){
            System.out.println("name:"+m.get("NAME"));
        }















 调用存储过程
1.带返回参数的调用存储过程?
SQLQuery query = session.createSQLQuery("{Call proc(?)}");?
query.setString(0, 参数);?
List list =query.list();
2:不带返回参数的调用存储过程?
/**
     * 调用存储过程
     */
    @Test
    public void testProcedure(){

        SQLQuery query = session.createSQLQuery("{call delete_stu_pro(?)}");
        query.setInteger(0, 2);
        query.executeUpdate();


    }
    也可以采用session获取connection之后再用jdbc去调用。

---

我觉得hibernate这四篇文章应该
够让大家初步了解hibernate了，概括的说，就是一个让开发简单点的封装了jdbc的一堆类（工具）

下午说下配置数据库连接池和log4j吧。