Java 坚持你的评论，但尽管你投了七张赞成票，这听起来完全错了。即时抓取绝对避免了N+1问题。请看第3点，我认为批量抓取或延迟加载只是延迟查询，实际上并没有避免多个查询。这并不能解决问题本身。这只是减少其影响的一种方法。事实上，我在每个类和每个集合上都使用此设置。

---

坚持你的评论，但尽管你投了七张赞成票，这听起来完全错了。即时抓取绝对避免了N+1问题。请看第3点，我认为批量抓取或延迟加载只是延迟查询，实际上并没有避免多个查询。这并不能解决问题本身。这只是减少其影响的一种方法。事实上，我在每个类和每个集合上都使用此设置。每一个每当我加载某个实体的列表，并触摸其引用或集合。。。仅为所有（1+1）选择一个（井取决于批次大小）。这是真正的1+N内置解决方案。更重要的是，我们不必更改查询（在某些引用或集合上使用Fetch.mode）。。。我们可以只查询根实体。。。只有很少的SELECT-later（懒洋洋地）让我们全部加载。。。希望事情再清楚一点；）+1.延迟加载和批取，并且只有在真正需要时，查询中的join fetch，才是处理n+1选择问题的最直接和标准的方法。批取并没有避免n+1查询，而是将n个查询的数量除以批大小。因此，合适的问题是连接获取。此外，批量抓取是在实体级别定义的，因此如果多个查询使用相同的实体，它们将使用相同的批量大小，并且可能会出现问题（想象在批处理和GUI中使用相同的实体）。如果在单个事务中更新同一实体的一组对象，我该怎么办，orm层发布了多个更新，但我希望一个更新语句能够工作。这可行吗？如何？欢迎来到堆栈溢出！虽然自我提升不是一个问题，如果它有帮助，请考虑添加一些代码或解释，以解决实际问题，它是一个有价值的答案，或考虑使用评论一旦你回答了足够的问题：谢谢你的建议@ AKS1618我添加了一些代码，以显示它如何与问题有关。

"from Manufacturer manufacturer join fetch manufacturer.contact contact"

select MANUFACTURER.id from manufacturer and contact ... from 
MANUFACTURER inner join CONTACT on MANUFACTURER.CONTACT_ID=CONTACT.id

Criteria criteria = session.createCriteria(Manufacturer.class);
criteria.setFetchMode("contact", FetchMode.EAGER);

select MANUFACTURER.id from MANUFACTURER left outer join CONTACT on 
MANUFACTURER.CONTACT_ID=CONTACT.id where 1=1

@Entity
@BatchSize(size=25)
@Table(...
public class MyEntity implements java.io.Serializable {...

@OneToMany(fetch = FetchType.LAZY...)
@BatchSize(size=25)
public Set<MyEntity> getMyColl() 

List<PostComment> comments = entityManager.createQuery("""
    select pc
    from PostComment pc
    where pc.review = :review
    """, PostComment.class)
.setParameter("review", review)
.getResultList();

for(PostComment comment : comments) {
    LOGGER.info("The post title is '{}'", comment.getPost().getTitle());
}

SELECT pc.id AS id1_1_, pc.post_id AS post_id3_1_, pc.review AS review2_1_
FROM   post_comment pc
WHERE  pc.review = 'Excellent!'

INFO - Loaded 3 comments

SELECT pc.id AS id1_0_0_, pc.title AS title2_0_0_
FROM   post pc
WHERE  pc.id = 1

INFO - The post title is 'Post nr. 1'

SELECT pc.id AS id1_0_0_, pc.title AS title2_0_0_
FROM   post pc
WHERE  pc.id = 2

INFO - The post title is 'Post nr. 2'

SELECT pc.id AS id1_0_0_, pc.title AS title2_0_0_
FROM   post pc
WHERE  pc.id = 3

INFO - The post title is 'Post nr. 3'

List<PostComment> comments = entityManager.createQuery("""
    select pc
    from PostComment pc
    join fetch pc.post p
    where pc.review = :review
    """, PostComment.class)
.setParameter("review", review)
.getResultList();

hibernate.batch_fetch_style=PADDED
hibernate.default_batch_fetch_size=25

hibernate.max_fetch_depth=0

public interface ClientDetailsRepository extends JpaRepository<ClientEntity, Long> {
    @Query("FROM clientMaster c join fetch c.manager m where m.managerId= :managerId")
    List<ClientEntity> findClientByManagerId(String managerId);
}

@Entity(name = "portfolioManager")
@Table(name = "portfolio_manager")
public class ManagerEntity implements Serializable {

      // some fields

@OneToMany(fetch = FetchType.LAZY, mappedBy = "manager")
protected List<ClientEntity> clients = new ArrayList<>();

     // Getter & Setter 

}

@Entity(name = "clientMaster")
@Table(name = "clientMaster")
public class ClientEntity implements Serializable {

    // some fields

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "manager_id", insertable = false, updatable = false)
    protected ManagerEntity manager;

    // Getter & Setter 

 }

Hibernate: select cliententi0_.client_id as client_id1_0_0_, cliententi0_.manager_id as manager_id2_0_0_, managerent1_.manager_id as manager_id1_2_1_, cliententi0_.created_by as created_by7_0_0_, cliententi0_.created_date as created_date3_0_0_, cliententi0_.client_name as client_name4_0_0_, cliententi0_.sector_name as sector_name5_0_0_, cliententi0_.updated_by as updated_by8_0_0_, cliententi0_.updated_date as updated_date6_0_0_, managerent1_.manager_name as manager_name2_2_1_ from client_master cliententi0_, portfolio_manager managerent1_ where cliententi0_.manager_id=managerent1_.manager_id and managerent1_.manager_id=?```

@Entity
@Table(name = "film", schema = "public")
public class Film implements Serializable {

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "language_id", nullable = false)
  private Language language;

  @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "film")
  private Set<FilmActor> filmActors;
...
}

@Entity
@Table(name = "film_actor", schema = "public")
public class FilmActor implements Serializable {

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "film_id", nullable = false, insertable = false, updatable = false)
  private Film film;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "actor_id", nullable = false, insertable = false, updatable = false)
  private Actor actor;
...
}

@Entity
@Table(name = "actor", schema = "public")
public class Actor implements Serializable {

  @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "actor")
  private Set<FilmActor> filmActors;
...
}

@Repository
public interface FilmDao extends JpaRepository<Film, Integer> {

  @EntityGraph(
    type = EntityGraphType.FETCH,
    attributePaths = {
      "language",
      "filmActors",
      "filmActors.actor"
    }
  )
  Page<Film> findAll(Pageable pageable);
...
}