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();

           //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", );

           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=;

           int pageIndex=;

           criteria.setFirstResult((pageIndex-)*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();

        }

    }

}

巴特西

Criteria查询初学者的采纳点哦

最新文章

热门文章