Spring Data JDBC多对一关联查询如何返回完整关联数据并支持分页？

问题背景 #

使用Spring Data JDBC处理多对一关联实体的增删改操作很便捷，但查询时默认仅返回关联ID（通过AggregateReference），无法直接返回包含关联实体完整信息的分页结果；手写@Query或JdbcTemplate易丢失分页能力，用MapStruct映射又会产生N+1查询问题。

对应表结构：

CREATE TABLE TYPE (
   ID   SERIAL NOT NULL,
   NAME VARCHAR NOT NULL,
   PRIMARY KEY (ID)
);

CREATE TABLE RECORD (   
   ID   SERIAL NOT NULL,
   NAME VARCHAR NOT NULL,
   TYPE_ID INTEGER REFERENCES TYPE(ID),
   PRIMARY KEY (ID)
);

实体类：

@Table
class Type {
    @Id
    Long id;
    String name;
}

@Table
class Record {
    @Id
    Long id;
    String name;
    @Column("type_id")
    AggregateReference<Type, Long> type;
}

需要返回包含完整Type信息的分页结果，格式如下：

[{"id":1,"name":"record1","type":{"id":1,"name":"type1"}},...]

最优解决方案 #

方案1：利用Spring Data JDBC原生@Query支持分页（推荐） #

Spring Data JDBC支持在自定义@Query中配合Pageable参数实现分页，无需手动处理limit/offset和总条数统计，同时通过关联查询获取完整Type信息。

步骤：

1. 定义包含完整关联信息的DTO：

public record RecordWithType(
    Long id,
    String name,
    Type type
) {}

2. 在Repository接口中定义带分页的关联查询方法：

public interface RecordRepository extends PagingAndSortingRepository<Record, Long> {

    @Query("""
            SELECT r.ID, r.NAME, t.ID AS type_id, t.NAME AS type_name
            FROM RECORD r JOIN TYPE t ON r.TYPE_ID = t.ID
            """)
    Page<RecordWithType> findAllWithType(Pageable pageable);
}

Spring Data JDBC会自动：

• 为查询添加LIMIT和OFFSET实现分页
• 执行count查询获取总条数
• 将查询结果映射到RecordWithTypeDTO中（字段名需与查询别名对应）

方案2：自定义Repository实现（灵活处理复杂查询） #

如果需要更复杂的查询逻辑，可自定义Repository实现类，结合JdbcTemplate手动处理分页和关联查询。

步骤：

1. 定义自定义Repository接口：

public interface RecordCustomRepository {
    Page<RecordWithType> findAllWithType(Pageable pageable);
}

public interface RecordRepository extends PagingAndSortingRepository<Record, Long>, RecordCustomRepository {
}

2. 实现自定义查询逻辑：

@Repository
public class RecordCustomRepositoryImpl implements RecordCustomRepository {

    private final JdbcTemplate jdbcTemplate;

    // 结果映射器
    private final RowMapper<RecordWithType> rowMapper = (rs, rowNum) -> {
        Type type = new Type();
        type.setId(rs.getLong("type_id"));
        type.setName(rs.getString("type_name"));
        return new RecordWithType(
                rs.getLong("record_id"),
                rs.getString("record_name"),
                type
        );
    };

    public RecordCustomRepositoryImpl(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Page<RecordWithType> findAllWithType(Pageable pageable) {
        // 统计总条数
        String countSql = "SELECT COUNT(*) FROM RECORD r JOIN TYPE t ON r.TYPE_ID = t.ID";
        long total = jdbcTemplate.queryForObject(countSql, Long.class);

        // 分页查询数据
        String dataSql = """
                SELECT r.ID AS record_id, r.NAME AS record_name, t.ID AS type_id, t.NAME AS type_name
                FROM RECORD r JOIN TYPE t ON r.TYPE_ID = t.ID
                LIMIT ? OFFSET ?
                """;
        int limit = pageable.getPageSize();
        int offset = pageable.getPageNumber() * limit;
        List<RecordWithType> content = jdbcTemplate.query(dataSql, rowMapper, limit, offset);

        return new PageImpl<>(content, pageable, total);
    }
}

方案3：优化MapStruct避免N+1查询 #

如果项目已使用MapStruct，可通过批量查询关联实体来消除N+1问题：

步骤：

1. 定义MapStruct映射器：

@Mapper(componentModel = "spring")
public interface RecordMapper {
    RecordWithType toDto(Record record, Type type);
}

2. 在Service层实现批量查询逻辑：

@Service
public class RecordService {

    private final RecordRepository recordRepository;
    private final TypeRepository typeRepository;
    private final RecordMapper recordMapper;

    public RecordService(RecordRepository recordRepository, TypeRepository typeRepository, RecordMapper recordMapper) {
        this.recordRepository = recordRepository;
        this.typeRepository = typeRepository;
        this.recordMapper = recordMapper;
    }

    public Page<RecordWithType> getRecordsWithType(Pageable pageable) {
        // 分页查询Record
        Page<Record> recordPage = recordRepository.findAll(pageable);
        
        // 提取所有关联Type的ID，批量查询
        Set<Long> typeIds = recordPage.getContent().stream()
                .map(record -> record.getType().getId())
                .collect(Collectors.toSet());
        Map<Long, Type> typeMap = typeRepository.findAllById(typeIds).stream()
                .collect(Collectors.toMap(Type::getId, Function.identity()));
        
        // 映射为DTO
        List<RecordWithType> content = recordPage.getContent().stream()
                .map(record -> recordMapper.toDto(record, typeMap.get(record.getType().getId())))
                .collect(Collectors.toList());
        
        return new PageImpl<>(content, pageable, recordPage.getTotalElements());
    }
}

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