如何用Spring Data Specifications实现等效关联子查询的SQL逻辑？

你的需求是查询A表全量字段，同时附带关联B表的对应记录数，下面分两种情况说明实现方式：

一、结合Spring Data Specifications与JPA CriteriaQuery实现 #

Spring Data Specifications本身主要用于构建WHERE子句的查询条件，但要实现子查询作为投影字段（即SELECT中的自定义字段），需要配合JPA的CriteriaQuery来完成，这样既可以利用Specifications的灵活条件构建，又能实现子查询统计。

1. 基础准备 #

首先定义实体类和结果DTO：

// A实体类
@Entity
@Table(name = "a")
public class A {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    // 其他业务字段
    // getter、setter省略
}

// B实体类
@Entity
@Table(name = "b")
public class B {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Long aId; // 关联A表的id
    // 其他业务字段
    // getter、setter省略
}

// 用于接收结果的DTO
public class AWithCountDTO {
    private A a;
    private Long count;

    public AWithCountDTO(A a, Long count) {
        this.a = a;
        this.count = count;
    }
    // getter、setter省略
}

2. 自定义Repository方法 #

在A的Repository中扩展JpaSpecificationExecutor，并实现自定义查询方法：

public interface ARepository extends JpaRepository<A, Long>, JpaSpecificationExecutor<A> {

    default List<AWithCountDTO> findAllWithBCount(Specification<A> spec) {
        CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
        CriteriaQuery<AWithCountDTO> query = cb.createQuery(AWithCountDTO.class);
        Root<A> aRoot = query.from(A.class);

        // 构建子查询：统计当前A记录对应的B表数量
        Subquery<Long> countSubquery = query.subquery(Long.class);
        Root<B> bRoot = countSubquery.from(B.class);
        countSubquery.select(cb.count(bRoot))
                     .where(cb.equal(bRoot.get("aId"), aRoot.get("id")));

        // 主查询选择A实体和子查询统计结果
        query.select(cb.construct(AWithCountDTO.class, aRoot, countSubquery));

        // 应用Specifications传入的查询条件
        if (spec != null) {
            query.where(spec.toPredicate(aRoot, query, cb));
        }

        return getEntityManager().createQuery(query).getResultList();
    }
}

3. 调用示例 #

可以传入任意Specifications条件来过滤A表数据：

// 示例：查询id大于10的A记录及其关联B的数量
List<AWithCountDTO> result = aRepository.findAllWithBCount((root, query, cb) -> 
    cb.greaterThan(root.get("id"), 10L)
);

二、替代方案 #

如果觉得上述方式过于繁琐，还有以下更简洁的实现方式：

方案1：使用@Query注解直接编写JPQL/原生SQL #

原生SQL方式

@Query(value = "select a.*, (select count(1) from b where b.a_id = a.id) as count from a a", nativeQuery = true)
List<Object[]> findAllWithBCountNative();

返回的Object[]中第一个元素是A表的字段数组，第二个元素是统计数，可自行转换为DTO。

JPQL方式（更贴合JPA规范）

@Query("select a as a, (select count(b) from B b where b.aId = a.id) as count from A a")
List<ACountProjection> findAllWithBCountJPQL();

// 定义投影接口
public interface ACountProjection {
    A getA();
    Long getCount();
}

方案2：使用Hibernate的@Formula注解（仅限Hibernate作为JPA实现） #

在A实体类中直接添加统计字段，由Hibernate自动生成子查询：

@Entity
@Table(name = "a")
public class A {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    // 其他业务字段

    @Formula("(select count(1) from b where b.a_id = id)")
    private Long count;

    // getter、setter省略
}

这样查询A实体时，count字段会自动填充对应的统计值，无需额外编写查询逻辑。

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