ExecutionGraphQlService是调用 GraphQL Java 执行的主要 Spring 抽象 请求。底层传输（如 HTTP）委托处理请求。ExecutionGraphQlService

主实现 配置了 a 用于访问要调用的实例。DefaultExecutionGraphQlServiceGraphQlSourcegraphql.GraphQL

GraphQLSource

GraphQlSource是公开实例以供使用的协定 包括用于构建该实例的构建器 API。默认构建器可通过 .graphql.GraphQLGraphQlSource.schemaResourceBuilder()

Boot Starter 创建此构建器的实例并进一步初始化它 要从可配置位置加载架构文件， 公开要应用于的属性，以检测 RuntimeWiringConfigurer bean、GraphQL 指标的检测 bean、 和 bean 用于异常解析。对于进一步的自定义，您还可以 声明一个 Bean，例如：GraphQlSource.BuilderDataFetcherExceptionResolverSubscriptionExceptionResolverGraphQlSourceBuilderCustomizer

@Configuration(proxyBeanMethods = false)
class GraphQlConfig {

	@Bean
	public GraphQlSourceBuilderCustomizer sourceBuilderCustomizer() {
		return (builder) ->
				builder.configureGraphQl(graphQlBuilder ->
						graphQlBuilder.executionIdProvider(new CustomExecutionIdProvider()));
	}
}

架构资源

GraphQlSource.Builder可以配置一个或多个实例 解析并合并在一起。这意味着架构文件几乎可以从任何位置加载 位置。Resource

默认情况下，启动启动程序会查找带有扩展名的架构文件 “.graphqls”或“.gqls”位置下，通常为 .您还可以使用文件系统位置或任何位置 受 Spring 层次结构支持，包括自定义实现 从远程位置、存储或内存加载架构文件。classpath:graphql/**src/main/resources/graphqlResource

用于跨多个类路径查找架构文件 位置，例如跨多个模块。classpath*:graphql/**/

架构创建

默认情况下，使用 GraphQL Java 创建 .这适用于典型用途，但如果您需要使用 不同的生成器，可以注册一个回调：GraphQlSource.BuilderSchemaGeneratorgraphql.schema.GraphQLSchemaschemaFactory

GraphQlSource.Builder builder = ...

builder.schemaResources(..)
		.configureRuntimeWiring(..)
		.schemaFactory((typeDefinitionRegistry, runtimeWiring) -> {
			// create GraphQLSchema
		})

请参阅 GraphQlSource 部分，了解如何使用 Spring Boot 进行配置。

如果对联合感兴趣，请参阅联合部分。

RuntimeWiringConfigurer

A 可用于注册以下内容：RuntimeWiringConfigurer

  • 自定义标量类型。

  • 处理指令的代码。

  • 直接注册。DataFetcher

  • 以及更多...

Spring 应用程序通常不需要执行直接注册。 相反，控制器方法被注册为 s via ，这是一个 .DataFetcherDataFetcherAnnotatedControllerConfigurerRuntimeWiringConfigurer
GraphQL Java，服务器应用程序仅使用 Jackson 进行数据映射的序列化。 客户端输入被解析为映射。服务器输出将根据字段选择集组合成地图。 这意味着您不能依赖 Jackson 序列化/反序列化批注。 相反，您可以使用自定义标量类型。

Boot Starter 检测类型为 在 .这意味着在大多数情况下，您将拥有 在您的配置中类似于以下内容：RuntimeWiringConfigurerGraphQlSource.Builder

@Configuration
public class GraphQlConfig {

	@Bean
	public RuntimeWiringConfigurer runtimeWiringConfigurer(BookRepository repository) {
		GraphQLScalarType scalarType = ... ;
		SchemaDirectiveWiring directiveWiring = ... ;
		return wiringBuilder -> wiringBuilder
				.scalar(scalarType)
				.directiveWiring(directiveWiring);
	}
}

如果您需要添加一个 ，例如，进行考虑到 schema 定义，实现同时接受 和 输出的替代方法。这允许您添加任何 然后按顺序调用的工厂数。WiringFactoryconfigureRuntimeWiring.BuilderList<WiringFactory>

TypeResolver

GraphQlSource.Builder注册为默认值，用于尚未具有此类注册的 GraphQL 接口和联合 通过 RuntimeWiringConfigurer。目的 GraphQL Java 中的 a 用于确定值的 GraphQL 对象类型 从 for a GraphQL Interface 或 Union 字段返回。ClassNameTypeResolverTypeResolverTypeResolverDataFetcher

ClassNameTypeResolver尝试将值的简单类名与 GraphQL 匹配 对象类型，如果不成功，它还会导航其超类型，包括 基类和接口，寻找匹配项。 提供 配置名称提取功能以及 GraphQL 对象类型的选项 名称映射应该有助于涵盖更多极端情况：ClassNameTypeResolverClass

GraphQlSource.Builder builder = ...
ClassNameTypeResolver classNameTypeResolver = new ClassNameTypeResolver();
classNameTypeResolver.setClassNameExtractor((klass) -> {
	// Implement Custom ClassName Extractor here
});
builder.defaultTypeResolver(classNameTypeResolver);

请参阅 GraphQlSource 部分，了解如何使用 Spring Boot 进行配置。

指令

GraphQL 语言支持“描述备用运行时执行和 GraphQL 文档中的类型验证行为“。指令类似于 Java，但在 GraphQL 文档中的类型、字段、片段和操作上声明。

GraphQL Java 提供了帮助应用程序检测的协定 并处理指令。有关更多详细信息，请参阅 GraphQL Java 文档。SchemaDirectiveWiring

在 Spring GraphQL 中，您可以通过 RuntimeWiringConfigurer 注册一个。Boot Starter 检测到 这样的豆子，所以你可能会有这样的东西：SchemaDirectiveWiring

@Configuration
public class GraphQlConfig {

	 @Bean
	 public RuntimeWiringConfigurer runtimeWiringConfigurer() {
		  return builder -> builder.directiveWiring(new MySchemaDirectiveWiring());
	 }

}
有关指令支持的示例，请查看 Graphql Java 扩展验证库。

ExecutionStrategy

GraphQL Java 中的 Java 驱动请求字段的获取。 要创建 ，您需要提供 . 默认情况下，Spring for GraphQL 会创建异常处理程序，如 Exceptions 中所述，并将其设置在 .然后，GraphQL Java 使用它来创建具有配置的异常处理程序的实例。ExecutionStrategyExecutionStrategyDataFetcherExceptionHandlerGraphQL.BuilderAsyncExecutionStrategy

如果需要创建自定义 ，可以检测 s 并以相同的方式创建异常处理程序，并使用 它创建自定义 .例如，在 Spring Boot 应用程序中：ExecutionStrategyDataFetcherExceptionResolverExecutionStrategy

@Bean
GraphQlSourceBuilderCustomizer sourceBuilderCustomizer(
		ObjectProvider<DataFetcherExceptionResolver> resolvers) {

	DataFetcherExceptionHandler exceptionHandler =
			DataFetcherExceptionResolver.createExceptionHandler(resolvers.stream().toList());

	AsyncExecutionStrategy strategy = new CustomAsyncExecutionStrategy(exceptionHandler);

	return sourceBuilder -> sourceBuilder.configureGraphQl(builder ->
			builder.queryExecutionStrategy(strategy).mutationExecutionStrategy(strategy));
}

架构转换

如果要遍历，可以注册 via 并在创建架构后对其进行转换，并对架构进行更改。请记住 这通常比架构遍历更昂贵 首选遍历而不是转换，除非需要进行架构更改。graphql.schema.GraphQLTypeVisitorbuilder.schemaResources(..).typeVisitorsToTransformSchema(..)

架构遍历

如果要遍历架构，可以注册 via 它已创建，并可能对 .请记住， 但是，此类访问者无法更改架构。如果需要对架构进行更改，请参阅架构转换。graphql.schema.GraphQLTypeVisitorbuilder.schemaResources(..).typeVisitors(..)GraphQLCodeRegistry

模式映射检查

如果查询、突变或订阅操作没有 ，则不会 返回任何数据，并且不会执行任何有用操作。同样，架构类型的字段 既没有通过注册明确涵盖，也没有通过注册隐含 查找匹配属性的默认值将始终为 。DataFetcherDataFetcherPropertyDataFetcherClassnull

GraphQL Java 不执行检查以确保覆盖每个模式字段，并且作为 较低级别的库，GraphQL Java 根本不知道可以返回什么 或者它依赖于什么参数，因此无法执行此类验证。这可以 导致差距，根据测试覆盖率，直到运行时才能发现 客户端可能会遇到“静默”值或非 null 字段错误。DataFetchernull

Spring for GraphQL 中的接口允许 公开返回类型和预期参数等信息。控制器方法、Querydsl 和 Query by Example 的所有内置 Spring 实现都是此接口的实现。对于带注释的控制器，返回类型和 预期的参数基于控制器方法签名。这使它成为可能 在启动时检查架构映射以确保满足以下条件：SelfDescribingDataFetcherDataFetcherDataFetcher

  • 架构字段具有注册或相应的属性。DataFetcherClass

  • DataFetcher注册是指存在的架构字段。

  • DataFetcher参数具有匹配的架构字段参数。

要启用架构检查，请如下所示进行自定义。 在这种情况下，只需记录报告，但您可以选择执行任何操作：GraphQlSource.Builder

GraphQlSource.Builder builder = ...

builder.schemaResources(..)
		.inspectSchemaMappings(report -> {
			logger.debug(report);
		});

报告示例：

GraphQL schema inspection:
    Unmapped fields: {Book=[title], Author[firstName, lastName]} (1)
    Unmapped registrations: {Book.reviews=BookController#reviews[1 args]} (2)
    Unmapped arguments: {BookController#bookSearch[1 args]=[myAuthor]} (3)
    Skipped types: [BookOrAuthor] (4)
1 未以任何方式覆盖的架构字段
2 DataFetcher注册到不存在的字段
3 DataFetcher不存在的预期参数
4 已跳过的架构类型（接下来解释）

在某些情况下，架构类型的类型是未知的。也许没有 implement ，或者声明的返回类型过于笼统 （例如）或未知（例如），或者可能完全缺失。 在这种情况下，架构类型将列为跳过，因为它无法验证。对于每一个 跳过类型，DEBUG 消息会解释它被跳过的原因。ClassDataFetcherSelfDescribingDataFetcherObjectList<?>DataFetcher

联合和接口

对于工会，检查会循环访问成员类型并尝试找到相应的 类。对于接口，检查会循环访问实现类型和外观 对于相应的类。

缺省情况下，在以下情况下可以现成地检测相应的 Java 类：

  • 的简单名称与接口实现的 GraphQL 联合成员匹配 type name，并且 与 的返回类型位于同一包中 控制器方法或控制器类，映射到联合或接口字段。ClassClass

  • 在架构的其他部分检查映射字段为 具体联合成员或接口实现类型。Class

  • 您已注册一个 TypeResolver，该 TypeResolver 具有显式到 GraphQL 类型映射。Class

在上述帮助中，GraphQL 类型在架构检查中被报告为跳过 report，您可以进行以下自定义：

  • 将 GraphQL 类型名称显式映射到一个或多个 Java 类。

  • 配置一个函数，用于自定义如何将 GraphQL 类型名称调整为简单名称。这有助于实现特定的 Java 类命名约定。Class

  • 提供 a 来映射 GraphQL 类型 a Java 类。ClassNameTypeResolver

例如：

GraphQlSource.Builder builder = ...

builder.schemaResources(..)
	.inspectSchemaMappings(
		initializer -> initializer.classMapping("Author", Author.class)
		logger::debug);

操作缓存

GraphQL Java 必须在执行操作之前解析和验证操作。这可能会影响 性能显著。为了避免需要重新分析和验证，应用程序可以 配置缓存和重用文档实例的 a。GraphQL Java 文档提供了有关 通过 .PreparsedDocumentProviderPreparsedDocumentProvider

在 Spring GraphQL 中，您可以通过以下方式注册： .PreparsedDocumentProviderGraphQlSource.Builder#configureGraphQl

// Typically, accessed through Spring Boot's GraphQlSourceBuilderCustomizer
GraphQlSource.Builder builder = ...

// Create provider
PreparsedDocumentProvider provider =
        new ApolloPersistedQuerySupport(new InMemoryPersistedQueryCache(Collections.emptyMap()));

builder.schemaResources(..)
		.configureRuntimeWiring(..)
		.configureGraphQl(graphQLBuilder -> graphQLBuilder.preparsedDocumentProvider(provider))

请参阅 GraphQlSource 部分，了解如何使用 Spring Boot 进行配置。

用于跨多个类路径查找架构文件 位置，例如跨多个模块。classpath*:graphql/**/
Spring 应用程序通常不需要执行直接注册。 相反，控制器方法被注册为 s via ，这是一个 .DataFetcherDataFetcherAnnotatedControllerConfigurerRuntimeWiringConfigurer
GraphQL Java，服务器应用程序仅使用 Jackson 进行数据映射的序列化。 客户端输入被解析为映射。服务器输出将根据字段选择集组合成地图。 这意味着您不能依赖 Jackson 序列化/反序列化批注。 相反，您可以使用自定义标量类型。
有关指令支持的示例，请查看 Graphql Java 扩展验证库。
1 未以任何方式覆盖的架构字段
2 DataFetcher注册到不存在的字段
3 DataFetcher不存在的预期参数
4 已跳过的架构类型（接下来解释）

螺纹模型

大多数 GraphQL 请求都受益于获取嵌套字段的并发执行。这是 为什么今天大多数应用程序都依赖于 GraphQL Java 的 ，它允许 数据获取器返回并发执行，而不是串行执行。AsyncExecutionStrategyCompletionStage

Java 21 和虚拟线程增加了一个有效使用更多线程的重要功能，但是 仍然需要并发执行而不是串行执行才能进行请求 执行以更快地完成。

Spring for GraphQL 支持：

  • 反应式数据获取器，这些是 适应了 .CompletionStageAsyncExecutionStrategy

  • CompletionStage作为返回值。

  • 属于 Kotlin 协程方法的控制器方法。

  • @SchemaMapping 和 @BatchMapping 方法可以返回提交到 Spring Framework 之类的方法。若要启用此功能，必须配置 on .CallableExecutorVirtualThreadTaskExecutorExecutorAnnotatedControllerConfigurer

Spring for GraphQL 在 Spring MVC 或 WebFlux 上运行作为传输。Spring MVC 使用异步请求执行，除非完成结果 在 GraphQL Java 引擎返回后立即出现这种情况，如果 请求非常简单，不需要异步数据提取。CompletableFuture

反应性的DataFetcher

默认生成器启用对返回的支持，或者将这些返回器调整为聚合值的位置 并转换为 List，除非该请求是 GraphQL 订阅请求， 在这种情况下，返回值仍然是流式处理的响应式流 GraphQL 响应。GraphQlSourceDataFetcherMonoFluxCompletableFutureFluxPublisher

反应式可以依赖于对 Reactor 上下文的访问，该上下文是从 传输层，例如来自 WebFlux 请求处理的传输层，请参阅 WebFlux 上下文。DataFetcher

上下文传播

Spring for GraphQL 支持透明地将上下文从 HTTP 传输、GraphQL Java 传播到它调用的其他组件。这包括两个上下文 来自 Spring MVC 请求处理线程和来自 WebFlux 的 Reactor 处理管道。DataFetcherThreadLocalContext

网络MVC

GraphQL Java 调用的 A 和其他组件可能并不总是在 与 Spring MVC 处理程序相同的线程，例如，如果异步 WebGraphQlInterceptor 或切换到 不同的线程。DataFetcherDataFetcher

Spring for GraphQL 支持从 Servlet 容器传播值 线程到线程 a 和 GraphQL Java 调用的其他组件 执行。为此，应用程序需要实现感兴趣的值：ThreadLocalDataFetcherio.micrometer.context.ThreadLocalAccessorThreadLocal

public class RequestAttributesAccessor implements ThreadLocalAccessor<RequestAttributes> {

    @Override
    public Object key() {
        return RequestAttributesAccessor.class.getName();
    }

    @Override
    public RequestAttributes getValue() {
        return RequestContextHolder.getRequestAttributes();
    }

    @Override
    public void setValue(RequestAttributes attributes) {
        RequestContextHolder.setRequestAttributes(attributes);
    }

    @Override
    public void reset() {
        RequestContextHolder.resetRequestAttributes();
    }

}

您可以在启动时手动注册全局实例，该实例可通过 访问。您也可以注册它 自动通过该机制。ThreadLocalAccessorContextRegistryio.micrometer.context.ContextRegistry#getInstance()java.util.ServiceLoader

网络通量

Reactive DataFetcher 可以依赖于对 Reactor 上下文的访问，该上下文 源自 WebFlux 请求处理链。这包括反应堆上下文 由 WebGraphQlInterceptor 组件添加。

异常

在 GraphQL Java 中，决定如何表示来自 在响应的“错误”部分中获取数据。应用程序可以注册 仅限单个处理程序。DataFetcherExceptionHandler

Spring for GraphQL 注册了一个提供默认值的 处理并启用合同。应用程序可以 通过 GraphQLSource builder 注册任意数量的解析器，这些解析器位于 顺序，直到一个 他们解析为 . Spring Boot 启动器会检测这种类型的 bean。DataFetcherExceptionHandlerDataFetcherExceptionResolverExceptionList<graphql.GraphQLError>

DataFetcherExceptionResolverAdapter是一个方便的基类，具有受保护的方法和 。resolveToSingleErrorresolveToMultipleErrors

Annotated Controllers 编程模型支持处理数据获取异常 具有灵活方法签名的带注释的异常处理程序方法，有关详细信息，请参阅@GraphQlExceptionHandler。

可以根据 GraphQL Java 或 Spring GraphQL 将 A 分配给一个类别，该类别定义了以下内容：GraphQLErrorgraphql.ErrorClassificationErrorType

  • BAD_REQUEST

  • UNAUTHORIZED

  • FORBIDDEN

  • NOT_FOUND

  • INTERNAL_ERROR

如果异常仍未解决，则默认情况下将其归类为具有包含类别名称和 from 的通用消息的异常。该消息故意不透明以避免泄漏 实现细节。应用程序可以使用 a 来自定义 错误详细信息。INTERNAL_ERRORexecutionIdDataFetchingEnvironmentDataFetcherExceptionResolver

未解决的异常与 to correlate 一起记录在 ERROR 级别 发送到客户端的错误。已解决的异常记录在 DEBUG 级别。executionId

请求例外

GraphQL Java 引擎在解析请求时可能会遇到验证或其他错误 这反过来又会阻止请求执行。在这种情况下，响应包含一个 “data”键，以及一个或多个全局的请求级“错误”，即不是 具有字段路径。null

DataFetcherExceptionResolver无法处理此类全局错误，因为它们被引发 在执行开始之前和调用任何操作之前。应用程序可以使用 传输级拦截器，用于检查和转换 . 请参阅 WebGraphQlInterceptor 下的示例。DataFetcherExecutionResult

订阅例外

在这种情况下，订阅请求可能会以错误信号结束 底层传输（例如 WebSocket）发送带有列表的最终“错误”类型消息 的 GraphQL 错误。Publisher

DataFetcherExceptionResolver无法解决订阅中的错误， 因为数据最初只创建。之后， 传输订阅 然后可能会完成错误。PublisherDataFetcherPublisherPublisher

应用程序可以注册一个以解决 订阅中的异常，以便将这些异常解决为 GraphQL 错误 发送给客户端。SubscriptionExceptionResolverPublisher

分页

GraphQL Cursor Connection 规范定义了一种导航大型结果集的方法，方法是在以下情况下返回项的子集 每个项目都与一个光标配对，客户端可以使用该光标在 或 在引用的项目之后。

该规范将该模式称为“连接”。名称以结尾的架构类型 on Connection 是表示分页结果集的 Connection Type。所有类型都包含一个“edges”字段，其中类型将实际项目与光标配对，如 以及带有布尔标志的“pageInfo”字段，用于指示是否有更多项目转发 和落后。~Connection~Edge

连接类型

Connection必须为需要分页的每个类型创建类型定义，并添加 架构的样板和噪声。Spring for GraphQL 提供在启动时添加这些类型（如果尚未添加） 存在于解析的架构文件中。这意味着在架构中，您只需要以下内容：ConnectionTypeDefinitionConfigurer

Query {
	books(first:Int, after:String, last:Int, before:String): BookConnection
}

type Book {
	id: ID!
	title: String!
}

请注意规范定义的前向分页参数，客户端可以使用这些参数 请求给定光标后的前 N 项，而 和 是向后的 分页参数，用于请求给定游标之前的最后 N 项。firstafterlastbefore

接下来，按如下方式进行配置：ConnectionTypeDefinitionConfigurer

GraphQlSource.schemaResourceBuilder()
		.schemaResources(..)
		.typeDefinitionConfigurer(new ConnectionTypeDefinitionConfigurer)

以下类型定义将透明地添加到架构中：

type BookConnection {
	edges: [BookEdge]!
	pageInfo: PageInfo!
}

type BookEdge {
	node: Book!
	cursor: String!
}

type PageInfo {
	hasPreviousPage: Boolean!
	hasNextPage: Boolean!
	startCursor: String
	endCursor: String
}

默认情况下，Boot Starter 会注册。ConnectionTypeDefinitionConfigurer

ConnectionAdapter

一旦连接类型在架构中可用，您还需要 等效的 Java 类型。GraphQL Java 提供了这些功能，包括泛型 和 ，以及 .ConnectionEdgePageInfo

一种选择是填充 a 并从控制器方法返回它，或者 .但是，这需要样板代码来创建 ， 创建游标，将每个项包装为 ，并创建 . 此外，您可能已经拥有底层分页机制，例如在使用 Spring 数据存储库。ConnectionDataFetcherConnectionEdgePageInfo

Spring for GraphQL 定义了适应项目容器的协定 自。适配器通过装饰器应用，而装饰器又是 通过 .您可以按如下方式进行配置：ConnectionAdapterConnectionDataFetcherConnectionFieldTypeVisitor

ConnectionAdapter adapter = ... ;
GraphQLTypeVisitor visitor = ConnectionFieldTypeVisitor.create(List.of(adapter)) (1)

GraphQlSource.schemaResourceBuilder()
		.schemaResources(..)
		.typeDefinitionConfigurer(..)
		.typeVisitors(List.of(visitor)) (2)
1 创建具有一个或多个 s 的类型访客。ConnectionAdapter
2 抵抗类型访客。

Spring Data 和 .您还可以创建自己的自定义适配器。 实现依赖于 CursorStrategy 来 为返回的项目创建游标。相同的策略也用于支持子范围控制器方法参数，该参数包含 分页输入。ConnectionAdapterWindowSliceConnectionAdapter

CursorStrategy

CursorStrategy是编码和解码 String 游标的协定，该游标引用 项在大型结果集中的位置。光标可以基于索引或 在键集上。

ConnectionAdapter 使用它对返回项的游标进行编码。Annotated Controllers 方法、Querydsl 存储库和 Query by Example 存储库使用它来解码分页请求中的游标，并创建一个 .Subrange

CursorEncoder是一个相关的合约，它进一步编码和解码 String 游标 使它们对客户不透明。 与 .您可以使用 ，也可以创建自己的。EncodingCursorStrategyCursorStrategyCursorEncoderBase64CursorEncoderNoOpEncoder

有一个内置的 Spring Data .当 Spring Data 存在时，Boot Starter 会注册 a。CursorStrategyScrollPositionCursorStrategy<ScrollPosition>Base64Encoder

排序

没有在 GraphQL 请求中提供排序信息的标准方法。然而 分页取决于稳定的排序顺序。您可以使用默认订单，也可以使用其他方式 公开输入类型并从 GraphQL 参数中提取排序详细信息。

内置支持Spring Data作为控制器 method 参数。为此，您需要有一个 bean。SortSortStrategy

1 创建具有一个或多个 s 的类型访客。ConnectionAdapter
2 抵抗类型访客。

批量加载

给定 a 和 its ，我们可以为一本书创建一个，另一个 对于它的作者。这允许选择有或没有作者的书籍，但这意味着书籍 而且作者没有加载在一起，这在查询多个作者时效率尤其低下 书籍作为每本书的作者是单独加载的。这称为 N+1 选择 问题。BookAuthorDataFetcher

DataLoader

GraphQL Java 提供了一种批量加载相关实体的机制。 您可以在 GraphQL Java 文档中找到完整的详细信息。下面是一个 工作原理摘要：DataLoader

  1. 在给定唯一键的情况下，在可以加载实体的 中注册 的。DataLoaderDataLoaderRegistry

  2. DataFetcher可以访问 ，并使用它们按 id 加载实体。DataLoader

  3. A 通过返回 future 来延迟加载，以便可以批量完成。DataLoader

  4. DataLoader维护每个请求的已加载实体缓存，可以进一步 提高效率。

BatchLoaderRegistry

GraphQL Java 中的完整批处理加载机制需要实现以下之一 几个接口，然后将它们包装并注册为 S 名称在 .BatchLoaderDataLoaderDataLoaderRegistry

Spring GraphQL 中的 API 略有不同。对于注册，只有一个， 集中公开工厂方法和构建器来创建和 注册任意数量的批量加载函数：BatchLoaderRegistry

@Configuration
public class MyConfig {

	public MyConfig(BatchLoaderRegistry registry) {

		registry.forTypePair(Long.class, Author.class).registerMappedBatchLoader((authorIds, env) -> {
				// return Mono<Map<Long, Author>
		});

		// more registrations ...
	}

}

Boot Starter 声明一个可以注入的 Bean 您的配置，如上所示，或按顺序放入任何组件（如控制器） 注册批量加载函数。反过来，它被注入到它确保每个请求注册的地方。BatchLoaderRegistryBatchLoaderRegistryDefaultExecutionGraphQlServiceDataLoader

默认情况下，该名称基于目标实体的类名。 这允许方法使用泛型类型声明 DataLoader 参数，并且 无需指定名称。但是，如有必要，可以通过构建器自定义该名称以及其他 .DataLoader@SchemaMappingBatchLoaderRegistryDataLoaderOptions

全局配置默认值，用作任何 注册，您可以覆盖 Boot 的 bean 并使用构造函数 因为那接受.DataLoaderOptionsBatchLoaderRegistryDefaultBatchLoaderRegistrySupplier<DataLoaderOptions>

在许多情况下，在加载相关实体时，可以使用@BatchMapping控制器方法，这是一种快捷方式 用于和替换需要直接使用。BatchLoaderRegistryDataLoader

BatchLoaderRegistry还提供其他重要好处。它支持访问 从批处理加载函数和从方法， 以及确保向他们传播上下文。这就是需要申请的原因 使用它。可以直接执行自己的注册，但 此类注册将放弃上述好处。GraphQLContext@BatchMappingDataLoader

测试批处理加载

首先在以下方面执行注册：BatchLoaderRegistryDataLoaderRegistry

BatchLoaderRegistry batchLoaderRegistry = new DefaultBatchLoaderRegistry();
// perform registrations...

DataLoaderRegistry dataLoaderRegistry = DataLoaderRegistry.newRegistry().build();
batchLoaderRegistry.registerDataLoaders(dataLoaderRegistry, graphQLContext);

现在，您可以按如下方式访问和测试个人：DataLoader

DataLoader<Long, Book> loader = dataLoaderRegistry.getDataLoader(Book.class.getName());
loader.load(1L);
loader.loadMany(Arrays.asList(2L, 3L));
List<Book> books = loader.dispatchAndJoin(); // actual loading

assertThat(books).hasSize(3);
assertThat(books.get(0).getName()).isEqualTo("...");
// ...