详解Jpa动态复杂条件查询,查询指定字段、并包括sum、count、avg等数学运算,包括groupBy分组

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/tianyaleixiaowu/article/details/90704969

Jpa是我一直推荐在Springboot及微服务项目中使用的数据库框架,并由于官方的并不是十分友好和易用的api,导致很多人使用起来并不方便,下面就来展示一下我对api进行了封装后的代码。大大减轻了使用难度。

效果展示

首先我们直接来看最终的结果:

譬如有个entity叫PtActivity,它有一个Repository。

public interface PtActivityRepository extends JpaRepository<PtActivity, Long>,
        JpaSpecificationExecutor<PtActivity> {

}

继承了JpaSpecificationExecutor后,它拥有了这样一个方法:

Page<T> findAll(@Nullable Specification<T> var1, Pageable var2);

即传入一个Specification对象,即可完成条件查询,来看一个简单的例子。MySpecification就是封装好的工具类,能够大幅简化jpa构建条件查询的操作。

  private Page<PtActivity> find(String states, String name, String begin, String end, Pageable pageable) {
        MySpecification<PtActivity> mySpecification = new MySpecification<>();
        String[] stateArray = states.split(",");

        if (begin != null) {
            mySpecification.add(Restrictions.gte("createTime", CommonUtil.beginOfDay(begin), true));
        }
        if (end != null) {
            mySpecification.add(Restrictions.lte("createTime", CommonUtil.endOfDay(end), true));
        }

        mySpecification.add(Restrictions.in("state", Arrays.asList(stateArray), true));
        mySpecification.add(Restrictions.like("name", name, true));
        mySpecification.add(Restrictions.eq("deleteFlag", false, true));
        return ptActivityManager.findAll(mySpecification, pageable);
    }

该demo构建了一个查询createTime大于begin,小于end,并且state字段的值,在某个数组范围内,并且name字段like一个传来的值,并且deleteFlag字段等于false的查询条件。如果哪个字段没传值,就忽略该筛选条件。

这样代码看起来就很容易理解,下面看一个稍微复杂点的例子:

public void find() {
        MySpecification<PtActivity> criteriaQueryBuilder = new MySpecification<>();
        criteriaQueryBuilder.addAll(Restrictions.pickSome("id","state"));
        //criteriaQueryBuilder.add(Restrictions.sum("id"));
        //criteriaQueryBuilder.add(Restrictions.max("state"));
        criteriaQueryBuilder.add(Restrictions.gte("createTime", CommonUtil.beginOfDay("2019-05-01"), true));
        criteriaQueryBuilder.add(Restrictions.lte("createTime", CommonUtil.endOfDay("2019-05-31"), true));

        //criteriaQueryBuilder.add(Restrictions.groupBy("state"));

        List<Tuple> tuples = criteriaQueryBuilder.findResult(em, PtActivity.class);
        for (Tuple tuple : tuples) {
            Object count = tuple.get(0);
            System.out.println(count);
        }
    }

该方法完成了只查询id、state字段,并且createTime在某个时间范围内的。如果把注释放开,就是查询sum(id),max(state) 并且groupBy state字段。

详细解析

何为Specification

还是回到Jpa的这个接口,可以看到,要完成一次查询,主要的工作就是构建Specification,而Specification接口中,主要就是一个方法即toPredicate方法。这个方法就是构建select * from table where xxxxx语句的where条件。其他的not、and都是对Specification的一些交集、并集,也就是where语句里的and、or。

public interface JpaSpecificationExecutor<T> {
    Optional<T> findOne(@Nullable Specification<T> var1);

    List<T> findAll(@Nullable Specification<T> var1);

    Page<T> findAll(@Nullable Specification<T> var1, Pageable var2);

    List<T> findAll(@Nullable Specification<T> var1, Sort var2);

    long count(@Nullable Specification<T> var1);
}
public interface Specification<T> extends Serializable {
    long serialVersionUID = 1L;

    static <T> Specification<T> not(Specification<T> spec) {
        return Specifications.negated(spec);
    }

    static <T> Specification<T> where(Specification<T> spec) {
        return Specifications.where(spec);
    }

    default Specification<T> and(Specification<T> other) {
        return Specifications.composed(this, other, CompositionType.AND);
    }

    default Specification<T> or(Specification<T> other) {
        return Specifications.composed(this, other, CompositionType.OR);
    }

    @Nullable
    Predicate toPredicate(Root<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3);
}

我们可以这样理解,要做的一切事情,就是为了构建Predicate对象,该对象组合了N多个查询子语句。

所以我们要做的就是根据前端传来的字段构建多个Predicate对象,再将这多个Predicate组装成一个Predicate对象,就完成了条件查询的构建。

如果采用官方api来完成一次复杂条件查询,代码可能是下面这样的:

 public void findTemp() {
        ptActivityManager.findAll(new Specification<PtActivity>() {
            @Override
            public Predicate toPredicate(Root<PtActivity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder
                    criteriaBuilder) {
                Path idPath = root.get("id");
                Predicate predicate1 = criteriaBuilder.equal(idPath, "12345");

                Path statePath = root.get("state");
                Predicate predicate2 = criteriaBuilder.equal(statePath, "1");

                return criteriaBuilder.and(predicate1, predicate2);
            }
        });
    }

猛一看,其实还是挺乱的,什么root、criteriaQuery、criteriaBuilder都是些什么鬼,怎么组建的Predicate,新手一看,比较茫然。下面就来解惑一下,这些都是什么鬼。

解析原生的底层查询

事实上,要完成一次条件查询,它的流程是这样的:

public List<Tuple> findResult(EntityManager entityManager, Class<T> t) {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Tuple> criteriaQuery = criteriaBuilder.createTupleQuery();
        Root<T> root = criteriaQuery.from(t);

        if (!selectorList.isEmpty()) {
            criteriaQuery.multiselect(buildSelections(criteriaBuilder, root));
        }
        if (!criterionList.isEmpty()) {
            criteriaQuery.groupBy(buildGroupBy(root));
        }
        criteriaQuery.where(toPredicate(root, criteriaQuery, criteriaBuilder));

        return entityManager.createQuery(criteriaQuery).getResultList();
    }

先获取EntityManager,然后从EntityManager中获取CriteriaBuilder,再从CriteriaBuilder中创建一个CriteriaQuery,然后将各个条件都组合到CriteriaQuery中,最终通过entityManager.createQuery(criteriaQuery).getResultList()来获取到查询结果。

譬如一次查询是这样的:select a, b, sum(c) from table where a > 0 and c < 1 group by a

那么a、b、sum(c)都属于CriteriaQuery中的select参数,where后面的条件都属于CriteriaQuery的where后的参数,groupBy和having都属于CriteriaQuery的对应的参数。最终组合成一个丰满的CriteriaQuery,并由EntityManager来createQuery并获取结果集。

可以看到里面有非常完整的构建的方法。我们要做的就是将select后面的组合成Selection对象,where后面的组合成Predicate对象,having、groupBy什么的按照属性类型组合即可。

这些Selection、Predicate对象怎么构建呢,就是靠CriteriaBuilder。

CriteriaBuilder里的箭头的方法,都是构建Selection的。

这几个都是构建Predicate的。

至于用来做having,groupBy的更简单,直接用root.get("字段名")就可以了。

知道了这些,问题就更简单了,我们要做的就是把构建这3个组合的方法给封装起来就好了。不然用上面官方提供的这些,很不方便。

JpaSpecificationExecutor怎么理解

我们知道,平时用这个findAll(Specification var1)时,只需要构建好Predicate即可。

里面的root,CriteriaQuery和builder都已经被Jpa赋值好了,我们只需要关注Predicate的构建,也就是说,这个findAll方法只能完成where条件的构建,而不能实现select后面属性的选择和groupBy的构建。

jpa怎么给root什么的赋值的呢,其实是这样的,Jpa是一种规范,Hibernate、OpenJPA对其进行了实现,譬如Springboot默认使用Hibernate实现Jpa,也就是上一小节提到的EntityManager那一套,Hibernate创建了CriteriaQuery和Builder和root,并且将值赋给上图的各参数中,供用户使用,来构建where条件需要的Predicate对象。

 

编码封装API

以上如果都理解了,那么就可以来编码了,我们做好构建Selection、Predicate、Expression的封装就可以了,就能完成所有的单表复杂查询。

定义一个终极接口:

/**
 * 适用于对单表做sum、avg、count等运算时使用,并且查询条件不固定,需要动态生成predicate</p>
 * 如select sum(a), count(b), count distinct(c) from table where a = ? & b = ?
 *
 * @author wuweifeng wrote on 2018/1/3.
 */
public interface CriteriaQueryBuilder<T> extends Specification<T> {

    /**
     * 构建select字段
     */
    List<Selection<?>> buildSelections(CriteriaBuilder builder, Root<T> root);

    /**
     * 构建groupBy字段
     */
    List<Expression<?>> buildGroupBy(Root<T> root);

    /**
     * 获取返回的结果集
     */
    List<Tuple> findResult(EntityManager entityManager, Class<T> t);
}
      

只要完成了这4个(包括Specification里的toPredicate)方法,就能从findResult里得到你想要的结果集。

提供一个实现类:

package com.maimeng.jd.global.specify;

import com.maimeng.jd.global.specify.simple.IExpression;
import com.maimeng.jd.global.specify.simple.IPredicate;
import com.maimeng.jd.global.specify.simple.ISelector;

import javax.persistence.EntityManager;
import javax.persistence.Tuple;
import javax.persistence.criteria.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 定义一个查询条件容器,用于构建where条件、select字段、groupBy字段
 *
 * @author wuwf   on 17/6/6.
 */
public class NbQueryBuilder<T> implements CriteriaQueryBuilder<T> {
    private List<IPredicate> criterionList = new ArrayList<>();

    private List<ISelector> selectorList = new ArrayList<>();

    private List<IExpression> expressionList = new ArrayList<>();

    @Override
    public List<Selection<?>> buildSelections(CriteriaBuilder builder, Root<T> root) {
        List<Selection<?>> selections = new ArrayList<>();
        for (ISelector iSelector : selectorList) {
            selections.add(iSelector.getSelection(root, builder));
        }
        return selections;
    }

    @Override
    public List<Expression<?>> buildGroupBy(Root<T> root) {
        List<Expression<?>> expressions = new ArrayList<>();
        for (IExpression expression : expressionList) {
            expressions.add(expression.getGroupBy(root));
        }
        return expressions;
    }

    @Override
    public Predicate toPredicate(Root<T> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
        if (!criterionList.isEmpty()) {
            List<Predicate> predicates = new ArrayList<>();
            for (IPredicate c : criterionList) {
                predicates.add(c.toPredicate(root, criteriaBuilder));
            }
            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
        }
        return criteriaBuilder.conjunction();
    }

    @Override
    public List<Tuple> findResult(EntityManager entityManager, Class<T> t) {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Tuple> criteriaQuery = criteriaBuilder.createTupleQuery();
        Root<T> root = criteriaQuery.from(t);

        if (!selectorList.isEmpty()) {
            criteriaQuery.multiselect(buildSelections(criteriaBuilder, root));
        }
        if (!criterionList.isEmpty()) {
            criteriaQuery.groupBy(buildGroupBy(root));
        }
        criteriaQuery.where(toPredicate(root, criteriaQuery, criteriaBuilder));

        return entityManager.createQuery(criteriaQuery).getResultList();
    }

    /**
     * 增加简单条件表达式
     */
    public void add(ISelector iSelector) {
        if (iSelector != null) {
            selectorList.add(iSelector);
        }
    }

    /**
     * 增加where子语句
     */
    public void add(IPredicate iPredicate) {
        if (iPredicate != null) {
            criterionList.add(iPredicate);
        }
    }

    /**
     * 增加尾部语句
     */
    public void add(IExpression iExpression) {
        if (iExpression != null) {
            expressionList.add(iExpression);
        }
    }

    public <R extends ISelector> void addAll(List<R> selectors) {
        selectorList.addAll(selectors);
    }
}

最终在service里使用起来就是这样的:

 public void find() {
        NbQueryBuilder<PtActivity> criteriaQueryBuilder = new NbQueryBuilder<>();
        criteriaQueryBuilder.addAll(Restrictions.pickSome("id", "state"));
        //criteriaQueryBuilder.add(Restrictions.sum("id"));
        //criteriaQueryBuilder.add(Restrictions.max("state"));
        criteriaQueryBuilder.add(Restrictions.gte("createTime", CommonUtil.beginOfDay("2019-05-01"), true));
        criteriaQueryBuilder.add(Restrictions.lte("createTime", CommonUtil.endOfDay("2019-05-31"), true));

        //criteriaQueryBuilder.add(Restrictions.groupBy("state"));

        List<Tuple> tuples = criteriaQueryBuilder.findResult(em, PtActivity.class);
        for (Tuple tuple : tuples) {
            Object count = tuple.get(0);
            System.out.println(count);
        }
    }

当然,如果你不需要构建Selection、groupBy时,也可以只构建Predicate,然后使用jpa的findAll()方法即可。

代码结构如下,都是一些对构建条件的封装和一个Restrictions的工厂类。

由于代码很多,我就不一一贴了。能理解全文的,自己应该也能写出来。

写不出来的,可以去我的开源区块链平台项目https://gitee.com/tianyalei/md_blockchain里找到联系方式索要代码。

需注意,该封装,是针对于单表用的,并没有对多表联合查询做封装,因为我从来只有单表操作,从不做任何外键以及多表级联查询。

 

 

 

展开阅读全文

没有更多推荐了,返回首页