Java Spring数据JPA规范groupBy

对不起，我先说英语

我想使用jpa来分组，比如：从数据流中选择scrip，dustup，count（*）按scrip分组，dstip。 因此，编写以下代码：

public class DataflowSpec {
    public static Specification<Dataflow> search(final String[] group, final String[] sort, final String[] desc) {
        return new Specification<Dataflow>() {
            @Override
            public Predicate toPredicate(Root<Dataflow> root1, CriteriaQuery<?> query1, CriteriaBuilder builder) {
                // TODO Auto-generated method stub

                CriteriaQuery<Tuple> query = builder.createQuery(Tuple.class);

                Root<Dataflow> root = query.from(Dataflow.class);


                query.multiselect(root.get("srcip"), root.get("dstip"), builder.count(root));

                query.groupBy(root.get("srcip"), root.get("dstip"));

                query.orderBy(builder.desc(root.get("srcip").as(BigInteger.class)));
                return query.getRestriction();
            }
        };
    }
}

休眠：

select
    count(dataflow0_.id) as col_0_0_ 
from
    Dataflow dataflow0_

select
    dataflow0_.id as id1_2_,
    dataflow0_.byteall as byteall2_2_,
    dataflow0_.bytedn as bytedn3_2_,
    dataflow0_.byteup as byteup4_2_,
    dataflow0_.dstip as dstip5_2_,
    dataflow0_.dstport as dstport6_2_,
    dataflow0_.engieid as engieid7_2_,
    dataflow0_.flag as flag8_2_,
    dataflow0_.netid as netid9_2_,
    dataflow0_.pkgall as pkgall10_2_,
    dataflow0_.pkgdn as pkgdn11_2_,
    dataflow0_.pkgup as pkgup12_2_,
    dataflow0_.protocolid as protoco17_2_,
    dataflow0_.rtt as rtt13_2_,
    dataflow0_.srcip as srcip14_2_,
    dataflow0_.srcport as srcport15_2_,
    dataflow0_.updatetime as updatet16_2_ 
from
    Dataflow dataflow0_ limit ?

---

那么，如何解决呢？谢谢

规范不支持groupBy。

---

SimpleParepository替换了query.select/multiselect by query.select（root）

您可以通过

规范实现spring数据
分组，只需遵循

或适用于2.0之前或之后的版本。对于单个存储库操作，这两个版本具有相同的解决方案。对于*all*存储库解决方案，在2.0使用之前，而在2.0之后，将省略此工厂bean操作

public Map<AlarmMsg.AlarmLevel, Long> testSpecification(String neId) {

    SingularAttribute attribute = AlarmData_.isClear;
    Specification<Object> where = Specification.where(
        (root, query, cb) -> cb.equal(root.get(attribute), false)
    );

    final Map<AlarmMsg.AlarmLevel, Long> result = alarmDataRepository.groupAndCount(AlarmData_.alarmLevel, where );
    return result;
}

公共映射测试规范（字符串neId）{
SingularAttribute属性=AlarmData_u2;isClear；
规格where=规格where(
（root，query，cb）->cb.equal（root.get（属性），false）
);
最终映射结果=alarmDataRepository.groupAndCount（AlarmData_u2;.alarmLevel，其中）；
返回结果；
}

存储库：

public interface AlarmDataRepository extends JpaRepository<AlarmData, Long>, JpaSpecificationExecutor<AlarmData>, CustomizedGroupCountRepository {

公共接口AlarmDataRepository扩展了JpaRepository、JpaSpecificationExecutor、CustomizedGroupCountRepository{

片段存储库及其实现：

public interface CustomizedGroupCountRepository {
    Map<AlarmMsg.AlarmLevel, Long> groupAndCount(SingularAttribute singularAttribute, Specification where);
}

public class CustomizedGroupCountRepositoryImpl implements CustomizedGroupCountRepository {
    private final EntityManager entityManager;


public CustomizedGroupCountRepositoryImpl(EntityManager entityManager) {
    Assert.notNull(entityManager, "EntityManager must not be null!");
    this.entityManager = entityManager;
}

@Override
public Map<AlarmMsg.AlarmLevel, Long> groupAndCount(SingularAttribute singularAttribute, Specification where) {
    final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    final CriteriaQuery<Tuple> query = criteriaBuilder.createQuery(Tuple.class);
    final Root<AlarmData> root = query.from(AlarmData.class);
    final Path<AlarmMsg.AlarmLevel> expression = root.get(singularAttribute);
    query.multiselect(expression, criteriaBuilder.count(root));
    query.select(criteriaBuilder.tuple(expression, criteriaBuilder.count(root)));
    query.where(where.toPredicate(root, query, criteriaBuilder));
    query.groupBy(expression);
    final List<Tuple> resultList = entityManager.createQuery(query).getResultList();
    return resultList.stream()
        .collect(toMap(
            t -> t.get(0, AlarmMsg.AlarmLevel.class),
            t -> t.get(1, Long.class))
        );
    }
}

public接口定制groupcountrepository{
Map groupAndCount（SingularAttribute，规格，其中）；
}
公共类CustomizedGroupCountRepositoryImpl实现CustomizedGroupCountRepository{
私人最终实体管理人实体管理人；
公共自定义组CountRepositoryImpl（EntityManager EntityManager）{
Assert.notNull（entityManager，“entityManager不能为null！”）；
this.entityManager=entityManager；
}
@凌驾
公共映射groupAndCount（SingularAttribute，规格，其中）{
final CriteriaBuilder CriteriaBuilder=entityManager.getCriteriaBuilder（）；
最终的CriteriaQuery查询=criteriaBuilder.createQuery（Tuple.class）；
最终根=query.from（AlarmData.class）；
最终路径表达式=root.get（singularAttribute）；
multiselect（表达式，criteriaBuilder.count（根））；
选择（criteriaBuilder.tuple（表达式，criteriaBuilder.count（根））；
query.where（where.toPredicate（root、query、criteriaBuilder））；
query.groupBy（表达式）；
最终列表resultList=entityManager.createQuery（query.getResultList（）；
返回resultList.stream（）
.收集(
t->t.get（0，AlarmMsg.AlarmLevel.class），
t->t.get（1，Long.class））
);
}
}

一对所有存储库和一对单个存储库之间的主要区别是，在一对单个存储库的情况下，它可以访问真实的实体类，如spring参考文档中的
User
。因此，您不需要使用泛型类型来引用任何类型的实体，而在一对所有存储库的情况下，它的实现是自定义方法使用泛型类型，其类信息可以（或必须）从注入的
JpaEntityInformation
中获得，如第3.6节所述。
对于仍在寻找如何在Spring jpa规范中应用“分组依据”的人，您可以使用以下代码片段：


...
private Dataflow dataflowFilter;

@Override
public Predicate toPredicate(Root<Dataflow> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
    Predicate predicate = cb.conjunction();
    predicate.getExpressions().add(cb.equal(root.get("id"), dataflowFilter.getId()));
    ...
    cq.groupBy(root.get("id"));
    ...
    return predicate;
}


...
专用数据流数据流过滤器；
@凌驾
公共谓词toPredicate（Root<Dataflow> Root，CriteriaQuery<？> cq，CriteriaBuilder cb）{
谓词=cb.conjunction（）；
predicate.getExpressions（）.add（cb.equal（root.get（“id”），dataflowFilter.getId（））；
...
groupBy（root.get（“id”）；
...
返回谓词；
}
您用JPQL试过了吗？因此您返回WHERE子句的谓词（到某处）…SELECT子句部分会发生什么情况？不，我只想使用specification.Stockton。我希望SELECT使用两个字段：srcip，dstip。但它返回所有字段。
specification
用于
where
部分。
CriteriaQuery
用于
SELECT