JPA/JPQL一对多关联数据高效投影与聚合策略

class ParentDTO {
   String id;
   String name;
   Collection<String> childIds; // 期望聚合的子ID集合

   public ParentDTO(String id, String name, Collection<String> childIds) {
       this.id = id;
       this.name = name;
       this.childIds = childIds;
   }
   // Getters
}

// Parent.java
@Entity
public class Parent {
    @Id
    private String id;
    private String name;
    @OneToMany(mappedBy = "parent")
    private Set<Child> children = new HashSet<>();
    // Getters and Setters
}

// Child.java
@Entity
public class Child {
    @Id
    private String id;
    private String value;
    @ManyToOne
    @JoinColumn(name = "parent_id")
    private Parent parent;
    // Getters and Setters
}

// 查询父实体ID、名称以及其关联子实体的ID
String jpql = "SELECT p.id, p.name, c.id FROM Parent p JOIN p.children c ORDER BY p.id";

// 执行查询并获取List<Tuple>
// Tuple是JPA 2.0引入的接口，用于表示查询结果中的一行数据，
// 可以通过索引或别名访问字段。
List<Tuple> resultTuples = entityManager.createQuery(jpql, Tuple.class).getResultList();

import javax.persistence.Tuple;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class DataAggregator {

    public static Collection<ParentDTO> aggregateToParentDTOs(List<Tuple> resultTuples) {
        // 使用Collectors.groupingBy按父实体ID分组
        Map<String, ParentDTO> parentDTOMap = resultTuples.stream()
            .collect(Collectors.groupingBy(
                tuple -> tuple.get(0, String.class), // 以父ID作为分组键
                Collectors.reducing(
                    // 初始值：创建一个新的ParentDTO，包含父ID和名称，子ID集合为空
                    null, // 初始值可以为null，因为reducing的accumulator会处理
                    tuple -> {
                        String parentId = tuple.get(0, String.class);
                        String parentName = tuple.get(1, String.class);
                        String childId = tuple.get(2, String.class);
                        ParentDTO dto = new ParentDTO(parentId, parentName, new java.util.ArrayList<>());
                        if (childId != null) {
                            dto.getChildIds().add(childId);
                        }
                        return dto;
                    },
                    // 合并器：合并两个ParentDTO，将子ID集合合并
                    (dto1, dto2) -> {
                        if (dto1 == null) return dto2; // 处理reducing的初始null值
                        if (dto2 == null) return dto1;
                        dto1.getChildIds().addAll(dto2.getChildIds());
                        return dto1;
                    }
                )
            ));

        // 如果需要，可以进一步优化，避免在reducing中创建过多DTO实例，
        // 而是先收集所有子ID，再统一构建DTO。
        // 更简洁且推荐的方式：
        Map<String, List<Tuple>> groupedByParentId = resultTuples.stream()
            .collect(Collectors.groupingBy(tuple -> tuple.get(0, String.class)));

        return groupedByParentId.entrySet().stream()
            .map(entry -> {
                String parentId = entry.getKey();
                List<Tuple> tuplesForParent = entry.getValue();
                // 假设同一父ID下的所有tuple的parentName相同
                String parentName = tuplesForParent.get(0).get(1, String.class);
                Set<String> childIds = tuplesForParent.stream()
                    .map(tuple -> tuple.get(2, String.class))
                    .collect(Collectors.toSet()); // 使用Set避免重复，如果需要List则改为toList()
                return new ParentDTO(parentId, parentName, new java.util.ArrayList<>(childIds));
            })
            .collect(Collectors.toList());
    }

    // ParentDTO 定义
    static class ParentDTO {
        String id;
        String name;
        Collection<String> childIds;

        public ParentDTO(String id, String name, Collection<String> childIds) {
            this.id = id;
            this.name = name;
            this.childIds = childIds;
        }

        public String getId() { return id; }
        public String getName() { return name; }
        public Collection<String> getChildIds() { return childIds; }

        @Override
        public String toString() {
            return "ParentDTO{" +
                   "id='" + id + '\'' +
                   ", name='" + name + '\'' +
                   ", childIds=" + childIds +
                   '}';
        }
    }
}