Criteria查询初学者的采纳点哦

一、Hibernate提供了5种检索对象的方式

     1.导航对象图检索方式：根据已经加载的对象导航到其他对象  　　 from  Emp e group by e.dept.deptName

     2.OID检索方式：按照对象的OID来检索对象  　　get/load

     3.HQL检索方式：使用面向对象的HQL查询语言 

     4.QBC检索方式：使用QBC(Query By Criteria)API来检索对象，这种API封装了基于字符串形式的查询语句，提供了更加面向对象的查询接口

     5.本地SQL检索方式：使用本地数据库的SQL查询语句   　　createSqlQuery();

二、什么是Criteria查询（使用QBC(Query By Criteria)API来检索对象）

      解析：Criteria查询是Hibernate提供的另一种查询方式。

　　　　　主要由Criteria、Criterion接口和Restrictions类组成，他支持在运行时动态生成查询语句。

三、实例来讲解Criteria的用法。

（一）首先我们我们先来熟悉一下createCriteria()方法

      Criteria criteria = session.createCriteria(Emp.class); 

　　解析：使用session.createCriteria()方法创建了criteria对象，createCriteria()方法的参数是持久化类的类型。

 List<Emp> list = criteria.list();

解析：使用criteria.list()执行查询语句，list()方法返回List集合。

@Test
    //1.查询所有部分信息
        public void SelectPartMessage(){
             Session session = HibernateUtil.currentSession();
               Transaction tx = session.beginTransaction();
               
               Criteria criteria = session.createCriteria(Emp.class); 
               List<Emp> list = criteria.list();
               for (Emp dept : list) {
                   System.out.println(dept.getEmpName());
                 }
               tx.commit();

        }

（二）根据条件查询

　　1）比较运算符

　　　　

HQL运算符	Criteria运算方法	说明
=	SimpleExpression Restrictions.eq(String propertyName,Object value)	等于
<>	SimpleExpression Restrictions.ne(String propertyName,Object value)	不等于
>	SimpleExpression Restrictions.gt(String propertyName,Object value)	大于
>=	SimpleExpression Restrictions.ge(String propertyName,Object value)	大于等于
<	SimpleExpression Restrictions.lt(String propertyName,Object value)	小于
<=	SimpleExpression Restrictions.le(String propertyName,Object value)	小于等于
is null	Criteria Restrictions.isNull(String propertyName)	等于空值
is not null	Criteria Restrictions.isNotNull(String propertyName)	非空值

 Criterion eq = Restrictions.eq("empName", "微冷的雨");

　　解析： Restrictions其方法的返回值是Criterion类型

@Test
    //按条件查询
    public void HasMessage(){
         Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
           Criteria criteria = session.createCriteria(Emp.class);
           
           Criterion eq = Restrictions.eq("empName", "微冷的雨");
           criteria=criteria.add(eq);
           List<Emp> list=criteria.list();
           for(Emp emps:list){
               System.out.println(emps.getEmpName());
           }
    }

 criteria.createAlias("dept", "d");
    解析：查看部门下的员工，用createAlias()方法获取其部门的属性值（必须起方法才能获取部门属性值）；dept（在关联emp的属性值在emp定义多对一关联）d是别名
　　
Criterion criterion = Restrictions.eq("d.deptName", "开发部");
解析：d.deptName获取属性值
　　

 /**
        * 1.3 关联查询  查询“开发部”所有员工
        * 
             */
       @Test
       public void connectTest(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
            Criteria criteria = session.createCriteria(Emp.class);
            
            //Emp中关联的dept对象，起一个别名   d
            criteria.createAlias("dept", "d");
            
            Criterion criterion = Restrictions.eq("d.deptName", "开发部");
            
            criteria.add(criterion);
    
            List<Emp> list = criteria.list();
            
            for (Emp emp : list) {
                System.out.println(emp.getEmpName());
            }
       }

 2）范围运算符

HQL运算符	Criteria运算方法	说明
in(列表)	Criterion Restrictions.in(String propertyName,Collecyion values) 或者 Criterion Restrictions.in(String propertyName,Object[] values)	等于类表中的某一个值
not in(列表)	Criterion Restrictions.not(  Restrictions.in())	不等于列表中的任意一个值
between 值1 and 值2	Criterion Restrictions.between(String propertyName,Object lo,Object hi)	大于等于值1 并且小于等于值2
not between 值1  and 值2	Criterion Restrictions.not(Restrictions.between())	小于值1 或者大于值2

lists.add("bj");
Criterion criterion=Restrictions.in("empCtity", lists);
解析:empCtity为bj的员工

 //1.4查询地址为bj的员工信息
       @Test 
       public void hastable(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
            Criteria criteria = session.createCriteria(Emp.class);
            List<String> lists=new ArrayList<String>();
            lists.add("bj");
            Criterion criterion=Restrictions.in("empCtity", lists);
            criteria.add(criterion);
            List<Emp> list = criteria.list();
            for (Emp emp : list) {
                System.out.println(emp.getEmpName());
            }

       }

 3）字符串模式匹配

  Criterion criterion = Restrictions.ilike("empCtity", "%b%");
　　解析：Restrictions.ilike（）字符串模型匹配同时忽略大小写（有i）
　　解析：Restrictions.like（）字符串模型匹配

 /**
        * 1.5  字符串模式匹配  
        * 查询员工地址中包含“s”的所有员工，忽略大小写
           Restrictions.ilike( )  //Ignore Like 
             */
       @Test
       public void likeTest(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
           Criteria criteria = session.createCriteria(Emp.class);
           
           Criterion criterion = Restrictions.ilike("empCtity", "%b%");
           
           criteria.add(criterion);
           
            List<Emp> list = criteria.list();
            for (Emp emp : list) {
                System.out.println(emp.getEmpName());
            }

       }

 4）逻辑运算符

　　解释有and逻辑与   or逻辑或  not逻辑非

　　Criterion criterion = Restrictions.and(c1, c2);

     解析：将两个参数传入

 /**
        * 1.6    逻辑运算
        * and  过滤    查找地址是bj 并且  名称中包含 “雨” 的员工信息 
             */
       @Test
       public void logicTest(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
           Criteria criteria= session.createCriteria(Emp.class);
           Criterion c1 = Restrictions.eq("empCtity", "bj");
           Criterion c2= Restrictions.like("empName", "号",MatchMode.ANYWHERE);
           
           Criterion criterion = Restrictions.and(c1, c2);
           
           criteria.add(criterion);
           
            List<Emp> list = criteria.list();
            for (Emp emp : list) {
                System.out.println(emp.getEmpName());
            }
       }

 5）集和运算

Criterion criterion = Restrictions.isEmpty("emps");
解析：Restrictions.isEmpty()集合为空，不包括任何元素

 /**
        * 1.7  集合运算
        * 集合运算  查询 没有员工的部门
        * */ 
       @Test
       public void collectionTest(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
           Criteria criteria = session.createCriteria(Dept.class); 
           //Restrictions类方法的返回值是Criterion
           Criterion criterion = Restrictions.isEmpty("emps");
           
           criteria.add(criterion);
           
            
            List<Dept> list = criteria.list();
            for (Dept dept : list) {
                System.out.println(dept.getDeptName());
            }
       }

 （三）动态查询

　　解析：动态查询就是根据条件进行sql语句的拼接

       /**
        * 1.8  动态查询    
        * 如何查找出符合以下条件的员工信息：
            职位是工程师，如：job = ‘engineer’
            工资大于2000元，如：salary > 2000
            入职时间在2006年12月31日至2008年12月31日之间 
         如何查找出符合以下条件的员工信息：
            地址 = ‘bj’
            员工编号大于0
     *
        * */ 
       @Test
       public void dynamicTest(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
           Criteria criteria = session.createCriteria(Emp.class); 
           //00.构建出一个和page对应的条件类，依次判定条件是否为空
           EmpCondition condition=new EmpCondition();
           condition.setEmpCity("bj");
           condition.setEmpId(0);
           
           //1.2判定之后，动态拼接检索条件
           if (condition.getEmpCity()!=null) {
               //用户填写了地址作为检索条件
               criteria.add(Restrictions.eq("empCtity", condition.getEmpCity()));
           }
           if(condition.getEmpId()!=null){
               //用户填写用户编号作为筛选条件
               criteria.add(Restrictions.gt("empId", condition.getEmpId()));
           }
            List<Emp> list = criteria.list();
            for (Emp emp : list) {
                System.out.println(emp.getEmpName());
            }
       }

（四）Order排序

 /**
        * 1.9  排序   addOrder()
        * 查询工号大于0的员工，查询结果按员工 编号升序排列
        * */ 
       @Test
       public void orderTest(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
           Criteria criteria = session.createCriteria(Emp.class);
           Criterion criterion = Restrictions.gt("empId", 0);
           criteria.add(criterion).addOrder(Order.asc("empId"));
           List<Emp> list = criteria.list();
            
            for (Emp emp : list) {
                System.out.println(emp.getEmpName());
            }

       }

（五）分页

 /**
        * 1.10 分页
        * Criteria接口提供了设置分页的方法
            setFirstResult(int firstResult)  起始记录的索引
            setMaxResult(int maxResult)  最大记录条数
            //10.分页  查询员工表中的4-6条数据，每页3条数据
        */
       
       @Test
       public void pageListTest(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
           Criteria criteria = session.createCriteria(Emp.class);
           //总记录数
          
           Projection projection = Projections.count("empId");
          
           criteria.setProjection(projection);
          
           Integer count = ((Long)criteria.uniqueResult()).intValue();
           System.out.println(count);

           //分页
           int pageSize=3;
           int pageIndex=2;
           criteria.setFirstResult((pageIndex-1)*pageSize);
           criteria.setMaxResults(pageSize);
           List<Emp> list = criteria.list();
            for (Emp emp : list) {
                System.out.println(emp.getEmpName());
            }

       }

（六）DetachedCriteria

 /**
        * 1.11  DetachedCriteria和Criteria功能类似，它实现了CriteriaSpecification接口
            Criteria是由Session对象创建的
            DetachedCriteria创建时不需要Session对象
            使用DetachedCriteria来构造查询条件
            可以把DetachedCriteria作为方法参数传递给业务层
        * 查询开发部的员工
        * */ 
       @Test  
       public void detachedCriteriaTest(){
           Session session = HibernateUtil.currentSession();
           Transaction tx = session.beginTransaction();
           //构建一个DetachedCriteria对象
           DetachedCriteria detachedCriteria=DetachedCriteria.forClass(Emp.class);
           //别名
           detachedCriteria.createAlias("dept","d");
           //检索条件
           Criterion criterion = Restrictions.eq("d.deptName", "开发部");
           //绑定
           detachedCriteria.add(criterion);
           List<Emp> list = detachedCriteria.getExecutableCriteria(session).list();
           for (Emp emp : list) {
                System.out.println(emp.getEmpName());
            }

       }
       

　　　　就此讲解到此，希望程序员的我们有收获！！！！友情提示HibernateUtil工具类

package cn.happy.until;

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

/**
 * 工具类
 * @author happy
 *
 */
public class HibernateUtil {
    //getCurrentSession()底层实现原理
    //ThreadLocal变量
    public static final ThreadLocal<Session> threadTL=new ThreadLocal<Session>();
    
   //我想直接调用一个方法，获取Session
   //定义一个sessionFactory对象
    private static SessionFactory factory;
    private static Configuration cfg;
    static{
        cfg=new Configuration().configure();
        factory=cfg.buildSessionFactory();
    }
    //提供一个静态方法
    public static Session currentSession(){
        Session session=threadTL.get();
        if(session==null){  //当前线程中没有session对象
            session=factory.openSession();
            threadTL.set(session);
        }
        return session;
        
    }
    //关闭session
    public static void closeSession(){
        //获取线程中的session
        Session session = threadTL.get();
        if (session!=null) {
            threadTL.set(null);
            session.close();
        }
    }
    
}