直接返回关联列表时Hibernate多对多关联查询不触发问题

问题现象 #

尝试获取Customer关联的Channel列表时，直接返回关联列表不会触发数据库查询：

@Transactional
public List<Channel> getChannelsOfCustomer(Customer customer){
    Session session = sessionFactory.getCurrentSession();
    Customer customer1 = session.get(Customer.class, customer.getCustomerId());
    return customer1.getChannels();
}

日志仅打印Customer的查询SQL：

Hibernate: select customer0_.customer_id as customer1_1_0_, customer0_.name as name2_1_0_ from customer customer0_ where customer0_.customer_id=?

但调用System.out.println(channels)后，Hibernate会执行关联查询并返回正确列表：

@Transactional
public List<Channel> getChannelsOfCustomer(Customer customer){
    Session session = sessionFactory.getCurrentSession();
    Customer customer1 = session.get(Customer.class, customer.getCustomerId());
    List<Channel> channels = customer1.getChannels();
    System.out.println(channels);
    return channels;
}

日志会打印Customer和关联Channel的查询SQL：

Hibernate: select customer0_.customer_id as customer1_1_0_, customer0_.name as name2_1_0_ from customer customer0_ where customer0_.customer_id=?
Hibernate: select channels0_.customer_id as customer4_2_0_, channels0_.channel_id as channel_3_2_0_, channel1_.channel_id as channel_1_0_1_, channel1_.name as name2_0_1_ from customer_channel channels0_ inner join channel channel1_ on channels0_.channel_id=channel1_.channel_id where channels0_.customer_id=?

核心原因 #

这是Hibernate**懒加载（Lazy Loading）**的默认行为导致的：

• @ManyToMany关联默认抓取策略为FetchType.LAZY，调用getChannels()时，Hibernate不会立即查询数据库，而是返回一个代理集合对象（如PersistentBag）。
• 该代理集合仅在被实际使用（如遍历、调用size()/toString()等方法）时，才会触发数据库查询加载真实数据。
• System.out.println(channels)会调用集合的toString()方法，触发了代理集合的初始化，因此执行了关联查询。

解决方案 #

根据业务需求，可选择以下几种处理方式：

1. 修改关联的抓取策略为立即加载（EAGER） #

直接在@ManyToMany注解中指定fetch = FetchType.EAGER，加载Customer时会立即查询关联的Channel列表：

@ManyToMany(fetch = FetchType.EAGER)
@JoinTable(
        name="customer_channel",
        joinColumns = @JoinColumn(name="customer_id"),
        inverseJoinColumns = @JoinColumn(name="channel_id")
)
private List<Channel> channels;

注意：EAGER加载会导致每次查询Customer都关联查询Channel，可能影响性能，适合关联数据量较小的场景。

2. 在事务内手动初始化集合 #

利用Hibernate的Hibernate.initialize()方法，在返回集合前手动触发加载：

@Transactional
public List<Channel> getChannelsOfCustomer(Customer customer){
    Session session = sessionFactory.getCurrentSession();
    Customer customer1 = session.get(Customer.class, customer.getCustomerId());
    List<Channel> channels = customer1.getChannels();
    Hibernate.initialize(channels); // 手动初始化集合
    return channels;
}

这种方式保留懒加载的默认行为，仅在需要时手动触发加载，灵活性更高。

3. 使用JOIN FETCH的HQL查询 #

通过HQL语句主动关联查询，一次性加载Customer和关联的Channel，避免N+1查询问题：

@Transactional
public List<Channel> getChannelsOfCustomer(Customer customer){
    Session session = sessionFactory.getCurrentSession();
    Customer customer1 = session.createQuery(
            "SELECT c FROM Customer c JOIN FETCH c.channels WHERE c.customerId = :id",
            Customer.class
    )
    .setParameter("id", customer.getCustomerId())
    .uniqueResult();
    return customer1.getChannels();
}

这种方式可精准控制查询时机，适合复杂查询场景，同时优化性能。

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