Spring Data JPA原生查询如何加载懒加载关联关系？

因为原生SQL无法直接使用JPQL的JOIN FETCH语法，这里提供三个实用的方案来解决你的问题：

方案1：分两步查询——先取ID，再用JPQL加载关联 #

这是最简洁的方案，适合数据量不大的场景：

1. 先用原生查询（带PostgreSQL JSON操作符）筛选出符合条件的实体ID列表
2. 再用JPQL通过JOIN FETCH加载实体及其懒加载关联

代码示例 #

// 第一步：查询符合条件的实体ID
@Query(nativeQuery = true, value = "SELECT id FROM your_entity WHERE json_column @> :jsonFilter")
List<Long> findMatchingEntityIds(@Param("jsonFilter") String jsonFilter);

// 第二步：通过ID列表加载实体及关联
@Query("SELECT e FROM YourEntity e JOIN FETCH e.relatedAssociation WHERE e.id IN (:ids)")
List<YourEntity> findEntitiesWithAssociation(@Param("ids") List<Long> ids);

业务层调用 #

List<Long> ids = yourRepository.findMatchingEntityIds("{\"key\": \"targetValue\"}");
List<YourEntity> entities = yourRepository.findEntitiesWithAssociation(ids);

方案2：使用@NamedNativeQuery + @SqlResultSetMapping映射关联 #

通过JPA的注解定义原生查询和结果集映射，让Hibernate帮你自动关联实体和懒加载数据：

实体类注解配置 #

@Entity
@NamedNativeQuery(
    name = "YourEntity.findWithAssociation",
    query = "SELECT e.id, e.name, r.id AS r_id, r.detail AS r_detail " +
            "FROM your_entity e " +
            "LEFT JOIN related_table r ON e.id = r.entity_id " +
            "WHERE e.json_column @> :jsonFilter",
    resultSetMapping = "YourEntityWithAssociation"
)
@SqlResultSetMapping(
    name = "YourEntityWithAssociation",
    entities = {
        @EntityResult(
            entityClass = YourEntity.class,
            fields = {
                @FieldResult(name = "id", column = "id"),
                @FieldResult(name = "name", column = "name")
            }
        ),
        @EntityResult(
            entityClass = RelatedEntity.class,
            fields = {
                @FieldResult(name = "id", column = "r_id"),
                @FieldResult(name = "detail", column = "r_detail")
            }
        )
    }
)
public class YourEntity {
    @Id
    private Long id;
    private String name;
    @Column(columnDefinition = "jsonb")
    private String jsonColumn;
    @OneToMany(mappedBy = "entity", fetch = FetchType.LAZY)
    private List<RelatedEntity> relatedEntities;
    
    // getter、setter省略
}

查询调用与结果组装 #

EntityManager em = ...; // 获取EntityManager
List<Object[]> results = em.createNamedQuery("YourEntity.findWithAssociation")
    .setParameter("jsonFilter", "{\"key\": \"targetValue\"}")
    .getResultList();

// 手动组装实体与关联关系（避免重复实体）
Map<Long, YourEntity> entityMap = new HashMap<>();
for (Object[] row : results) {
    YourEntity entity = (YourEntity) row[0];
    RelatedEntity related = (RelatedEntity) row[1];
    
    YourEntity cachedEntity = entityMap.computeIfAbsent(entity.getId(), k -> entity);
    if (related != null) {
        cachedEntity.getRelatedEntities().add(related);
        related.setEntity(cachedEntity);
    }
}

List<YourEntity> finalEntities = new ArrayList<>(entityMap.values());

方案3：自定义RowMapper手动映射结果 #

直接在原生查询中返回所有需要的字段，通过Spring Data的RowMapper手动将结果映射为带有关联数据的实体：

Repository方法定义 #

@Query(nativeQuery = true, value = "SELECT e.id, e.name, r.id AS r_id, r.detail AS r_detail " +
        "FROM your_entity e LEFT JOIN related_table r ON e.id = r.entity_id " +
        "WHERE e.json_column @> :jsonFilter")
List<YourEntity> findEntitiesWithAssociation(@Param("jsonFilter") String jsonFilter, RowMapper<YourEntity> rowMapper);

查询调用 #

Map<Long, YourEntity> entityMap = new HashMap<>();
List<YourEntity> entities = yourRepository.findEntitiesWithAssociation("{\"key\": \"targetValue\"}", (rs, rowNum) -> {
    Long entityId = rs.getLong("id");
    YourEntity entity = entityMap.getOrDefault(entityId, new YourEntity());
    entity.setId(entityId);
    entity.setName(rs.getString("name"));
    
    Long relatedId = rs.getLong("r_id");
    if (!rs.wasNull()) {
        RelatedEntity related = new RelatedEntity();
        related.setId(relatedId);
        related.setDetail(rs.getString("r_detail"));
        related.setEntity(entity);
        entity.getRelatedEntities().add(related);
    }
    entityMap.put(entityId, entity);
    return entity;
});

// 去重（左连接会产生重复实体行）
entities = new ArrayList<>(new LinkedHashSet<>(entities));

方案对比 #

• 方案1：实现成本最低，性能稳定，适合大多数场景
• 方案2：符合JPA规范，但配置繁琐，结果组装需要额外处理
• 方案3：灵活性最高，适合复杂的关联映射，但代码量较大

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