问为什么它调用N+1查询？

EN

    @Override
public SearchResult<EntityA> findByAnyCritere(SomeCriteria critere, Integer page, Integer pageSize, String... orderBys) {
    CriteriaBuilder builder = getEntityManager().getCriteriaBuilder();

    // count all entities
    Long unfilteredCount = countAll();

    // count filtered entities
    Long count = unfilteredCount;

    CriteriaQuery<EntityA> criteriaQuery = builder.createQuery(EntityA.class);
    Root<EntityA> from = criteriaQuery.from(getEntityClass());
    Join<EntityA, EntityB> joinB = from.join("entityB", JoinType.LEFT);
    Join<EntityB, EntityC> joinC = joinB.join("entityC", JoinType.LEFT);
    Join<EntityB, EntityD> joinD = joinB.join("entityD", JoinType.LEFT);
    Join<EntityD, EntityE> joinE = joinD.join("entityE", JoinType.LEFT);

    Predicate predicate = builder.equal(from.<EntityF> get("entityF").<Long> get("id"), critere.getSomeId());
    Predicate predicateKeyword = filterLookupByValue(critere.getAnyCriteria(), builder, criteriaQuery, LookupType.TEXT_KEYWORD, keywordJoin);
    Predicate predicateNumberText = filterNumber(critere, builder, textJoin, false);

    Subquery<Long> subqueryLibelle = filterLibelle(critere.getAnyCriteria(), builder, criteriaQuery, from);

    if (StringUtils.isNotBlank(critere.getAnyCriteria())) {
        criteriaQuery.where(builder.and(predicate,
                builder.or(predicateKeyword, predicateNumberText, builder.exists(subqueryLibelle))));
    } else {
        criteriaQuery.where(builder.and(predicate));
    }

    criteriaQuery.select(from);

    count = JpaUtils.count(getEntityManager(), criteriaQuery);

    addSortingInstructionsIfNeeded(builder, criteriaQuery, from, orderBys);

    TypedQuery<EntityA> typedQuery = getEntityManager().createQuery(criteriaQuery);
    addPaginationRestrictionIfNeeded(typedQuery, page, pageSize);

    List<EntityA> entities = typedQuery.getResultList();
    LOG.debug("found {} entities", entities.size());

    return toSearchResult(unfilteredCount, count, entities, page, pageSize);
}

select * from ( 
  select inner2_.*, rownumber() over(order by order of inner2_) as rownumber_ from ( 
  select 
    <<fields>> 
  from 
    EntityA versionelk0_ 
    left outer join EntityB textversio1_ on versionelk0_.ID_TEXT_VERSION=textversio1_.ID 
    left outer join EntityC textentity2_ on textversio1_.ID_TEXT=textentity2_.ID 
    left outer join EntityD textdefini3_ on textversio1_.ID_TEXT_DEFINITION=textdefini3_.ID 
    left outer join EntityE lookupenti4_ on textdefini3_.ID_LOOKUP_KEYWORD=lookupenti4_.ID, 
    EntityF textentity6_ 
  where 
      textversio1_.ID_TEXT=textentity6_.ID and versionelk0_.ID_VERSION_ELKAT=41 
  order by textentity6_.NUMBER asc 
      fetch first 20 rows only 
  ) as inner2_ 
) as inner1_ 
where rownumber_ > 10 order by rownumber_

@Entity
public class EntityA extends AbstractVersionedEntity<Long> {

    @Id
    @GeneratedValue
    @Column(name = "ID")
    private Long id;

    @ManyToOne
    @JoinColumn(name = "ID_TEXT_VERSION")
    private EntityB entityB;

[...]
}

@Entity
public class EntityB extends AbstractVersionedEntity<Long> {

    @Id
    @GeneratedValue
    @Column(name = "ID")
    private Long id;

    @OneToOne
    @JoinColumn(name = "ID_TEXT")
    private EntityC entityC;

    @OneToOne
    @JoinColumn(name = "ID_TEXT_DEFINITION")
    private EntityD definition;

[...]
}

@Entity
public class EntityC extends AbstractVersionedEntity<Long> {
    @Id
    @GeneratedValue
    @Column(name = "ID")
    private Long id;

    @Column(name = "NUMBER")
    private String number;

[...]
}

@Entity
public class EntityD extends AbstractVersionedEntity<Long> {
    @Id
    @GeneratedValue
    @Column(name = "ID")
    private Long id;

    @ManyToOne
    @JoinColumn(name = "ID_LOOKUP_CHAPTER")
    private EntityE chapter;

    @ManyToOne
    @JoinColumn(name = "ID_LOOKUP_CATEGORY")
    private EntityE category;

    @ManyToOne
    @JoinColumn(name = "ID_LOOKUP_KEYWORD")
    private EntityE keyword;

    @ManyToOne
    @JoinColumn(name = "ID_LOOKUP_RECIPIENT")
    private EntityE recipient;

[...]
}

@Entity
public class EntityE extends AbstractVersionedEntity<Long> {
    @Id
    @GeneratedValue
    @Column(name = "ID")
    private Long id;

    @Column(name = "KEY")
    private String key;

    @Column(name = "INDEX")
    private Integer index;

    @Column(name = "ACTIVE")
    private Boolean active = Boolean.TRUE;

    @ManyToOne
    @JoinColumn(name = "ID_LOOKUPTYPE")
    private EntityF type;

[...]
}