FetchType.LAZY未生效，表现同FetchType.EAGER问题求助

我在使用Hibernate时遇到了懒加载（lazy）数据获取的问题：Clinic实体的@OneToMany关联设置了FetchType.LAZY，但查询所有Clinic数据时，返回结果里却包含完整的doctors数组，而且Hibernate还额外执行了查询医生的SQL语句——这和我预期的「只查询Clinic，doctors为null」不符。

相关代码 #

Clinic实体类 #

@Getter
@Setter
@Entity(name = "clinic")
public class Clinic {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String name;
  @OneToMany(fetch = FetchType.LAZY, mappedBy="clinic")
  private List<Doctor> doctors;
}

Doctor实体类 #

@Getter
@Setter
@Entity(name = "doctor")
public class Doctor {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String firstname;
  private String lastname;
  @ManyToOne(fetch = FetchType.LAZY)
  @JsonIgnore
  private Clinic clinic;
}

控制器代码 #

@RestController
@RequestMapping("clinics")
public class ClinicController {

  private final ClinicRepository clinicRepository;

  public ClinicController(ClinicRepository clinicRepository) {this.clinicRepository = clinicRepository;}

  @GetMapping()
  public List<Clinic> getAllClinics() {
    return clinicRepository.findAll();
  }
}

生成的SQL语句 #

Hibernate: select clinic0_.id as id1_0_, clinic0_.name as name2_0_ from clinic clinic0_
Hibernate: select doctors0_.clinic_id as clinic_i4_1_0_, doctors0_.id as id1_1_0_, doctors0_.id as id1_1_1_, doctors0_.clinic_id as clinic_i4_1_1_, doctors0_.firstname as firstnam2_1_1_, doctors0_.lastname as lastname3_1_1_ from doctor doctors0_ where doctors0_.clinic_id=?
Hibernate: select doctors0_.clinic_id as clinic_i4_1_0_, doctors0_.id as id1_1_0_, doctors0_.id as id1_1_1_, doctors0_.clinic_id as clinic_i4_1_1_, doctors0_.firstname as firstnam2_1_1_, doctors0_.lastname as lastname3_1_1_ from doctor doctors0_ where doctors0_.clinic_id=?

当前返回结果 #

[
    {
        "id": 1,
        "name": "Clinic 1",
        "doctors": [
            {
                "id": 1,
                "firstname": "Bob",
                "lastname": "Fisher"
            },
            {
                "id": 2,
                "firstname": "John",
                "lastname": "Cena"
            }
        ]
    },
    {
        "id": 2,
        "name": "Clinic 2",
        "doctors": [
            {
                "id": 3,
                "firstname": "Some",
                "lastname": "guy"
            }
        ]
    }
]

问题原因 #

核心原因是Jackson序列化触发了懒加载：
当Spring MVC控制器返回Clinic列表时，Jackson会自动调用实体类的所有getter方法（因为你用了@Getter注解）。此时getDoctors()被调用，而Hibernate的懒加载代理对象检测到当前仍处于EntityManager会话（Session）中（findAll()返回的实体还在持久化上下文里），就会立即执行SQL查询加载关联的doctors数据，导致懒加载失效。

解决方案 #

1. 序列化时忽略懒加载属性 #

在Clinic的doctors字段上添加@JsonIgnore，让Jackson序列化时跳过该属性，避免触发getter：

@OneToMany(fetch = FetchType.LAZY, mappedBy="clinic")
@JsonIgnore
private List<Doctor> doctors;

缺点是所有接口场景下都不会返回doctors，如果需要按需返回，更推荐用DTO。

2. 使用DTO层分离实体与返回数据 #

创建ClinicDTO类，仅包含需要返回的字段，避免直接序列化实体：

public class ClinicDTO {
    private Long id;
    private String name;

    public ClinicDTO(Clinic clinic) {
        this.id = clinic.getId();
        this.name = clinic.getName();
    }

    // getter方法
    public Long getId() { return id; }
    public String getName() { return name; }
}

修改控制器代码：

import java.util.stream.Collectors;

@GetMapping()
public List<ClinicDTO> getAllClinics() {
    return clinicRepository.findAll().stream()
            .map(ClinicDTO::new)
            .collect(Collectors.toList());
}

这种方式更灵活，能精准控制返回字段，也避免了实体序列化带来的各种问题。

3. 关闭持久化上下文后再序列化 #

通过@Transactional控制事务范围，查询完成后将实体从持久化上下文中分离，此时调用getter会触发LazyInitializationException（若不需要返回doctors，这种方式可以阻止懒加载触发）：

import javax.persistence.EntityManager;
import org.springframework.transaction.annotation.Transactional;

@GetMapping()
@Transactional(readOnly = true)
public List<Clinic> getAllClinics() {
    List<Clinic> clinics = clinicRepository.findAll();
    clinics.forEach(clinic -> entityManager.detach(clinic));
    return clinics;
}

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