QBC---Criteria查询

QBC:Query  By Criteria     标准查询     JPA中Criteria  所有查询都需要加事务
SQL、HQL 或者各种关键字的语句都不需要书写。全部用方法代替。
Hibernate5.2之前 session.createCriteria(XX); 
Hibernate5.2之后 建造者模式    重点

 //1.创建CriteriaBuilder对象，用于构建查询条件
 CriteriaBuilder cBuilder= session.getCriteriaBuilder();
 //2.构建Criteria查询对象同时要声明返回的结果类型：Person
 CriteriaQuery<Person> cQuery= cBuilder.createQuery(Person.class);
 //2.1指明要查询哪一个java持久化类  ,可以等价于HQL语句：from com.qf.domain.Person
 cQuery.from(Person.class);
 //3.执行Criteria查询
 session.createQuery(cQuery);

 　　1.基础查询

//1.创建CriteriaBuilder对象，用于构建查询条件
CriteriaBuilder cBuilder= session.getCriteriaBuilder();
//2.构建Criteria查询对象同时要声明返回的结果类型：Person
CriteriaQuery<Person> cQuery= cBuilder.createQuery(Person.class);
//2.1指明要查询哪一个java持久化类  ,可以等价于HQL语句：from com.qf.domain.Person
cQuery.from(Person.class);
//3.执行Criteria查询
List<Person> list = session.createQuery(cQuery).list();
System.out.println(list); 

　　2.条件查询

     where后跟的条件符：
     >      gt()  大于         >=     ge()  大于等于         <    lt()  小于    <=     le()  小于等于        ==     equal()      !=     notEqual()
    path<Number>：Integer，long,short.....
    between A and B  在A和B之间     in (......)    在某个集合范围内      like    模糊匹配       notlike  不能匹配到的是        and  and()  和
    or        or()   或者        空   isNull     非空   isNotNUll 

　　　Expression接口: 查询表达式 Type for query expressions.  提供的方法： isNull()  isNotNull()  in(Object... values)
     Path和Predicate是Expression的实现类
     Path:从绑定的类(type)或者集合(collection)中查找简单或者复杂的属性路径。
     程序：from(Person.class)  查找指定属性 Path<Integer> path = get("属性名")：
     Predicate：同时发生的多个或者单个限制条件
     a conjunction(连接词，同时发生) or   disjunction(分离) of restrictions.    restrictions  限制条件 

　　　　比较大小

        　　CriteriaBuilder cBuilder =session.getCriteriaBuilder();
        　　CriteriaQuery<Person> criteriaQuery = cBuilder.createQuery(Person.class);
            Root root = criteriaQuery.from(Person.class);        
            //2.2构建查询条件 写where后的条件
            //参数1：字段表达式 ，参数2：要比较的值
            //需求：age大于20岁的
            //从Person类上查找age属性的路径
            //比较大小：gt,ge,lt，le,equal,notEqual
            Path<Integer> age =  root.get("age");
            //P通过指定路径的属性映射的列名和后面的值去比较
            Predicate pAge= cBuilder.equal(age, 18);    
            //条件必须放在where后面
            criteriaQuery.where(pAge);
            //3执行Criteria查询
            Query<Person> query = session.createQuery(criteriaQuery);    
            System.out.println(query.list()); 

　　　　其他条件查询

　　　　　　  CriteriaBuilder cBuilder =session.getCriteriaBuilder();
            CriteriaQuery<Person> criteriaQuery = cBuilder.createQuery(Person.class);
            Root root = criteriaQuery.from(Person.class);        
            
            //2.2构建查询条件 写where后的条件
            //参数1：字段表达式 ，参数2：要比较的值
            //需求：name中含有g的Person
            //从Person类上查找name属性的路径
            Path<String> name =  root.get("name");
            Path<Integer> age =  root.get("age");
            //Predicate条件：
            Predicate pAge1= cBuilder.like(name, "%g%");    
            //Predicate pAge= cBuilder.notLike(name, "%g%");    
             Predicate pAge2 =cBuilder.isNotNull(age);
            Predicate p1=  cBuilder.and(pAge1,pAge2);
            //条件必须放在where后面
            criteriaQuery.where(p1);
            
            //3执行Criteria查询
            Query<Person> query = session.createQuery(criteriaQuery);    
            System.out.println(query.list()); 

　　3.分页查询

　　　　　　　CriteriaBuilder cBuilder=  session.getCriteriaBuilder();
            CriteriaQuery<Person> cQuery= cBuilder.createQuery(Person.class);
            Root root = cQuery.from(Person.class);
          
            Query<Person>  query = session.createQuery(cQuery);
            query.setFirstResult(0);//查询的起始位置
            query.setMaxResults(2);//每次查询数据的条数
            System.out.println(query.list()); 

 　　4.排序查询

　　　　　　 CriteriaBuilder cBuilder=  session.getCriteriaBuilder();
            CriteriaQuery<Person> cQuery= cBuilder.createQuery(Person.class);
            Root root = cQuery.from(Person.class);
            //3.1加排序 递增asc，递减desc  (属于条件类的)
            Path<String>  path=  root.get("ID");//get("持久化类要排序的属性值")    
            //3.2构建排序的条件
            Order order= cBuilder.desc(path);
            //3.3加入查询的条件
            cQuery.orderBy(order);
            //4.执行查询
            Query<Person> query = session.createQuery(cQuery);
            System.out.println(query.list()); 

　　5.聚合函数查询

    //在JPA中的Criteria的所有查询中要执行调用的是以前sql中关键字的方法
    //示例： from()  select()  orderby()    where() 
    //但是条件必须都是CriteriaBuilder
    //在JPA中的Criteria的聚合函数查询中：
    //1. sum,max,min的类型跟所查询的列的类型一致
    //3. avg  结果类型是Double类型
    //4. count  结果类型是Long类型 

　　　　　　  CriteriaBuilder cBuilder=  session.getCriteriaBuilder();
            CriteriaQuery<Long> cQuery= cBuilder.createQuery(Long.class);
            Root root = cQuery.from(Person.class);
          
            //聚合函数select 后和from前
            //1.需求1：sum(age)
            //1.1先找出age列的路径
            /*Path<Integer> agePath = root.get("age");
            //1.2根据sum构建条件
            Expression<Integer> expression = cBuilder.sum(agePath);
            cQuery.select(expression);*/
            
            //2.需求2: count(age)
            Path<Long> agePath = root.get("age");
            //1.2根据sum构建条件
            Expression<Long> expression = cBuilder.count(agePath);
            cQuery.select(expression);
            Long sum = session.createQuery(cQuery).uniqueResult();
            System.out.println(sum); 

　　6.查询多个列

　　　　　　  CriteriaBuilder cBuilder=  session.getCriteriaBuilder();
            CriteriaQuery<Object[]> cQuery= cBuilder.createQuery(Object[].class);
            Root root = cQuery.from(Person.class);
          
            //3.1 先查找name和address属性所在的Path路径
            Path namePath=  root.get("name");
            Path addressPath=  root.get("address");
            //3.2. 最终目的：select  name,address from  com.qf.domainn.Person
            //方式一：cQuery.multiselect(namePath,addressPath);
            //方式二：cBuilder.array(namePath,addressPath)表示把所有条件放在一个array组成一个新的对象
            cQuery.select(cBuilder.array(namePath,addressPath));
            //4.执行查询
            List<Object[]> list = session.createQuery(cQuery).list();
            for (int i = 0; i < list.size(); i++) {
                Object[] objects = list.get(i);
                System.out.println(objects[0]+"---"+objects[1]);
            } 

　　在线查询和离线查询

　　　　在线查询(需要用到session)

　　　　 Session session = HibernateUtils.getCurrentSession();
        CriteriaBuilder builder = session.getCriteriaBuilder();
        CriteriaQuery<Person> createQuery = builder.createQuery(Person.class);
        Root<Person> root = createQuery.from(Person.class);
        Path<Person> path = root.get("ID");
        Predicate predicate = builder.equal(path, 4);
        createQuery.where(predicate);
        Query<Person> query = session.createQuery(createQuery);
        return query.uniqueResult(); 

　　　　离线查询

//1.创建一个DetachedCriteria类，并且指明要查询的持久化类
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Person.class);
//2.添加查询条件  Restrictions封装了大量的查询条件
detachedCriteria.add(Restrictions.idEq(id));
//执行数据增删查改操作
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
criteria.uniqueResult(); 

　　　　离线查询的聚合函数

　　　　 //1.创建一个DetachedCriteria类，并且指明要查询的持久化类
        DetachedCriteria  detachedCriteria= DetachedCriteria.forClass(Person.class);          
        //执行数据增删查改操作：
        Criteria c = detachedCriteria.getExecutableCriteria(session);
        /* c.setProjection(Projections.max("age"));
        c.setProjection(Projections.min("age"));
        c.setProjection(Projections.sum("age"));
        c.setProjection(Projections.avg("age"));*/
        c.setProjection(Projections.count("IDCard"));
        c.uniqueResult();

 

转载于:https://www.cnblogs.com/a77355699/p/7886501.html