Hibernate查询关联实体时按需加载C部分字段的方案咨询

实体映射关系 #

@Entity
class A {
   @OneToMany
   private List<B> Bs;
}

@Entity
class B {
   @OneToMany
   private List<C> Cs;
}

@Entity
class C {
   private Double x1;
   private Double y1;
   private Double z1;

   private Double x2;
   private Double y2;
   private Double z2;
   
   //... 其他大量字段
}

实体C映射自包含大量列的CSV表，业务中需要通过aRepository.findAll(spec)遍历所有A关联的Bs及其对应的Cs，支持用户选择C的部分字段（例如[x1, x2, z2]），希望SQL仅查询这些指定字段，同时想保留懒加载特性。请问使用ResultTransformer的自定义查询是否为最佳方案？有没有更简单的替代方案？

回答 #

ResultTransformer并非最佳方案 #

ResultTransformer在Hibernate 5.2版本后已被标记为过时，替代方案是TupleTransformer和ResultListTransformer，而且自定义查询配合Transformer需要手动处理实体关联关系，实现繁琐，还容易破坏JPA的懒加载语义，不推荐使用。

更简单的替代方案 #

1. 接口投影（Interface Projection）

这是最简洁的方案，无需编写DTO类，Spring Data会动态生成代理实现投影接口：

• 定义投影接口，包含需要的字段getter：

  public interface CProjection {
      Double getX1();
      Double getX2();
      Double getZ2();
  }
  

• 在A的Repository中定义自定义查询，结合Specification返回投影结果：

  public interface ARepository extends JpaRepository<A, Long>, JpaSpecificationExecutor<A> {
      @Query("SELECT c.x1 AS x1, c.x2 AS x2, c.z2 AS z2 FROM A a JOIN a.Bs b JOIN b.Cs c WHERE #{#spec}")
      List<CProjection> findAllWithSelectedCFields(@Param("spec") Specification<A> spec);
  }
  

  如果需要同时保留A和B的实体数据，也可以在查询中包含A、B的字段，或者将投影扩展为包含关联实体的信息。

2. 构造函数投影（Constructor Projection）

适合需要更严格类型控制的场景：

• 创建仅包含目标字段的DTO类：

  public class CDto {
      private Double x1;
      private Double x2;
      private Double z2;
  
      public CDto(Double x1, Double x2, Double z2) {
          this.x1 = x1;
          this.x2 = x2;
          this.z2 = z2;
      }
  
      // getter方法
  }
  

• 通过Criteria API动态构建查询，指定构造函数投影：

  public List<CDto> findAllWithSelectedCFields(Specification<A> spec, List<String> cFields) {
      CriteriaBuilder cb = entityManager.getCriteriaBuilder();
      CriteriaQuery<CDto> query = cb.createQuery(CDto.class);
      Root<A> root = query.from(A.class);
      Join<A, B> bJoin = root.join("Bs");
      Join<B, C> cJoin = bJoin.join("Cs");
  
      // 动态选择C的指定字段，映射到DTO构造函数
      List<Selection<?>> selections = cFields.stream()
          .map(field -> cJoin.get(field))
          .collect(Collectors.toList());
      query.select(cb.construct(CDto.class, selections.toArray(new Selection[0])));
  
      // 应用传入的Specification条件
      Predicate predicate = spec.toPredicate(root, query, cb);
      if (predicate != null) {
          query.where(predicate);
      }
  
      return entityManager.createQuery(query).getResultList();
  }
  

3. 结合Specification动态控制字段与懒加载

如果必须使用aRepository.findAll(spec)，可以自定义Specification来动态指定C的查询字段，同时保留懒加载：

public class DynamicCSpecification implements Specification<A> {
    private List<String> cFields;

    public DynamicCSpecification(List<String> cFields) {
        this.cFields = cFields;
    }

    @Override
    public Predicate toPredicate(Root<A> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
        // 普通JOIN而非FETCH，保留Bs的懒加载特性
        Join<A, B> bJoin = root.join("Bs", JoinType.LEFT);
        Join<B, C> cJoin = bJoin.join("Cs", JoinType.LEFT);

        // 动态选择A、B的必要字段及C的指定字段
        List<Selection<?>> selections = new ArrayList<>();
        selections.add(root.get("id")); // 根据实际需求添加A的字段
        selections.add(bJoin.get("id")); // 根据实际需求添加B的字段
        selections.addAll(cFields.stream().map(cJoin::get).collect(Collectors.toList()));

        query.multiselect(selections);
        return cb.conjunction();
    }
}

使用时直接传入该Specification：

List<A> result = aRepository.findAll(new DynamicCSpecification(Arrays.asList("x1", "x2", "z2")));

这种方式下，A的Bs仍保持懒加载（除非主动触发），而Cs仅加载指定字段，避免查询冗余列。

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