存储库代理有两种方法可以从方法名称派生特定于存储的查询：Spring中文文档

可用选项取决于实际商店。 但是，必须有一个策略来决定创建什么实际查询。 下一节将介绍可用选项。Spring中文文档

查询查找策略

存储库基础结构可以使用以下策略来解决查询。 使用 XML 配置时，可以通过属性在命名空间配置策略。 对于 Java 配置，您可以使用注释的属性。 某些策略可能不支持特定数据存储。query-lookup-strategyqueryLookupStrategyEnableJdbcRepositoriesSpring中文文档

  • CREATE尝试从查询方法名称构造特定于存储的查询。 一般方法是从方法名称中删除一组给定的已知前缀，并解析方法的其余部分。 您可以在“查询创建”中阅读有关查询构造的详细信息。Spring中文文档

  • USE_DECLARED_QUERY尝试查找已声明的查询，如果找不到查询，则引发异常。 查询可以通过某处的注释来定义，也可以通过其他方式声明。 请参阅特定商店的文档，查找该商店的可用选项。 如果存储库基础结构在引导时未找到该方法的声明查询，则该查询将失败。Spring中文文档

  • CREATE_IF_NOT_FOUND（默认值）组合 和 。 它首先查找已声明的查询，如果未找到已声明的查询，则创建基于自定义方法名称的查询。 这是默认的查找策略，因此，如果未显式配置任何内容，则使用此策略。 它允许通过方法名称快速定义查询，但也允许根据需要引入声明的查询来自定义调整这些查询。CREATEUSE_DECLARED_QUERYSpring中文文档

查询创建

Spring Data 存储库基础结构中内置的查询生成器机制可用于构建对存储库实体的约束查询。Spring中文文档

以下示例演示如何创建多个查询：Spring中文文档

从方法名称创建查询
interface PersonRepository extends Repository<Person, Long> {

  List<Person> findByEmailAddressAndLastname(EmailAddress emailAddress, String lastname);

  // Enables the distinct flag for the query
  List<Person> findDistinctPeopleByLastnameOrFirstname(String lastname, String firstname);
  List<Person> findPeopleDistinctByLastnameOrFirstname(String lastname, String firstname);

  // Enabling ignoring case for an individual property
  List<Person> findByLastnameIgnoreCase(String lastname);
  // Enabling ignoring case for all suitable properties
  List<Person> findByLastnameAndFirstnameAllIgnoreCase(String lastname, String firstname);

  // Enabling static ORDER BY for a query
  List<Person> findByLastnameOrderByFirstnameAsc(String lastname);
  List<Person> findByLastnameOrderByFirstnameDesc(String lastname);
}

解析查询方法名称分为主语和谓语。 第一部分 （， ） 定义查询的主语，第二部分构成谓语。 引言从句（主语）可以包含进一步的表达式。 和 之间的任何文本（或其他介绍性关键字）都被视为描述性的，除非使用结果限制关键字之一，例如 a 在要创建的查询上设置不同的标志，或者使用 Top/First 来限制查询结果。find…Byexists…ByfindByDistinctSpring中文文档

附录包含查询方法主语关键字和查询方法谓词关键字的完整列表，包括排序和大小写修饰符。 但是，第一个充当分隔符，以指示实际条件谓词的开始。 在非常基本的级别上，您可以定义实体属性的条件，并将它们与 和 连接起来。ByAndOrSpring中文文档

分析方法的实际结果取决于为其创建查询的持久性存储。 但是，有一些一般事项需要注意：Spring中文文档

  • 表达式通常是属性遍历，与可以连接的运算符组合在一起。 可以将属性表达式与 和 组合在一起。 还可以获得对运算符（如 、 、 ）和属性表达式的支持。 支持的运算符可能因数据存储而异，因此请参阅参考文档的相应部分。ANDORBetweenLessThanGreaterThanLikeSpring中文文档

  • 方法解析器支持为单个属性（例如，）或支持忽略大小写类型的所有属性（通常是实例，例如 ）设置标志。 是否支持忽略案例可能因商店而异，因此请参阅参考文档中的相关部分，了解特定于商店的查询方法。IgnoreCasefindByLastnameIgnoreCase(…)StringfindByLastnameAndFirstnameAllIgnoreCase(…)Spring中文文档

  • 可以通过将子句追加到引用属性的查询方法并提供排序方向（ 或 ）来应用静态排序。 若要创建支持动态排序的查询方法，请参阅“分页、迭代大型结果、排序和限制”。OrderByAscDescSpring中文文档

属性表达式

属性表达式只能引用托管实体的直接属性，如前面的示例所示。 在创建查询时，已确保分析的属性是托管域类的属性。 但是，您也可以通过遍历嵌套属性来定义约束。 请考虑以下方法签名：Spring中文文档

List<Person> findByAddressZipCode(ZipCode zipCode);

假设 a 有一个 和 . 在这种情况下，该方法将创建属性遍历。 解析算法首先将整个部件 （） 解释为属性，并检查域类中是否有具有该名称（未大写）的属性。 如果算法成功，它将使用该属性。 如果没有，该算法会将右侧骆驼壳部分的源拆分为头部和尾部，并尝试找到相应的属性——在我们的示例中，和 。 如果算法找到具有该头部的属性，则它会获取尾部并继续从那里向下构建树，以刚才描述的方式将尾部分开。 如果第一个拆分不匹配，则算法将拆分点向左移动 （， ） 并继续。PersonAddressZipCodex.address.zipCodeAddressZipCodeAddressZipCodeAddressZipCodeSpring中文文档

尽管这应该适用于大多数情况，但算法可能会选择错误的属性。 假设该类也有一个属性。 该算法在第一轮拆分中已经匹配，选择了错误的属性，然后失败（因为 的类型可能没有属性）。PersonaddressZipaddressZipcodeSpring中文文档

若要解决此歧义，可以在方法名称中使用手动定义遍历点。 因此，我们的方法名称如下：_Spring中文文档

List<Person> findByAddress_ZipCode(ZipCode zipCode);

因为我们将下划线 （） 视为保留字符，因此我们强烈建议遵循标准的 Java 命名约定（即，不要在属性名称中使用下划线，而是应用骆驼大小写）。_Spring中文文档
以下划线开头的字段名称：

字段名称可能以下划线开头，例如 。 确保保留 as in 并使用 double 拆分嵌套路径，例如 。String _name__name_user__nameSpring中文文档

大写字段名称：

全部大写的字段名称可以这样使用。 嵌套路径（如果适用）需要拆分 via 如 中所示。_USER_nameSpring中文文档

带有第二个大写字母的字段名称：

由起始小写字母后跟大写字母组成的字段名称可以通过以两个大写字母开头进行解析，如 中所示。 请注意潜在的路径歧义。String qCodeQCodeSpring中文文档

路径歧义：

在下面的示例中，属性 和 的排列方式包含一个名为 的属性，从而为路径 创建了歧义。qCodeqqcodeQCodeSpring中文文档

record Container(String qCode, Code q) {}
record Code(String code) {}

由于首先考虑属性的直接匹配，因此不会考虑任何潜在的嵌套路径，并且算法会选择该字段。 为了选择下划线表示法中的字段，需要。qCodecodeqQ_CodeSpring中文文档

因为我们将下划线 （） 视为保留字符，因此我们强烈建议遵循标准的 Java 命名约定（即，不要在属性名称中使用下划线，而是应用骆驼大小写）。_Spring中文文档
以下划线开头的字段名称：

字段名称可能以下划线开头，例如 。 确保保留 as in 并使用 double 拆分嵌套路径，例如 。String _name__name_user__nameSpring中文文档

大写字段名称：

全部大写的字段名称可以这样使用。 嵌套路径（如果适用）需要拆分 via 如 中所示。_USER_nameSpring中文文档

带有第二个大写字母的字段名称：

由起始小写字母后跟大写字母组成的字段名称可以通过以两个大写字母开头进行解析，如 中所示。 请注意潜在的路径歧义。String qCodeQCodeSpring中文文档

路径歧义：

在下面的示例中，属性 和 的排列方式包含一个名为 的属性，从而为路径 创建了歧义。qCodeqqcodeQCodeSpring中文文档

record Container(String qCode, Code q) {}
record Code(String code) {}

由于首先考虑属性的直接匹配，因此不会考虑任何潜在的嵌套路径，并且算法会选择该字段。 为了选择下划线表示法中的字段，需要。qCodecodeqQ_CodeSpring中文文档

返回集合或迭代对象的存储库方法

返回多个结果的查询方法可以使用标准 Java、 和 。 除此之外，我们还支持返回 Spring Data 的 ，以及 Vavr 提供的集合类型。 请参阅解释所有可能的查询方法返回类型的附录。IterableListSetStreamableIterableSpring中文文档

使用 Streamable 作为查询方法返回类型

您可以用作任何集合类型的替代类型。 它提供了访问非并行（缺少 ）的便捷方法，以及直接和覆盖元素并将元素连接到其他元素的能力：StreamableIterableStreamIterable….filter(…)….map(…)StreamableSpring中文文档

使用 Streamable 合并查询方法结果
interface PersonRepository extends Repository<Person, Long> {
  Streamable<Person> findByFirstnameContaining(String firstname);
  Streamable<Person> findByLastnameContaining(String lastname);
}

Streamable<Person> result = repository.findByFirstnameContaining("av")
  .and(repository.findByLastnameContaining("ea"));

返回自定义流式处理包装器类型

为集合提供专用包装器类型是一种常用模式，用于为返回多个元素的查询结果提供 API。 通常，通过调用返回类似集合类型的存储库方法并手动创建包装器类型的实例来使用这些类型。 您可以避免该额外步骤，因为 Spring Data 允许您将这些包装器类型用作查询方法返回类型，前提是它们满足以下条件：Spring中文文档

  1. 该类型实现 .StreamableSpring中文文档

  2. 该类型公开一个名为 or 作为参数的构造函数或静态工厂方法。of(…)valueOf(…)StreamableSpring中文文档

以下列表显示了一个示例：Spring中文文档

class Product {                                         (1)
  MonetaryAmount getPrice() { … }
}

@RequiredArgsConstructor(staticName = "of")
class Products implements Streamable<Product> {         (2)

  private final Streamable<Product> streamable;

  public MonetaryAmount getTotal() {                    (3)
    return streamable.stream()
      .map(Priced::getPrice)
      .reduce(Money.of(0), MonetaryAmount::add);
  }


  @Override
  public Iterator<Product> iterator() {                 (4)
    return streamable.iterator();
  }
}

interface ProductRepository implements Repository<Product, Long> {
  Products findAllByDescriptionContaining(String text); (5)
}
1 公开 API 以访问产品价格的实体。Product
2 可以使用（使用 Lombok 注释创建的工厂方法）构造的包装类型。 一个标准构造函数也会这样做。Streamable<Product>Products.of(…)Streamable<Product>
3 包装器类型公开一个附加 API，用于计算 .Streamable<Product>
4 实现接口并委托给实际结果。Streamable
5 该包装器类型可直接用作查询方法返回类型。 在存储库客户端中查询后，您无需返回并手动包装它。ProductsStreamable<Product>

支持 Vavr 集合

Vavr 是一个包含 Java 函数式编程概念的库。 它附带了一组自定义的集合类型，您可以将其用作查询方法返回类型，如下表所示：Spring中文文档

Vavr 收集类型 使用的 Vavr 实现类型 有效的 Java 源代码类型

io.vavr.collection.SeqSpring中文文档

io.vavr.collection.ListSpring中文文档

java.util.IterableSpring中文文档

io.vavr.collection.SetSpring中文文档

io.vavr.collection.LinkedHashSetSpring中文文档

java.util.IterableSpring中文文档

io.vavr.collection.MapSpring中文文档

io.vavr.collection.LinkedHashMapSpring中文文档

java.util.MapSpring中文文档

您可以将第一列（或其子类型）中的类型用作查询方法返回类型，并获取第二列中的类型作为实现类型，具体取决于实际查询结果（第三列）的 Java 类型。 或者，您可以声明（Vavr 等价物），然后我们从实际返回值派生实现类。 也就是说，a 变成 Vavr 或者 ，a 变成 Vavr，依此类推。TraversableIterablejava.util.ListListSeqjava.util.SetLinkedHashSetSetSpring中文文档

1 公开 API 以访问产品价格的实体。Product
2 可以使用（使用 Lombok 注释创建的工厂方法）构造的包装类型。 一个标准构造函数也会这样做。Streamable<Product>Products.of(…)Streamable<Product>
3 包装器类型公开一个附加 API，用于计算 .Streamable<Product>
4 实现接口并委托给实际结果。Streamable
5 该包装器类型可直接用作查询方法返回类型。 在存储库客户端中查询后，您无需返回并手动包装它。ProductsStreamable<Product>
Vavr 收集类型 使用的 Vavr 实现类型 有效的 Java 源代码类型

io.vavr.collection.SeqSpring中文文档

io.vavr.collection.ListSpring中文文档

java.util.IterableSpring中文文档

io.vavr.collection.SetSpring中文文档

io.vavr.collection.LinkedHashSetSpring中文文档

java.util.IterableSpring中文文档

io.vavr.collection.MapSpring中文文档

io.vavr.collection.LinkedHashMapSpring中文文档

java.util.MapSpring中文文档

流式查询结果

可以使用 Java 8 作为返回类型以增量方式处理查询方法的结果。 而不是将查询结果包装在 中，而是使用特定于数据存储的方法执行流式处理，如以下示例所示：Stream<T>StreamSpring中文文档

使用 Java 8 流式传输查询结果Stream<T>
@Query("select u from User u")
Stream<User> findAllByCustomQueryAndStream();

Stream<User> readAllByFirstnameNotNull();

@Query("select u from User u")
Stream<User> streamAllPaged(Pageable pageable);
A 可能会包装特定于基础数据存储的资源，因此必须在使用后关闭。 您可以使用该方法或使用 Java 7 块手动关闭 ，如以下示例所示：StreamStreamclose()try-with-resources
在块中处理结果Stream<T>try-with-resources
try (Stream<User> stream = repository.findAllByCustomQueryAndStream()) {
  stream.forEach(…);
}
并非所有 Spring Data 模块目前都支持作为返回类型。Stream<T>
A 可能会包装特定于基础数据存储的资源，因此必须在使用后关闭。 您可以使用该方法或使用 Java 7 块手动关闭 ，如以下示例所示：StreamStreamclose()try-with-resources
并非所有 Spring Data 模块目前都支持作为返回类型。Stream<T>

异步查询结果

您可以使用 Spring 的异步方法运行功能异步运行存储库查询。 这意味着该方法在调用时立即返回，而实际查询发生在已提交到 Spring 的任务中。 异步查询不同于反应式查询，不应混合使用。 有关反应式支持的更多详细信息，请参阅特定于商店的文档。 以下示例显示了许多异步查询：TaskExecutorSpring中文文档

@Async
Future<User> findByFirstname(String firstname);               (1)

@Async
CompletableFuture<User> findOneByFirstname(String firstname); (2)
1 用作返回类型。java.util.concurrent.Future
2 使用 Java 8 作为返回类型。java.util.concurrent.CompletableFuture
1 用作返回类型。java.util.concurrent.Future
2 使用 Java 8 作为返回类型。java.util.concurrent.CompletableFuture

分页、迭代大型结果、排序和限制

若要处理查询中的参数，请定义方法参数，如前面的示例所示。 除此之外，基础结构还可以识别某些特定类型，例如 和 ，以动态地对查询应用分页、排序和限制。 下面的示例演示了这些功能：PageableSortLimitSpring中文文档

在查询方法中使用 、 和PageableSliceSortLimit
Page<User> findByLastname(String lastname, Pageable pageable);

Slice<User> findByLastname(String lastname, Pageable pageable);

List<User> findByLastname(String lastname, Sort sort);

List<User> findByLastname(String lastname, Sort sort, Limit limit);

List<User> findByLastname(String lastname, Pageable pageable);
API 获取 ，并期望将非值传递到方法中。 如果不想应用任何排序或分页，请使用 和 。SortPageableLimitnullSort.unsorted()Pageable.unpaged()Limit.unlimited()

第一种方法允许您将实例传递给查询方法，以便将分页动态添加到静态定义的查询中。 A 知道可用的元素和页面的总数。 它通过基础结构触发计数查询来计算总数来实现。 由于这可能很昂贵（取决于使用的商店），因此您可以改为返回 . A 只知道下一个是否可用，这在遍历更大的结果集时可能就足够了。org.springframework.data.domain.PageablePageSliceSliceSliceSpring中文文档

排序选项也通过实例进行处理。 如果只需要排序，请向方法添加参数。 如您所见，返回 a 也是可能的。 在这种情况下，不会创建构建实际实例所需的其他元数据（这反过来意味着不会发出必要的额外计数查询）。 相反，它将查询限制为仅查找给定的实体范围。Pageableorg.springframework.data.domain.SortListPageSpring中文文档

若要了解整个查询获得的页数，必须触发额外的计数查询。 默认情况下，此查询派生自实际触发的查询。

特殊参数在查询方法中只能使用一次。
上面描述的一些特殊参数是互斥的。 请考虑以下无效参数组合列表。Spring中文文档

参数 例 原因

Pageable和SortSpring中文文档

findBy…​(Pageable page, Sort sort)Spring中文文档

Pageable已经定义SortSpring中文文档

Pageable和LimitSpring中文文档

findBy…​(Pageable page, Limit limit)Spring中文文档

Pageable已经定义了一个限制。Spring中文文档

用于限制结果的关键字可用于 while 定义结果的最大总数，而 Pageable 参数可能会减少此数字。TopPageableTopSpring中文文档

哪种方法合适？

Spring Data 抽象提供的值可能最好通过下表中概述的可能的查询方法返回类型来显示。 下表显示了可以从查询方法返回的类型Spring中文文档

表 1.使用大型查询结果
方法 获取的数据量 查询结构 约束

List<T>Spring中文文档

所有结果。Spring中文文档

单个查询。Spring中文文档

查询结果可能会耗尽所有内存。获取所有数据可能非常耗时。Spring中文文档

Streamable<T>Spring中文文档

所有结果。Spring中文文档

单个查询。Spring中文文档

查询结果可能会耗尽所有内存。获取所有数据可能非常耗时。Spring中文文档

Stream<T>Spring中文文档

分块（逐个或批量）取决于消耗量。StreamSpring中文文档

通常使用游标的单个查询。Spring中文文档

流使用后必须关闭，以免资源泄露。Spring中文文档

Flux<T>Spring中文文档

分块（逐个或批量）取决于消耗量。FluxSpring中文文档

通常使用游标的单个查询。Spring中文文档

存储模块必须提供反应式基础结构。Spring中文文档

Slice<T>Spring中文文档

Pageable.getPageSize() + 1在Pageable.getOffset()Spring中文文档

从应用限制开始获取数据的一对多查询。Pageable.getOffset()Spring中文文档

A 只能导航到下一个 .SliceSliceSpring中文文档

  • Slice提供是否有更多数据要提取的详细信息。Spring中文文档

  • 当偏移量太大时，基于偏移量的查询效率低下，因为数据库仍必须具体化完整结果。Spring中文文档

  • Window提供是否有更多数据要提取的详细信息。Spring中文文档

  • 当偏移量太大时，基于偏移量的查询效率低下，因为数据库仍必须具体化完整结果。Spring中文文档

Page<T>Spring中文文档

Pageable.getPageSize()在Pageable.getOffset()Spring中文文档

从应用限制开始的一对多查询。此外，可能需要查询以确定元素的总数。Pageable.getOffset()COUNT(…)Spring中文文档

通常，需要的查询成本很高。COUNT(…)Spring中文文档

  • 当偏移量太大时，基于偏移量的查询效率低下，因为数据库仍必须具体化完整结果。Spring中文文档

分页和排序

可以使用属性名称定义简单的排序表达式。 您可以连接表达式以将多个条件收集到一个表达式中。Spring中文文档

定义排序表达式
Sort sort = Sort.by("firstname").ascending()
  .and(Sort.by("lastname").descending());

若要使用更安全的类型方法来定义排序表达式，请从定义排序表达式的类型开始，然后使用方法引用来定义要排序的属性。Spring中文文档

使用类型安全 API 定义排序表达式
TypedSort<Person> person = Sort.sort(Person.class);

Sort sort = person.by(Person::getFirstname).ascending()
  .and(person.by(Person::getLastname).descending());
TypedSort.by(…)通过（通常）使用 CGlib 来使用运行时代理，这在使用 Graal VM Native 等工具时可能会干扰本机映像编译。

如果存储实现支持 Querydsl，则还可以使用生成的元模型类型来定义排序表达式：Spring中文文档

使用 Querydsl API 定义排序表达式
QSort sort = QSort.by(QPerson.firstname.asc())
  .and(QSort.by(QPerson.lastname.desc()));

限制查询结果

除了分页之外，还可以使用专用参数限制结果大小。 您还可以使用 or 关键字来限制查询方法的结果，这些关键字可以互换使用，但不能与参数混合使用。 您可以追加可选的数值，以指定要返回的最大结果大小。 如果省略该数字，则假定结果大小为 1。 以下示例演示如何限制查询大小：LimitFirstTopLimitTopFirstSpring中文文档

使用 和 限制查询的结果大小TopFirst
List<User> findByLastname(Limit limit);

User findFirstByOrderByLastnameAsc();

User findTopByOrderByAgeDesc();

Page<User> queryFirst10ByLastname(String lastname, Pageable pageable);

Slice<User> findTop3ByLastname(String lastname, Pageable pageable);

List<User> findFirst10ByLastname(String lastname, Sort sort);

List<User> findTop10ByLastname(String lastname, Pageable pageable);

限制表达式还支持支持不同查询的数据存储的关键字。 此外，对于将结果集限制为一个实例的查询，支持使用关键字将结果包装成。DistinctOptionalSpring中文文档

如果将分页或切片应用于限制查询分页（以及可用页数的计算），则在有限结果中应用分页或切片。Spring中文文档

通过使用参数对结果进行限制，结合动态排序，可以表达“K”最小元素和“K”最大元素的查询方法。Sort
API 获取 ，并期望将非值传递到方法中。 如果不想应用任何排序或分页，请使用 和 。SortPageableLimitnullSort.unsorted()Pageable.unpaged()Limit.unlimited()
若要了解整个查询获得的页数，必须触发额外的计数查询。 默认情况下，此查询派生自实际触发的查询。

特殊参数在查询方法中只能使用一次。
上面描述的一些特殊参数是互斥的。 请考虑以下无效参数组合列表。Spring中文文档

参数 例 原因

Pageable和SortSpring中文文档

findBy…​(Pageable page, Sort sort)Spring中文文档

Pageable已经定义SortSpring中文文档

Pageable和LimitSpring中文文档

findBy…​(Pageable page, Limit limit)Spring中文文档

Pageable已经定义了一个限制。Spring中文文档

用于限制结果的关键字可用于 while 定义结果的最大总数，而 Pageable 参数可能会减少此数字。TopPageableTopSpring中文文档
参数 例 原因

Pageable和SortSpring中文文档

findBy…​(Pageable page, Sort sort)Spring中文文档

Pageable已经定义SortSpring中文文档

Pageable和LimitSpring中文文档

findBy…​(Pageable page, Limit limit)Spring中文文档

Pageable已经定义了一个限制。Spring中文文档
表 1.使用大型查询结果
方法 获取的数据量 查询结构 约束

List<T>Spring中文文档

所有结果。Spring中文文档

单个查询。Spring中文文档

查询结果可能会耗尽所有内存。获取所有数据可能非常耗时。Spring中文文档

Streamable<T>Spring中文文档

所有结果。Spring中文文档

单个查询。Spring中文文档

查询结果可能会耗尽所有内存。获取所有数据可能非常耗时。Spring中文文档

Stream<T>Spring中文文档

分块（逐个或批量）取决于消耗量。StreamSpring中文文档

通常使用游标的单个查询。Spring中文文档

流使用后必须关闭，以免资源泄露。Spring中文文档

Flux<T>Spring中文文档

分块（逐个或批量）取决于消耗量。FluxSpring中文文档

通常使用游标的单个查询。Spring中文文档

存储模块必须提供反应式基础结构。Spring中文文档

Slice<T>Spring中文文档

Pageable.getPageSize() + 1在Pageable.getOffset()Spring中文文档

从应用限制开始获取数据的一对多查询。Pageable.getOffset()Spring中文文档

A 只能导航到下一个 .SliceSliceSpring中文文档

  • Slice提供是否有更多数据要提取的详细信息。Spring中文文档

  • 当偏移量太大时，基于偏移量的查询效率低下，因为数据库仍必须具体化完整结果。Spring中文文档

  • Window提供是否有更多数据要提取的详细信息。Spring中文文档

  • 当偏移量太大时，基于偏移量的查询效率低下，因为数据库仍必须具体化完整结果。Spring中文文档

Page<T>Spring中文文档

Pageable.getPageSize()在Pageable.getOffset()Spring中文文档

从应用限制开始的一对多查询。此外，可能需要查询以确定元素的总数。Pageable.getOffset()COUNT(…)Spring中文文档

通常，需要的查询成本很高。COUNT(…)Spring中文文档

  • 当偏移量太大时，基于偏移量的查询效率低下，因为数据库仍必须具体化完整结果。Spring中文文档
TypedSort.by(…)通过（通常）使用 CGlib 来使用运行时代理，这在使用 Graal VM Native 等工具时可能会干扰本机映像编译。
通过使用参数对结果进行限制，结合动态排序，可以表达“K”最小元素和“K”最大元素的查询方法。Sort