• 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();
            }
        }
        
    }
  • 相关阅读:
    大杂烩 -- 查找单向链表倒数第m个元素
    大杂烩 -- 单向链表是否存在环或是否相交
    大杂烩 -- 四种生成和解析XML文档的方法详解
    延伸 -- 泛型 -- 通配符的使用
    延伸 -- 泛型 -- 泛型的内部原理:类型擦除以及类型擦除带来的问题
    延伸 -- 泛型 -- 泛型的基本介绍和使用
    大杂烩 -- HashMap、HashTable、ConCurrentHashMap 联系与区别
    大杂烩 -- ArrayList的动态增长 源码分析
    Java -- 异常的捕获及处理 -- 自定义异常类
    Java字符串占位符(commons-text)替换(转载)
  • 原文地址:https://www.cnblogs.com/yejiaojiao/p/5796279.html
Copyright © 2020-2023  润新知