如何在NativeQuery结果列表中关联子对象？

针对你的需求，这里提供三种不同场景下的最优实现方式，可根据项目实际情况选择：

一、配置实体类一对多关联（推荐长期维护） #

如果项目允许修改实体类和映射配置，这是最符合JPA/Hibernate规范的方案，代码简洁且维护成本低：

1. 修改Person实体类，添加一对多关联映射：

@Entity
public class Person {
    @Id
    private Integer id;
    private String firstName;
    private String lastName;
    private String email;

    // 关联Address表的person_id字段，懒加载可根据需求调整为EAGER
    @OneToMany(fetch = FetchType.LAZY)
    @JoinColumn(name = "person_id")
    private List<Address> addresses;

    // 生成对应的getter、setter方法
}

2. 使用JPQL查询，通过FETCH JOIN避免N+1查询问题：

List<Person> personList = session.createQuery(
    "SELECT p FROM Person p LEFT JOIN FETCH p.addresses", 
    Person.class
).list();

Hibernate会自动处理关联关系，返回的每个Person对象都会包含对应的Address列表。

二、利用Hibernate ResultTransformer实现映射（无需修改实体关联） #

如果不能修改实体类的关联配置，可通过原生关联查询+结果转换器，一次性完成数据映射，避免多次查询：

// 编写关联查询SQL，左联保证没有地址的Person也能被返回
String querySql = "SELECT p.id, p.first_name, p.last_name, p.email, a.person_id, a.street_address " +
                  "FROM person p LEFT JOIN address a ON p.id = a.person_id";

List<Person> personList = session.createNativeQuery(querySql)
    .setResultTransformer(new ResultTransformer() {
        // 用Map存储已处理的Person，避免重复创建
        private final Map<Integer, Person> personMap = new HashMap<>();

        @Override
        public Object transformTuple(Object[] tuple, String[] aliases) {
            Integer personId = ((Number) tuple[0]).intValue();
            Person person = personMap.get(personId);
            
            // 首次处理该Person，初始化对象
            if (person == null) {
                person = new Person();
                person.setId(personId);
                person.setFirstName((String) tuple[1]);
                person.setLastName((String) tuple[2]);
                person.setEmail((String) tuple[3]);
                person.setAddresses(new ArrayList<>());
                personMap.put(personId, person);
            }
            
            // 左联可能返回null地址，需判断后添加
            if (tuple[4] != null) {
                Address address = new Address();
                address.setPersonId(((Number) tuple[4]).intValue());
                address.setStreetAddress((String) tuple[5]);
                person.getAddresses().add(address);
            }
            return person;
        }

        @Override
        public List transformList(List collection) {
            // 返回去重后的Person列表
            return new ArrayList<>(personMap.values());
        }
    })
    .list();

此方案仅需一次SQL查询，通过内存Map去重Person，效率较高。

三、自定义DTO投影（适合无实体修改权限场景） #

如果既不能修改实体类，又不想用匿名转换器，可定义DTO类来承接结果，再手动处理映射：

1. 定义DTO类：

public class PersonWithAddressesDTO {
    private Integer id;
    private String firstName;
    private String lastName;
    private String email;
    private List<Address> addresses;

    public PersonWithAddressesDTO(Integer id, String firstName, String lastName, String email) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
        this.addresses = new ArrayList<>();
    }

    // 生成getter、setter方法
}

2. 执行查询并手动映射结果：

String querySql = "SELECT p.id, p.first_name, p.last_name, p.email, a.person_id, a.street_address " +
                  "FROM person p LEFT JOIN address a ON p.id = a.person_id";

List<Object[]> resultTuples = session.createNativeQuery(querySql).list();
Map<Integer, PersonWithAddressesDTO> dtoMap = new HashMap<>();

for (Object[] tuple : resultTuples) {
    Integer personId = ((Number) tuple[0]).intValue();
    PersonWithAddressesDTO dto = dtoMap.get(personId);
    
    if (dto == null) {
        dto = new PersonWithAddressesDTO(personId, (String) tuple[1], (String) tuple[2], (String) tuple[3]);
        dtoMap.put(personId, dto);
    }
    
    if (tuple[4] != null) {
        Address address = new Address();
        address.setPersonId(((Number) tuple[4]).intValue());
        address.setStreetAddress((String) tuple[5]);
        dto.getAddresses().add(address);
    }
}

// 最终结果列表
List<PersonWithAddressesDTO> finalResult = new ArrayList<>(dtoMap.values());

方案选择建议 #

• 若项目架构允许修改实体类，优先选择实体一对多关联方案，代码最简洁且符合JPA规范；
• 若不能修改实体类，优先选择ResultTransformer方案，查询效率高且代码紧凑；
• DTO投影方案适合对实体类完全无修改权限的场景，结构清晰但代码量稍大。

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