Spring Data结合Specification与分页实现分组查询方案咨询

现有基于item维度的数据库视图，数据关系如下：

• 单个item归属于1个container，1个container可包含多个item
• 每个item对应1个location，多个item可关联同一个location

视图示例数据：

id_item   id_container   id_location   container_name   container_code   amount
'I1'      'C1'           'L1'          'container #01'  'c01'            10
'I2'      'C1'           'L1'          'container #01'  'c01'             5
'I3'      'C1'           'L2'          'container #01'  'c01'            25
'I4'      'C2'           'L3'          'container #02'  'c02'            30

需要实现按container维度分组查询，分组结果映射的GroupByContainerEntity结构如下：

public class GroupByContainerEntity {
    private String idContainer;
    private String containerName;
    private String containerCode;
    private List<String> locations; // 也可使用String类型存储逗号分隔的location ID
    private Integer sumAmount;
    private Integer countItems;
}

现有Repository层基础定义：

public interface IGroupByContainerRepository extends JpaRepository<GroupByContainerEntity, String>, JpaSpecificationExecutor<GroupByContainerEntity> {
}

硬性要求：

• 必须支持传入自定义Specification，实现灵活筛选（比如筛选指定范围的location、container）
• 必须支持分页、按字段排序（比如按containerName排序）
• 不能使用固定写死的原生查询，期望调用形式兼容groupByContainerRepository.findAll(Specification, Pageable)的使用习惯

原生Spring Data JPA默认不支持Specification直接作用于分组聚合查询，可通过以下两种方案实现需求：

方案1：自定义Repository实现（无额外依赖，推荐） #

核心思路是拆分查询逻辑，先按分页、筛选条件查出当前页的container ID集合，再对该集合做聚合查询，完全兼容现有业务调用逻辑，无第三方依赖。

1. 首先新建和item视图一一对应的基础实体，作为Specification的查询载体：

   @Entity
   @Table(name = "你的item视图表名")
   public class ItemViewEntity {
       @Id
       private String idItem;
       private String idContainer;
       private String idLocation;
       private String containerName;
       private String containerCode;
       private Integer amount;
       // 补全getter/setter、@Column注解即可
   }
   

2. 调整Repository接口，拆分基础JPA接口和自定义方法：

   public interface IGroupByContainerRepository extends JpaRepository<ItemViewEntity, String>,
           JpaSpecificationExecutor<ItemViewEntity>, CustomGroupByContainerRepository {
   }
   
   public interface CustomGroupByContainerRepository {
       Page<GroupByContainerEntity> findAll(Specification<ItemViewEntity> spec, Pageable pageable);
   }
   

3. 实现自定义Repository逻辑，拆分成分页查ID、聚合查数据两步：

   @Repository
   public class CustomGroupByContainerRepositoryImpl implements CustomGroupByContainerRepository {
       @PersistenceContext
       private EntityManager entityManager;
   
       @Override
       public Page<GroupByContainerEntity> findAll(Specification<ItemViewEntity> spec, Pageable pageable) {
           CriteriaBuilder cb = entityManager.getCriteriaBuilder();
   
           // 查询符合条件的去重container总数，用于分页总条数计算
           CriteriaQuery<Long> countCb = cb.createQuery(Long.class);
           Root<ItemViewEntity> countRoot = countCb.from(ItemViewEntity.class);
           Predicate countPredicate = spec.toPredicate(countRoot, countCb, cb);
           countCb.select(cb.countDistinct(countRoot.get("idContainer")))
                   .where(countPredicate);
           Long total = entityManager.createQuery(countCb).getSingleResult();
           if (total == 0) {
               return new PageImpl<>(Collections.emptyList(), pageable, 0);
           }
   
           // 查询当前分页对应的container ID列表，支持排序
           CriteriaQuery<String> idQuery = cb.createQuery(String.class);
           Root<ItemViewEntity> idRoot = idQuery.from(ItemViewEntity.class);
           Predicate idPredicate = spec.toPredicate(idRoot, idQuery, cb);
           idQuery.select(idRoot.get("idContainer"))
                   .where(idPredicate)
                   .groupBy(idRoot.get("idContainer"));
           // 拼接排序逻辑
           if (pageable.getSort().isSorted()) {
               List<Order> orders = new ArrayList<>();
               pageable.getSort().forEach(order -> {
                   Path<?> sortPath = idRoot.get(order.getProperty());
                   orders.add(order.isAscending() ? cb.asc(sortPath) : cb.desc(sortPath));
               });
               idQuery.orderBy(orders);
           }
           List<String> currentPageContainerIds = entityManager.createQuery(idQuery)
                   .setFirstResult((int) pageable.getOffset())
                   .setMaxResults(pageable.getPageSize())
                   .getResultList();
   
           // 对当前页的container做聚合查询
           String nativeAggSql = """
               SELECT 
                   id_container AS idContainer,
                   MAX(container_name) AS containerName,
                   MAX(container_code) AS containerCode,
                   GROUP_CONCAT(DISTINCT id_location SEPARATOR ',') AS locationStr,
                   SUM(amount) AS sumAmount,
                   COUNT(DISTINCT id_item) AS countItems
               FROM 你的item视图表名
               WHERE id_container IN :containerIds
               GROUP BY id_container
               """;
           // 可根据pageable的Sort参数动态拼接ORDER BY子句，和第二步排序规则保持一致
           List<GroupByContainerEntity> result = entityManager.createNativeQuery(nativeAggSql, GroupByContainerEntity.class)
                   .setParameter("containerIds", currentPageContainerIds)
                   .getResultList();
           // 如果locations用List类型，把逗号分隔的字符串转成List即可
           result.forEach(item -> {
               if (item.getLocationStr() != null) {
                   item.setLocations(Arrays.asList(item.getLocationStr().split(",")));
               }
           });
           return new PageImpl<>(result, pageable, total);
       }
   }
   

   注意：GroupByContainerEntity不要加@Entity注解，用@SqlResultSetMapping做原生查询结果映射，或者用构造函数投影，避免JPA将其识别为普通持久化实体。

方案2：Blaze Persistence扩展实现（适合允许引入第三方依赖的场景） #

如果项目允许引入第三方组件，可以直接使用Blaze Persistence的Spring Data JPA扩展，该组件原生支持Specification作用于分组聚合查询，内置分页能力，不需要手动拆分查询逻辑，只需要在实体类上配置分组聚合的注解，即可直接使用和原生一致的findAll(Specification, Pageable)调用方式，代码量更小。缺点是需要额外引入依赖、做基础配置，适合已经在使用该组件或者新搭建的模块。

内容的提问来源于stack exchange，提问作者QStorm