Spring Data JPA之JpaSpecificationExecutor复杂动态查询实例

已于 2023-01-31 16:37:09 修改
阅读量1.8w 收藏 44
点赞数 18
分类专栏： # Spring Data JPA 文章标签： SpringData 动态查询
于 2018-11-28 11:18:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/J080624/article/details/84581231
版权

本文接SpringDataJPA查询方法那些事继续学习JpaSpecificationExecutor复杂动态查询。

【1】回顾简单查询

简单动态查询实例如下：

 public Page<User> test(){
        Sort sort = new Sort(Sort.Direction.DESC,"id");
        int page = 1;
        int pageSize = 5;
        Pageable pageable = PageRequest.of(page,pageSize,sort);

        //通常使用 Specification 的匿名内部类
        Specification<User> specification = new Specification<User>() {
            /**
             * @param *root: 代表查询的实体类.
             * @param query: 可以从中可到 Root 对象, 即告知 JPA Criteria 查询要查询哪一个实体类. 还可以
             * 来添加查询条件, 还可以结合 EntityManager 对象得到最终查询的 TypedQuery 对象.
             * @param *cb: CriteriaBuilder 对象. 用于创建 Criteria 相关对象的工厂. 当然可以从中获取到 Predicate 对象
             * @return: *Predicate 类型, 代表一个查询条件.
             */
            @Override
            public Predicate toPredicate(Root<User> root,
                                         CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path id = root.get("id");
                Predicate predicateId = cb.gt(id,5);
                return predicateId ;
            }
        };
        Page<User> userPage = userRepository.findAll(specification,  pageable);
        return userPage;
    }

只有一个属性，一个查询条件。

后台打印SQL如下所示：

Hibernate: select user0_.id as id1_1_, user0_.address_id as address_5_1_, user0_.add_id as add_id2_1_,
 user0_.email as email3_1_, user0_.last_name as last_nam4_1_ from tb_user user0_ 
 where user0_.id>5 order by user0_.id desc limit ?, ?
 
Hibernate: select count(user0_.id) as col_0_0_ from tb_user user0_ where user0_.id>5

【2】添加多个查询条件

比如这里再添加查询条件：id=5 and email="aa@qq.com"。

核心方法如下所示：

Specification<User> specification = new Specification<User>() {
     @Override
     public Predicate toPredicate(Root<User> root,
                                  CriteriaQuery<?> query, CriteriaBuilder cb) {
         Path id = root.get("id");
         Predicate predicateId = cb.gt(id,5);
         Path<User> email = root.get("email");
         Predicate predicateEmail = cb.equal(email, "aa@qq.com");
         Predicate endPredicate = cb.and(predicateId, predicateEmail);
         return endPredicate;
     }
 };

这里需要用到CriteriaBuilder提供的几个方法：

/**
     * Create a conjunction of the given boolean expressions.
     * @param x  boolean expression
     * @param y  boolean expression
     * @return and predicate
     */
    Predicate and(Expression<Boolean> x, Expression<Boolean> y);
    
    /**
     * Create a conjunction of the given restriction predicates.
     * A conjunction of zero predicates is true.
     * @param restrictions  zero or more restriction predicates
     * @return and predicate
     */
    Predicate and(Predicate... restrictions);

    /**
     * Create a disjunction of the given boolean expressions.
     * @param x  boolean expression
     * @param y  boolean expression
     * @return or predicate
     */
    Predicate or(Expression<Boolean> x, Expression<Boolean> y);

    /**
     * Create a disjunction of the given restriction predicates.
     * A disjunction of zero predicates is false.
     * @param restrictions  zero or more restriction predicates
     * @return or predicate
     */
    Predicate or(Predicate... restrictions);

连词And和OR，其中每种连词又有两种参数。 Predicate and(Predicate... restrictions);表示不定数参数Predicate使用And连接起来，通常你可以传入多个Predicate参数，但是建议传入一个数组。

修改上面核心方法如下：

Specification<User> specification = new Specification<User>() {
    @Override
    public Predicate toPredicate(Root<User> root,
                                 CriteriaQuery<?> query, CriteriaBuilder cb) {
        Path id = root.get("id");
        List<Predicate> predicates=new ArrayList<Predicate>();
        Predicate predicateId = cb.gt(id,5);
        predicates.add(predicateId);
        Path<User> email = root.get("email");
        Predicate predicateEmail = cb.equal(email, "aa@qq.com");
        predicates.add(predicateEmail);
        Predicate endPredicate = cb.and(predicates.toArray(new Predicate[predicates.size()]));
//                Predicate endPredicate = cb.and((Predicate[]) predicates.toArray());
        return endPredicate;
    }
};

这里toArray有两种方式：

 Object[] toArray();
 <T> T[] toArray(T[] a);
 
  * 相同点：都是作为数组和collection之间的桥梁；
  * 不同点：toArray()每次都会分配一个新的数组空间，toArray(T[] a);则在某些情况下节省分配成本。

即完整方法如下：

public Page<User> test17(){
     Sort sort = new Sort(Sort.Direction.DESC,"id");
     int page = 1;
     int pageSize = 5;
     Pageable pageable = PageRequest.of(page,pageSize,sort);

     Specification<User> specification = new Specification<User>() {
         @Override
         public Predicate toPredicate(Root<User> root,
                                      CriteriaQuery<?> query, CriteriaBuilder cb) {
             Path id = root.get("id");
             List<Predicate> predicates=new ArrayList<Predicate>();
             Predicate predicateId = cb.gt(id,5);
             predicates.add(predicateId);
             Path<User> email = root.get("email");
             Predicate predicateEmail = cb.equal(email, "aa@qq.com");
             predicates.add(predicateEmail);
             Predicate endPredicate = cb.and(predicates.toArray(new Predicate[predicates.size()]));
//                Predicate endPredicate = cb.and((Predicate[]) predicates.toArray());
             return endPredicate;
         }
     };
     Page<User> userPage = userRepository.findAll(specification,  pageable);
     return userPage;
 }

此时后台SQL打印如下：

Hibernate: select user0_.id as id1_1_, user0_.address_id as address_5_1_, user0_.add_id as add_id2_1_, 
user0_.email as email3_1_, user0_.last_name as last_nam4_1_ from tb_user user0_ 
where user0_.id>5 and user0_.email=? order by user0_.id desc limit ?, ?

Hibernate: select count(user0_.id) as col_0_0_ from tb_user user0_ where user0_.id>5 and user0_.email=?

【3】CriteriaBuilder.conjunction()和CriteriaBuilder.disjunction()

如果没有查询条件呢？即Predicate为null，CriteriaBuilder同样提供了两个方法conjunction()和disjunction()。

方法说明如下;

/**
 * Create a conjunction (with zero conjuncts).
 * A conjunction with zero conjuncts is true.
 * @return and predicate
 */
Predicate conjunction();

/**
 * Create a disjunction (with zero disjuncts).
 * A disjunction with zero disjuncts is false.
 * @return or predicate
 */
Predicate disjunction();

① CriteriaBuilder.conjunction()

修改方法如下所示：

public Page<User> test(){
    Sort sort = new Sort(Sort.Direction.DESC,"id");
    int page = 1;
    int pageSize = 5;
    Pageable pageable = PageRequest.of(page,pageSize,sort);

    Specification<User> specification = new Specification<User>() {
        @Override
        public Predicate toPredicate(Root<User> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {
            return cb.conjunction();
        }
    };
    Page<User> userPage = userRepository.findAll(specification,  pageable);
    return userPage;
}

后台SQL打印如下：

Hibernate: select user0_.id as id1_1_, user0_.address_id as address_5_1_, user0_.add_id as add_id2_1_, 
user0_.email as email3_1_, user0_.last_name as last_nam4_1_ from tb_user user0_ 
where 1=1 order by user0_.id desc limit ?, ?

//这里where子句为 where 1=1

Hibernate: select count(user0_.id) as col_0_0_ from tb_user user0_ where 1=1

② CriteriaBuilder.disjunction()

修改方法如下所示：

public Page<User> test18(){
    Sort sort = new Sort(Sort.Direction.DESC,"id");
    int page = 1;
    int pageSize = 5;
    Pageable pageable = PageRequest.of(page,pageSize,sort);

    Specification<User> specification = new Specification<User>() {
        @Override
        public Predicate toPredicate(Root<User> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {
            return cb.disjunction();
//                return cb.conjunction();
        }
    };
    Page<User> userPage = userRepository.findAll(specification,  pageable);
    return userPage;
}

此时SQL打印如下：

Hibernate: select user0_.id as id1_1_, user0_.address_id as address_5_1_, user0_.add_id as add_id2_1_, 
user0_.email as email3_1_, user0_.last_name as last_nam4_1_ from tb_user user0_ 
where 0=1 order by user0_.id desc limit ?, ?

//这里where子句为 where 0=1，肯定不会返回值了

Hibernate: select count(user0_.id) as col_0_0_ from tb_user user0_ where 0=1

【4】Path应用之对象属性为对象

Path是个什么？有三个关键词：对象引用；属性；路径。

源码如下所示：

/**
 * Represents a simple or compound attribute path from a 
 * bound type or collection, and is a "primitive" expression.
 *表示来自绑定类型或集合的简单或复合属性路径，并且是“原语”表达式。

 * @param <X>  the type referenced by the path
 *
 * @since Java Persistence 2.0
 */
public interface Path<X> extends Expression<X> {

    /** 
     * Return the bindable object that corresponds to the path expression.
     */
    Bindable<X> getModel(); 
    
    /**
     *  Return the parent "node" in the path or null if no parent.
     */
    Path<?> getParentPath();
	
    /**
     *  Create a path corresponding to the referenced single-valued attribute.
     */
    <Y> Path<Y> get(SingularAttribute<? super X, Y> attribute);

    /**
     *  Create a path corresponding to the referenced collection-valued attribute.
     */
    <E, C extends java.util.Collection<E>> Expression<C> get(PluralAttribute<X, C, E> collection);

    /**
     *  Create a path corresponding to the referenced map-valued attribute.
     */
    <K, V, M extends java.util.Map<K, V>> Expression<M> get(MapAttribute<X, K, V> map);

    /**
     *  Create an expression corresponding to the type of the path.
     *  @return expression corresponding to the type of the path
     */
    Expression<Class<? extends X>> type();


    //String-based:
    /**
     *  Create a path corresponding to the referenced attribute.
     */
    <Y> Path<Y> get(String attributeName);
}

上面使用的属性都是对象的简单属性，如user.id，user.email。但是如果属性为user.address.id呢？

修改方法如下所示：

public Page<User> test(){
    Sort sort = new Sort(Sort.Direction.DESC,"id");
    int page = 1;
    int pageSize = 5;
    Pageable pageable = PageRequest.of(page,pageSize,sort);

    Specification<User> specification = new Specification<User>() {
        @Override
        public Predicate toPredicate(Root<User> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {
            Path<Object> addressPath = root.get("address");
            //这里再次获取addressPath 中的属性
            Path<Object> id = addressPath.get("id");
            Predicate predicate = cb.equal(id, 1);
            return predicate;
        }
    };
    Page<User> userPage = userRepository.findAll(specification,  pageable);
    return userPage;
}

此时后台SQL打印如下：

Hibernate: select user0_.id as id1_1_, user0_.address_id as address_5_1_, user0_.add_id as add_id2_1_,
 user0_.email as email3_1_, user0_.last_name as last_nam4_1_ 
 from tb_user user0_ 
 where user0_.address_id=1 order by user0_.id desc limit ?, ?
 //where 子句 条件为user-address的外键列 address_id
 
Hibernate: select count(user0_.id) as col_0_0_ 
from tb_user user0_ 
where user0_.address_id=1

上面是我们手动处理–先获取addressPath，再获取其idPath，实际应用中通常处理如下：

// nested path translate, 如Task的名为"user.name"的filedName, 转换为Task.user.name属性
 String[] names = StringUtils.split("address.id", ".");
 Path expression = root.get(names[0]);
   for (int i = 1; i < names.length; i++) {
       expression = expression.get(names[i]);
   }

该实例有个特殊之处在于获取user.address时，外键列address_id对应address类的主键id。故而直接使用addressPath查询时后台打印SQL同上。但是如果fieldName为address.city呢？

修改方法如下所示：

public Page<User> test19(){
    Sort sort = new Sort(Sort.Direction.DESC,"id");
    int page = 1;
    int pageSize = 5;
    Pageable pageable = PageRequest.of(page,pageSize,sort);

    Specification<User> specification = new Specification<User>() {
        @Override
        public Predicate toPredicate(Root<User> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {
            Path<Object> addressPath = root.get("address");
            Path<Object> expression = addressPath.get("city");
            Predicate predicate = cb.equal(expression, "beijing");
            return predicate;
        }
    };
    Page<User> userPage = userRepository.findAll(specification,  pageable);
    return userPage;
}

后台SQL打印如下：

Hibernate: select user0_.id as id1_1_, user0_.address_id as address_5_1_, user0_.add_id as add_id2_1_, 
user0_.email as email3_1_, user0_.last_name as last_nam4_1_
from tb_user user0_ 
cross join tb_address address1_ 
where user0_.address_id=address1_.id and address1_.city=? order by user0_.id desc limit ?, ?
 
Hibernate: select count(user0_.id) as col_0_0_ 
from tb_user user0_ 
cross join tb_address address1_ 
where user0_.address_id=address1_.id and address1_.city=?

这里使用了cross join 参考博文：MySQL多表连接查询。

【5】CriteriaQuery实现多条件组合

如下图所示，常见SQL语法CriteriaQuery都提供了实现：
在这里插入图片描述

方法实例如下：

public Page<User> test(){
    Sort sort = new Sort(Sort.Direction.DESC,"id");
    int page = 1;
    int pageSize = 5;
    Pageable pageable = PageRequest.of(page,pageSize,sort);

    Specification<User> specification = new Specification<User>() {
        @Override
        public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            Path id = root.get("id");
            List<Predicate> predicates=new ArrayList<Predicate>();
            Predicate predicateId = cb.gt(id,5);
            predicates.add(predicateId);
            Path<User> email = root.get("email");
            Predicate predicateEmail = cb.equal(email, "aa@qq.com");
            predicates.add(predicateEmail);
            Predicate endPredicate = cb.and(predicates.toArray(new Predicate[predicates.size()]));
//                Predicate endPredicate = cb.and((Predicate[]) predicates.toArray());
            //添加where条件
            query.where(endPredicate);
            // //指定查询项，select后面的东西
            query.multiselect(id,email,cb.count(id));
            //分组
            query.groupBy(id);
            //排序
            query.orderBy(cb.asc(id));
            //筛选
            query.having(cb.greaterThan(id,0));
            //获取最终的Predicate
            Predicate restriction = query.getRestriction();
            return restriction;
        }
    };
    Page<User> userPage = userRepository.findAll(specification,  pageable);
    return userPage;
}

后台SQL打印如下：

Hibernate: select user0_.id as id1_1_, user0_.address_id as address_5_1_, user0_.add_id as add_id2_1_, 
user0_.email as email3_1_, user0_.last_name as last_nam4_1_ from tb_user user0_
 where user0_.id>5 and user0_.email=? 
 group by user0_.id 
 having user0_.id>0 
 order by user0_.id desc limit ?, ?
// 这里需要注意，排序根据pageable
 
Hibernate: select count(user0_.id) as col_0_0_ from tb_user user0_ 
where user0_.id>5 and user0_.email=? group by user0_.id having user0_.id>0

【6】CriteriaQuery与entityManager整合

前面提到过CriteriaQuery可以结合 EntityManager 对象得到最终查询的 TypedQuery 对象。

实例如下：

@PersistenceContext
private EntityManager entityManager;

public List<User> test22(){
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        //User指定了查询结果返回至自定义对象
        CriteriaQuery<User> query = cb.createQuery(User.class);
        Root<User> root = query.from(User.class);
        Path id = root.get("id");
        List<Predicate> predicates=new ArrayList<Predicate>();
        Predicate predicateId = cb.equal(id,1);
        predicates.add(predicateId);
        Path<User> email = root.get("email");
        Predicate predicateEmail = cb.equal(email, "aa@qq.com");
        predicates.add(predicateEmail);
        Predicate endPredicate = cb.and(predicates.toArray(new Predicate[predicates.size()]));
        //添加where条件
        query.where(endPredicate);
         //指定查询项，select后面的东西
//        query.multiselect(id,email);
        //分组
        query.groupBy(id);
        //排序
        query.orderBy(cb.asc(id));
        //筛选
        query.having(cb.greaterThan(id,0));
        TypedQuery<User> q = entityManager.createQuery(query);
        List<User> result = q.getResultList();
        for (User user : result) {
            //打印查询结果
            System.out.println(user.toString());
        }
        return result;
    }

后台SQL打印如下：

Hibernate: select user0_.id as id1_1_, user0_.address_id as address_5_1_, user0_.add_id as add_id2_1_,
 user0_.email as email3_1_, user0_.last_name as last_nam4_1_ from tb_user user0_ 
 where user0_.id=1 and user0_.email=? 
 group by user0_.id 
 having user0_.id>0 
 order by user0_.id asc

//关联查询Address 
Hibernate: select address0_.id as id1_0_0_, address0_.city as city2_0_0_, address0_.province as province3_0_0_
from tb_address address0_ where address0_.id=?

博文项目代码下载地址：GitHub项目地址

流烟默
关注
专栏目录
HIBERNATE:disjunction和conjunction构造复杂的查询条件.
Stone.鱼儿的博客
10-16 2498
工作中小结：(1) 查询某个批次的数据，也还可以输入州/县/医疗机构（这三个是或者的关系）；//disjunction或者 关系：【 批次的数据  &amp;&amp;  （州   ||  县   ||   医疗机构）】 关系（用下面方法一：） (2).还有一种情况：是下拉框可以选择条件查询，可以选择多个条件进行查询（这种是并且的关系）；//conjunction并且 关系： 【批次的数据...
Spring Data JPA：解析CriteriaBuilder
manong20210713的博客
08-29 1736
源码 在Spring Data JPA相关的文章[地址]中提到了有哪几种方式可以构建Specification的实例，该处需要借助CriteriaBuilder，回顾一下Specification中toPredicate方法的定义，代码如下： /** * Creates a WHERE clause for a query of the referenced entity in form of a {@link Predicate} for the given * {@li
jpa 去重_spring boot jpa 表关联查询分组 group by 去重
weixin_39630735的博客
02-17 467
使用jpa操作多张表进行关联查询时，有重复数据需要分组去重1)确定主表：将有重复数据的表格作为主表，表明关系public class AttendanceRuleTypeItem implements Serializable {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long itemId;private Str...
Hibernae的Criteria 查询(十七)
两个蝴蝶飞
04-09 744
东家蝴蝶西家飞，白骑少年今日归。 愿，所有迷茫的人，都不再迷茫的，愿，所有努力工作的人，都可以得到应有的回报，愿，所有的人，都可以找到回家的方向，愿，再无苦痛，再无离别。 上一章简单介绍了Hibernat的HQL语句查询(十六),如果没有看过,请观看上一章 一. Criteria 查询 hql查询是用类似于Sql语句的形式进行相应的查询，Criteria 是用类的形式进行相应的处理。 所用的例子...
JPA多表查询
最新发布
m0_50272029的博客
09-06 394
结果集接口方法更灵活，可以通过自定义的查询结果接口来选择需要返回的字段。关联映射方法更方便管理关系，可以直接在实体类中通过@ManyToOne或@OneToMany等注解来实现关联查询。这两种方式在不同的场景下各有优势，具体选择哪种方式取决于项目的需求。
CriteriaBuilder 封装查询
qq_27088383的博客
11-27 5335
package com.topsec.tsm.util; import com.google.gson.reflect.TypeToken; import com.topsec.tsm.common.WhereEqual; import org.apache.commons.lang.StringUtils; import org.springframework.data.jpa.domain...
SpringDataJpa学习(五) jpql介绍及查询
爱喵的Hero的博客
03-06 397
JPA中的复杂查询 JPQL 全称 Java Persistence Query Language 基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。 其特征与原生的sql语句类似...
SpringData专题(六)-JPA中的复杂查询
专业的计算机毕业设计指南
07-06 960
JPQL全称Java Persistence Query Language 基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。 其特征与原生SQL语句类似，并且完全面向对象，通过类...
JPA中,QBC查询,JpaSpecificationExecutor,Specification总结
JavaMyDream的博客
04-07 712
【代码】JPA中,QBC查询,JpaSpecificationExecutor,Specification总结。
SpringData JPA的复杂查询
OceanStar的博客
01-18 256
查询 调用接口方法查询 jpql查询 使用@Query注解，结合JPQL的语句方式完成查询 /** * JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作 * JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作） */ public interface CustomerDao extends...
spring data jpa复杂查询
01-30 243
我们只要实现Specification&lt;User&gt;接口就可以用来复杂的查询 引入类 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.domain.Example; import org.springframework.stereotype....
SpringDataJpa 动态复杂查询NativeQuery
12-22
SpringDataJpa 动态复杂查询NativeQuery emm挺长时间没更新了，最近在忙项目，外加搬家,后续会继续更新 遇到一个复杂的sql查询，在不通过外键关联的情况下，只能选择使用原生sql的方式查询，但是遇到一个极其XX的问题 首先去了Spring官方和一些博客调查了一下，感觉Jpa还是偏冷门讨论的不多，一搜索好多还是15年的信息… 当前SpringBoot版本信息 2.2.5.RELEASE 如果使用网上大家说的方式会出现这个异常,但是都说好像可以用，可能跟版本有关系，或者网上说的有问题 List list = nativeQuery.unwrap(NativeQuer
Spring Data JPA中的动态查询实例
08-30
要使用 Spring Data JPA 的动态查询功能，我们需要让 Repository 接口继承 `JpaSpecificationExecutor`。这是一个泛型接口，用于处理动态查询。例如： ```java public interface MyRepository extends Jpa...
Spring Data JPA实现动态条件与范围查询实例代码
08-30
Spring Data JPA实现动态条件与范围查询实例代码 本文主要介绍了使用Spring Data JPA实现动态条件与范围查询实例代码的方法。该方法可以实现既支持动态条件查询又支持范围查询的功能。 首先，我们需要定义一个...
spring data jpa 的Specifications动态查询
02-07
首先，我们需要导入`org.springframework.data.jpa.domain.Specifications`包，并创建一个`Specification`实例。例如，如果我们有一个`User`实体类，我们想根据用户名进行查询，可以这样做： ```java public class ...
Spring Data JPA实现分页Pageable的实例代码
08-29
Spring Data JPA实现分页Pageable的实例代码 Spring Data JPA是基于Java Persistence API（JPA）的数据访问技术，提供了简洁的数据访问方式。其中，Pageable是Spring Data JPA中的一种分页机制，允许开发者轻松实现...
Spring Data JPA 实现多表关联查询的示例代码
08-27
在Spring Data JPA中，多表关联查询是一个常见的需求，特别是在复杂的业务场景下。本文将主要探讨通过创建结果集接口的方式来实现多表关联查询的方法，而不是依赖Hibernate的级联查询。 首先，我们要了解Spring ...
Spring Data Jpa的复杂查询
qq_42488087的博客
12-10 163
Spring Data Jpa的查询 SpringJpa的复杂查询 借助接口中定义好的方法完成查询 /* * 统计查询:查询客户的总数量 * */ @Test public void testCount(){ long count = customerDao.count(); System.out.println(count); } /* * ...
criteriaBuilder.conjunction()
05-28
`criteriaBuilder.conjunction()`是Criteria API中的一个方法，用于创建一个空的`Conjunction`对象，表示一个AND连接的查询条件，即所有条件都必须满足。在Criteria API中，`Conjunction`表示一个AND连接的查询条件，`Disjunction`表示一个OR连接的查询条件，可以通过这两个对象来构建复杂的查询条件。 `criteriaBuilder.conjunction()`返回的是一个`Predicate`对象，表示一个空的AND连接的查询条件。可以通过`CriteriaBuilder`的其他方法，如`equal()`、`between()`、`like()`等来构建具体的查询条件，然后使用`and()`方法将它们连接起来，最终形成一个完整的查询条件。例如： ```java Predicate predicate1 = criteriaBuilder.equal(root.get("name"), "张三"); Predicate predicate2 = criteriaBuilder.between(root.get("age"), 18, 30); Predicate predicate3 = criteriaBuilder.like(root.get("address"), "%北京%"); Predicate predicate = criteriaBuilder.conjunction().and(predicate1).and(predicate2).and(predicate3); ``` 上述代码表示查询条件为：`name`为"张三"、`age`在18到30之间、`address`中包含"北京"。这三个条件都必须满足，才能匹配查询结果。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

流烟默

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值