带注解的控制器

Spring for GraphQL 提供了一个基于注解的编程模型，其中 @Controller 组件使用注解来声明处理程序方法，这些方法具有灵活的方法签名，用于获取特定 GraphQL 字段的数据。例如

@Controller
public class GreetingController {

		@QueryMapping (1)
		public String hello() { (2)
			return "Hello, world!";
		}

}

1	将此方法绑定到查询，即 Query 类型下的字段。
2	如果未在注解上声明，则从方法名称确定查询。

Spring for GraphQL 使用 RuntimeWiring.Builder 将上述处理程序方法注册为名为“hello”的查询的 graphql.schema.DataFetcher。

声明

您可以将 @Controller bean 定义为标准的 Spring bean 定义。@Controller 构造型允许自动检测，与 Spring 对检测类路径上的 @Controller 和 @Component 类以及为其自动注册 bean 定义的一般支持保持一致。它也充当带注解类的构造型，指示其在 GraphQL 应用程序中的数据获取组件的角色。

AnnotatedControllerConfigurer 检测 @Controller bean 并通过 RuntimeWiring.Builder 将其带注解的处理程序方法注册为 DataFetcher。它是 RuntimeWiringConfigurer 的实现，可以添加到 GraphQlSource.Builder 中。该启动器自动将 AnnotatedControllerConfigurer 声明为 bean 并将所有 RuntimeWiringConfigurer bean 添加到 GraphQlSource.Builder 中，从而启用对带注解的 DataFetcher 的支持，请参阅启动器文档中的 GraphQL 运行时连接部分。

`@SchemaMapping`

@SchemaMapping 注解将处理程序方法映射到 GraphQL 模式中的字段，并将其声明为该字段的 DataFetcher。该注解可以指定父类型名称和字段名称

@Controller
public class BookController {

	@SchemaMapping(typeName="Book", field="author")
	public Author getAuthor(Book book) {
		// ...
	}
}

@SchemaMapping 注解也可以省略这些属性，在这种情况下，字段名称默认为方法名称，而类型名称默认为注入到方法中的源/父对象的简单类名称。例如，以下内容默认为类型“Book”和字段“author”

@Controller
public class BookController {

	@SchemaMapping
	public Author author(Book book) {
		// ...
	}
}

@SchemaMapping 注解可以在类级别声明，以指定类中所有处理程序方法的默认类型名称。

@Controller
@SchemaMapping(typeName="Book")
public class BookController {

	// @SchemaMapping methods for fields of the "Book" type

}

@QueryMapping、@MutationMapping 和 @SubscriptionMapping 是元注解，它们本身使用 @SchemaMapping 进行注解，并且其 typeName 预设为 Query、Mutation 或 Subscription。实际上，这些是 Query、Mutation 和 Subscription 类型下字段的快捷注解。例如

@Controller
public class BookController {

	@QueryMapping
	public Book bookById(@Argument Long id) {
		// ...
	}

	@MutationMapping
	public Book addBook(@Argument BookInput bookInput) {
		// ...
	}

	@SubscriptionMapping
	public Flux<Book> newPublications() {
		// ...
	}
}

@SchemaMapping 处理程序方法具有灵活的签名，并且可以选择各种方法参数和返回值。

方法参数

模式映射处理程序方法可以具有以下任何方法参数

方法参数描述

方法参数	描述
`@Argument`	用于访问绑定到更高级别类型化对象的命名字段参数。参见 `@Argument`。
`@Argument Map<String, Object>`	用于访问原始参数值。参见 `@Argument`。
`ArgumentValue`	用于访问绑定到更高级别类型化对象的命名字段参数，以及一个标志，用于指示输入参数是否被省略或设置为 `null`。参见 `ArgumentValue`。
`@Arguments`	用于访问绑定到更高级别类型化对象的所有字段参数。参见 `@Arguments`。
`@Arguments Map<String, Object>`	用于访问参数的原始映射。
`@ProjectedPayload` 接口	用于通过项目接口访问字段参数。参见 `@ProjectedPayload` 接口。
"源"	用于访问字段的源（即父/容器）实例。参见源。
`Subrange` 和 `ScrollSubrange`	用于访问分页参数。参见分页、滚动、`Subrange`。
`排序`	用于访问排序详细信息。参见分页、`Sort`。
`DataLoader`	用于访问 `DataLoaderRegistry` 中的 `DataLoader`。参见 `DataLoader`。
`@ContextValue`	用于访问 `DataFetchingEnvironment` 中的主 `GraphQLContext` 中的属性。
`@LocalContextValue`	用于访问 `DataFetchingEnvironment` 中的本地 `GraphQLContext` 中的属性。
`GraphQLContext`	用于访问 `DataFetchingEnvironment` 中的上下文。
`java.security.Principal`	如果可用，则从 Spring Security 上下文获取。
`@AuthenticationPrincipal`	用于访问 Spring Security 上下文中的 `Authentication#getPrincipal()`。
`DataFetchingFieldSelectionSet`	用于通过 `DataFetchingEnvironment` 访问查询的选择集。
`Locale`、`Optional<Locale>`	用于访问 `DataFetchingEnvironment` 中的 `Locale`。
`DataFetchingEnvironment`	用于直接访问底层的 `DataFetchingEnvironment`。

@Argument

用于访问绑定到更高级别类型化对象的命名字段参数。

参见 @Argument。

@Argument Map<String, Object>

用于访问原始参数值。

参见 @Argument。

ArgumentValue

用于访问绑定到更高级别类型化对象的命名字段参数，以及一个标志，用于指示输入参数是否被省略或设置为 null。

参见 ArgumentValue。

@Arguments

用于访问绑定到更高级别类型化对象的所有字段参数。

参见 @Arguments。

@Arguments Map<String, Object>

用于访问参数的原始映射。

@ProjectedPayload 接口

用于通过项目接口访问字段参数。

参见 @ProjectedPayload 接口。

"源"

用于访问字段的源（即父/容器）实例。

参见源。

Subrange 和 ScrollSubrange

用于访问分页参数。

参见分页、滚动、Subrange。

排序

用于访问排序详细信息。

参见分页、Sort。

DataLoader

用于访问 DataLoaderRegistry 中的 DataLoader。

参见 DataLoader。

@ContextValue

用于访问 DataFetchingEnvironment 中的主 GraphQLContext 中的属性。

@LocalContextValue

用于访问 DataFetchingEnvironment 中的本地 GraphQLContext 中的属性。

GraphQLContext

用于访问 DataFetchingEnvironment 中的上下文。

java.security.Principal

如果可用，则从 Spring Security 上下文获取。

@AuthenticationPrincipal

用于访问 Spring Security 上下文中的 Authentication#getPrincipal()。

DataFetchingFieldSelectionSet

用于通过 DataFetchingEnvironment 访问查询的选择集。

Locale、Optional<Locale>

用于访问 DataFetchingEnvironment 中的 Locale。

DataFetchingEnvironment

用于直接访问底层的 DataFetchingEnvironment。

返回值

模式映射处理程序方法可以返回

任何类型的解析值。
Mono 和 Flux 用于异步值。支持控制器方法和响应式 DataFetcher 中描述的任何 DataFetcher。
Kotlin 协程和 Flow 被适配为 Mono 和 Flux。
java.util.concurrent.Callable 用于异步生成值。为此，必须使用 Executor 配置 AnnotatedControllerConfigurer。

在 Java 21 及更高版本中，当 AnnotatedControllerConfigurer 使用 Executor 配置时，具有阻塞方法签名的控制器方法将异步调用。默认情况下，如果控制器方法不返回异步类型（如 Flux、Mono、CompletableFuture），并且也不是 Kotlin 挂起函数，则会被视为阻塞。您可以在 AnnotatedControllerConfigurer 上配置阻塞控制器方法 Predicate 以帮助确定哪些方法被视为阻塞。

Spring for GraphQL 的 Spring Boot 启动器在属性 spring.threads.virtual.enabled 设置时，会自动使用 Executor（用于虚拟线程）配置 AnnotatedControllerConfigurer。

接口模式映射

当控制器方法映射到架构接口字段时，默认情况下，映射会被替换为多个映射，每个实现该接口的架构对象类型对应一个映射。这允许使用一个控制器方法来处理所有子类型。

例如，给定

type Query {
	activities: [Activity!]!
}

interface Activity {
	id: ID!
	coordinator: User!
}

type FooActivity implements Activity {
	id: ID!
	coordinator: User!
}

type BarActivity implements Activity {
	id: ID!
	coordinator: User!
}

type User {
	name: String!
}

您可以编写如下控制器

@Controller
public class BookController {

	@QueryMapping
	public List<Activity> activities() {
		// ...
	}

	@SchemaMapping
	public User coordinator(Activity activity) {
		// Called for any Activity subtype
	}

}

如有必要，您可以接管各个子类型的映射

@Controller
public class BookController {

	@QueryMapping
	public List<Activity> activities() {
		// ...
	}

	@SchemaMapping
	public User coordinator(Activity activity) {
		// Called for any Activity subtype except FooActivity
	}

	@SchemaMapping
	public User coordinator(FooActivity activity) {
		// ...
	}

}

`@Argument`

在 GraphQL Java 中，DataFetchingEnvironment 提供对字段特定参数值的映射的访问。这些值可以是简单的标量值（例如 String、Long）、用于更复杂输入的 Map 或值的 List。

使用 @Argument 注解将参数绑定到目标对象并注入到处理程序方法中。绑定是通过将参数值映射到预期方法参数类型的首要数据构造函数，或通过使用默认构造函数创建对象，然后将参数值映射到其属性来执行的。此过程会递归重复，使用所有嵌套的参数值并相应地创建嵌套的目标对象。例如

@Controller
public class BookController {

	@QueryMapping
	public Book bookById(@Argument Long id) {
		// ...
	}

	@MutationMapping
	public Book addBook(@Argument BookInput bookInput) {
		// ...
	}
}

如果目标对象没有 setter 方法，并且您无法更改它，则可以使用 AnnotatedControllerConfigurer 上的一个属性来允许回退到通过直接字段访问进行绑定。

默认情况下，如果方法参数名称可用（需要使用 Java 8+ 的 -parameters 编译器标志或来自编译器的调试信息），则会使用它来查找参数。如果需要，您可以通过注解自定义名称，例如 @Argument("bookInput")。

@Argument 注解没有“required”标志，也没有指定默认值的选项。这两者都可以在 GraphQL 架构级别指定，并由 GraphQL Java 强制执行。

如果绑定失败，则会引发 BindException，并将绑定问题累积为字段错误，其中每个错误的 field 是发生问题的参数路径。

您可以将 @Argument 与 Map<String, Object> 参数一起使用，以获取参数的原始值。例如

@Controller
public class BookController {

	@MutationMapping
	public Book addBook(@Argument Map<String, Object> bookInput) {
		// ...
	}
}

在 1.2 之前，如果注解未指定名称，则 @Argument Map<String, Object> 会返回完整的参数映射。1.2 之后，带有 Map<String, Object> 的 @Argument 始终返回原始参数值，匹配注解中指定的名称或参数名称。要访问完整的参数映射，请改用 @Arguments。

`ArgumentValue`

默认情况下，GraphQL 中的输入参数是可空且可选的，这意味着参数可以设置为 null 字面量，或者根本不提供。这种区别对于使用变异进行部分更新很有用，其中基础数据也可以相应地设置为 null 或根本不更改。当使用 @Argument 时，无法进行这种区分，因为在这两种情况下您都会得到 null 或一个空的 Optional。

如果您想知道值是否根本没有提供，您可以声明一个 ArgumentValue 方法参数，它是一个简单的容器，用于存储结果值，以及一个标志，用于指示输入参数是否完全省略。您可以使用它代替 @Argument，在这种情况下，参数名称由方法参数名称确定，或者与 @Argument 一起使用以指定参数名称。

例如

@Controller
public class BookController {

	@MutationMapping
	public void addBook(ArgumentValue<BookInput> bookInput) {
		if (!bookInput.isOmitted()) {
			BookInput value = bookInput.value();
			// ...
		}
	}
}

ArgumentValue 也支持作为 @Argument 方法参数的对象结构中的一个字段，可以通过构造函数参数或 setter 方法初始化，包括作为顶级对象下方任意级别的嵌套对象的字段。

`@Arguments`

如果您想将完整的参数映射绑定到单个目标对象上，请使用 @Arguments 注解，这与 @Argument 形成对比，后者绑定特定的命名参数。

例如，@Argument BookInput bookInput 使用参数“bookInput”的值来初始化 BookInput，而 @Arguments 使用完整的参数映射，在这种情况下，顶级参数绑定到 BookInput 属性。

您可以将 @Arguments 与 Map<String, Object> 参数一起使用，以获取所有参数值的原始映射。

`@ProjectedPayload` 接口

作为使用完整对象与 @Argument 的替代方案，您还可以使用投影接口通过定义明确的最小接口来访问 GraphQL 请求参数。当 Spring Data 位于类路径上时，Spring Data 的接口投影提供参数投影。Spring Data’s Interface projections

要使用此功能，请创建一个使用 @ProjectedPayload 注解的接口，并将其声明为控制器方法参数。如果参数使用 @Argument 注解，则它适用于 DataFetchingEnvironment.getArguments() 映射中的单个参数。当不使用 @Argument 声明时，投影将在完整参数映射中的顶级参数上工作。

例如

@Controller
public class BookController {

	@QueryMapping
	public Book bookById(BookIdProjection bookId) {
		// ...
	}

	@MutationMapping
	public Book addBook(@Argument BookInputProjection bookInput) {
		// ...
	}
}

@ProjectedPayload
interface BookIdProjection {

	Long getId();
}

@ProjectedPayload
interface BookInputProjection {

	String getName();

	@Value("#{target.author + ' ' + target.name}")
	String getAuthorAndName();
}

源

在 GraphQL Java 中，DataFetchingEnvironment 提供对字段的源（即父/容器）实例的访问。要访问它，只需声明一个预期目标类型的方法参数即可。

@Controller
public class BookController {

	@SchemaMapping
	public Author author(Book book) {
		// ...
	}
}

源方法参数还有助于确定映射的类型名称。如果 Java 类的简单名称与 GraphQL 类型匹配，则无需在 @SchemaMapping 注解中显式指定类型名称。

给定一组源/父书籍对象，@BatchMapping 处理程序方法可以批量加载所有作者以进行查询。

`Subrange`

当 Spring 配置中存在 CursorStrategy bean 时，控制器方法支持 Subrange<P> 参数，其中 <P> 是从游标转换的相对位置。对于 Spring Data，ScrollSubrange 公开 ScrollPosition。例如

@Controller
public class BookController {

	@QueryMapping
	public Window<Book> books(ScrollSubrange subrange) {
		ScrollPosition position = subrange.position().orElse(ScrollPosition.offset());
		int count = subrange.count().orElse(20);
		// ...
	}

}

有关分页和内置机制的概述，请参阅分页。

`Sort`

当 Spring 配置中存在 SortStrategy bean 时，控制器方法支持将 Sort 作为方法参数。例如

@Controller
public class BookController {

	@QueryMapping
	public Window<Book> books(Optional<Sort> optionalSort) {
		Sort sort = optionalSort.orElse(Sort.by(..));
	}

}

`DataLoader`

当您为实体注册批量加载函数时（如批量加载中所述），您可以通过声明类型为 DataLoader 的方法参数来访问该实体的 DataLoader，并使用它来加载实体

@Controller
public class BookController {

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

	@SchemaMapping
	public CompletableFuture<Author> author(Book book, DataLoader<Long, Author> loader) {
		return loader.load(book.getAuthorId());
	}

}

默认情况下，BatchLoaderRegistry 使用值类型的完整类名（例如 Author 的类名）作为注册的键，因此只需使用泛型类型声明 DataLoader 方法参数即可提供足够的信息来在 DataLoaderRegistry 中找到它。作为后备，DataLoader 方法参数解析器也将尝试使用方法参数名称作为键，但通常不需要这样做。

请注意，对于许多加载相关实体的情况，其中 @SchemaMapping 只是委托给 DataLoader，您可以通过使用下一节中描述的 @BatchMapping 方法来减少样板代码。

验证

当找到 javax.validation.Validator bean 时，AnnotatedControllerConfigurer 会启用对带注解的控制器方法的 Bean Validation 支持。通常，bean 的类型为 LocalValidatorFactoryBean。

Bean 验证允许您在类型上声明约束

public class BookInput {

	@NotNull
	private String title;

	@NotNull
	@Size(max=13)
	private String isbn;
}

然后，您可以使用 @Valid 注解控制器方法参数，以便在方法调用之前对其进行验证

@Controller
public class BookController {

	@MutationMapping
	public Book addBook(@Argument @Valid BookInput bookInput) {
		// ...
	}
}

如果在验证过程中发生错误，则会引发 ConstraintViolationException。您可以使用异常链来决定如何将其呈现给客户端，方法是将其转换为错误以包含在 GraphQL 响应中。

除了 @Valid 之外，您还可以使用 Spring 的 @Validated，它允许指定验证组。

Bean 验证对于 @Argument、@Arguments 和 @ProjectedPayload 方法参数很有用，但更普遍地适用于任何方法参数。

验证和 Kotlin 协程

Hibernate Validator 与 Kotlin 协程方法不兼容，在内省其方法参数时会失败。有关相关问题的链接和建议的解决方法，请参阅 spring-projects/spring-graphql#344 (comment)。

`@BatchMapping`

批量加载通过使用 org.dataloader.DataLoader 来延迟单个实体实例的加载来解决 N+1 选择问题，以便可以将它们一起加载。例如

@Controller
public class BookController {

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

	@SchemaMapping
	public CompletableFuture<Author> author(Book book, DataLoader<Long, Author> loader) {
		return loader.load(book.getAuthorId());
	}

}

对于上面所示的加载关联实体的简单情况，@SchemaMapping 方法除了委托给 DataLoader 之外什么也不做。这是一种可以使用 @BatchMapping 方法避免的样板代码。例如

@Controller
public class BookController {

	@BatchMapping
	public Mono<Map<Book, Author>> author(List<Book> books) {
		// ...
	}
}

上面变成了 BatchLoaderRegistry 中的批量加载函数，其中键是 Book 实例，加载的值是它们的作者。此外，DataFetcher 也透明地绑定到类型 Book 的 author 字段，它只是委托给作者的 DataLoader，给定其源/父 Book 实例。

要作为唯一键使用，Book 必须实现 hashcode 和 equals。

默认情况下，字段名称默认为方法名称，类型名称默认为输入 List 元素类型的简单类名。两者都可以通过注解属性自定义。类型名称也可以从类级别的 @SchemaMapping 继承。

方法参数

批量映射方法支持以下参数

方法参数描述

方法参数	描述
`List<K>`	源/父对象。
`java.security.Principal`	如果可用，则从 Spring Security 上下文获取。
`@ContextValue`	要访问 `BatchLoaderEnvironment` 的 `GraphQLContext` 中的值，该值与 `DataFetchingEnvironment` 中的值相同。
`GraphQLContext`	要访问来自`BatchLoaderEnvironment`的上下文，该上下文与来自`DataFetchingEnvironment`的上下文相同。
`BatchLoaderEnvironment`	在GraphQL Java中，可用于`org.dataloader.BatchLoaderWithContext`的环境。 `BatchLoaderEnvironment`的`context`属性返回与`@SchemaMapping`方法通过`DataFetchingEnvironment`获得的相同的`GraphQLContext`实例。 `BatchLoaderEnvironment`的`keyContexts`属性返回在为每个键调用`DataLoader`时从`DataFetchingEnvironment`获得的localContext。

List<K>

源/父对象。

java.security.Principal

如果可用，则从 Spring Security 上下文获取。

@ContextValue

要访问 BatchLoaderEnvironment 的 GraphQLContext 中的值，该值与 DataFetchingEnvironment 中的值相同。

GraphQLContext

要访问来自BatchLoaderEnvironment的上下文，该上下文与来自DataFetchingEnvironment的上下文相同。

BatchLoaderEnvironment

在GraphQL Java中，可用于org.dataloader.BatchLoaderWithContext的环境。

BatchLoaderEnvironment的context属性返回与@SchemaMapping方法通过DataFetchingEnvironment获得的相同的GraphQLContext实例。

BatchLoaderEnvironment的keyContexts属性返回在为每个键调用DataLoader时从DataFetchingEnvironment获得的localContext。

返回值

批量映射方法可以返回

返回类型描述

返回类型	描述
`Mono<Map<K,V>>`	一个以父对象为键，批量加载的对象为值的映射。
`Flux<V>`	批量加载的对象序列，必须与传递到方法中的源/父对象的顺序相同。
`Map<K,V>`, `Collection<V>`	命令式变体，例如，无需进行远程调用。
`Callable<Map<K,V>>`, `Callable<Collection<V>>`	要异步调用的命令式变体。要使其正常工作，`AnnotatedControllerConfigurer`必须配置有`Executor`。
带有`Map<K,V>`的Kotlin协程，Kotlin `Flow<K,V>`	适配到`Mono<Map<K,V>`和`Flux<V>`。

Mono<Map<K,V>>

一个以父对象为键，批量加载的对象为值的映射。

Flux<V>

批量加载的对象序列，必须与传递到方法中的源/父对象的顺序相同。

Map<K,V>, Collection<V>

命令式变体，例如，无需进行远程调用。

Callable<Map<K,V>>, Callable<Collection<V>>

要异步调用的命令式变体。要使其正常工作，AnnotatedControllerConfigurer必须配置有Executor。

带有Map<K,V>的Kotlin协程，Kotlin Flow<K,V>

适配到Mono<Map<K,V>和Flux<V>。

Spring for GraphQL 的 Spring Boot 启动器在属性 spring.threads.virtual.enabled 设置时，会自动使用 Executor（用于虚拟线程）配置 AnnotatedControllerConfigurer。

接口批量映射

与接口模式映射一样，当批量映射方法映射到模式接口字段时，映射将被替换为多个映射，每个实现接口的模式对象类型一个。

这意味着，给定以下内容

type Query {
	activities: [Activity!]!
}

interface Activity {
	id: ID!
	coordinator: User!
}

type FooActivity implements Activity {
	id: ID!
	coordinator: User!
}

type BarActivity implements Activity {
	id: ID!
	coordinator: User!
}

type User {
	name: String!
}

您可以编写如下控制器

@Controller
public class BookController {

	@QueryMapping
	public List<Activity> activities() {
		// ...
	}

	@BatchMapping
	Map<Activity, User> coordinator(List<Activity> activities) {
		// Called for all Activity subtypes
	}
}

如有必要，您可以接管各个子类型的映射

@Controller
public class BookController {

	@QueryMapping
	public List<Activity> activities() {
		// ...
	}

	@BatchMapping
	Map<Activity, User> coordinator(List<Activity> activities) {
		// Called for all Activity subtypes
	}

	@BatchMapping(field = "coordinator")
	Map<Activity, User> fooCoordinator(List<FooActivity> activities) {
		// ...
	}
}

`@GraphQlExceptionHandler`

使用@GraphQlExceptionHandler方法处理数据获取中的异常，并使用灵活的方法签名。当在控制器中声明时，异常处理程序方法适用于来自同一控制器的异常

@Controller
public class BookController {

	@QueryMapping
	public Book bookById(@Argument Long id) {
		// ...
	}

	@GraphQlExceptionHandler
	public GraphQLError handle(BindException ex) {
		return GraphQLError.newError().errorType(ErrorType.BAD_REQUEST).message("...").build();
	}
}

当在@ControllerAdvice中声明时，异常处理程序方法适用于所有控制器

@ControllerAdvice
public class GlobalExceptionHandler {

	@GraphQlExceptionHandler
	public GraphQLError handle(BindException ex) {
		return GraphQLError.newError().errorType(ErrorType.BAD_REQUEST).message("...").build();
	}

}

通过@GraphQlExceptionHandler方法进行的异常处理会自动应用于控制器调用。要处理来自其他graphql.schema.DataFetcher实现的异常（不基于控制器方法），请从AnnotatedControllerConfigurer获取DataFetcherExceptionResolver，并在GraphQlSource.Builder中将其注册为DataFetcherExceptionResolver。

方法签名

异常处理程序方法支持灵活的方法签名，其方法参数从DataFetchingEnvironment解析，并与@SchemaMapping方法的方法参数匹配。

支持的返回类型列在下面

返回类型描述

返回类型	描述
`graphql.GraphQLError`	将异常解析为单个字段错误。
`Collection<GraphQLError>`	将异常解析为多个字段错误。
`void`	在没有响应错误的情况下解析异常。
`Object`	将异常解析为单个错误、多个错误或无错误。返回值必须是`GraphQLError`、`Collection<GraphQLError>`或`null`。
`Mono<T>`	用于异步解析，其中`<T>`是支持的同步返回类型之一。

graphql.GraphQLError

将异常解析为单个字段错误。

Collection<GraphQLError>

将异常解析为多个字段错误。

void

在没有响应错误的情况下解析异常。

Object

将异常解析为单个错误、多个错误或无错误。返回值必须是GraphQLError、Collection<GraphQLError>或null。

Mono<T>

用于异步解析，其中<T>是支持的同步返回类型之一。

命名空间

在模式级别，查询和变异操作直接在Query和Mutation类型下定义。丰富的GraphQL API可以在这些类型下定义数十个操作，这使得探索API和分离关注点变得更加困难。您可以选择在GraphQL模式中定义命名空间。虽然这种方法有一些注意事项，但您可以使用Spring for GraphQL带注释的控制器实现此模式。

使用命名空间，您的GraphQL模式可以例如将查询操作嵌套在顶级类型下，而不是直接在Query下列出它们。在这里，我们将定义MusicQueries和UserQueries类型，并使它们在Query下可用

type Query {
    music: MusicQueries
    users: UserQueries
}

type MusicQueries {
    album(id: ID!): Album
    searchForArtist(name: String!): [Artist]
}

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

type Artist {
    id: ID!
    name: String!
}

type UserQueries {
    user(login: String): User
}

type User {
    id: ID!
    login: String!
}

GraphQL客户端将像这样使用album查询

{
  music {
    album(id: 42) {
      id
      title
    }
  }
}

并获得以下响应

{
  "data": {
    "music": {
      "album": {
        "id": "42",
        "title": "Spring for GraphQL"
      }
    }
  }
}

这可以在具有以下模式的@Controller中实现

import java.util.List;

import org.springframework.graphql.data.method.annotation.Argument;
import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.graphql.data.method.annotation.SchemaMapping;
import org.springframework.stereotype.Controller;

@Controller
@SchemaMapping(typeName = "MusicQueries") (1)
public class MusicController {

	@QueryMapping (2)
	public MusicQueries music() {
		return new MusicQueries();
	}

	(3)
	public record MusicQueries() {

	}

	@SchemaMapping (4)
	public Album album(@Argument String id) {
		return new Album(id, "Spring GraphQL");
	}

	@SchemaMapping
	public List<Artist> searchForArtist(@Argument String name) {
		return List.of(new Artist("100", "the Spring team"));
	}


}

1	使用`@SchemaMapping`和`typeName`属性注释控制器，以避免在方法上重复。
2	为“music”命名空间定义一个`@QueryMapping`
3	“music”查询返回一个“空”记录，但也可能返回一个空映射
4	查询现在声明为“MusicQueries”类型下的字段

您可以选择使用Spring Boot的GraphQlSourceBuilderCustomizer通过运行时连接来配置它们，而不是在控制器中显式声明包装类型（“MusicQueries”、“UserQueries”）。

import java.util.Collections;
import java.util.List;

import org.springframework.boot.autoconfigure.graphql.GraphQlSourceBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class NamespaceConfiguration {

	@Bean
	public GraphQlSourceBuilderCustomizer customizer() {
		List<String> queryWrappers = List.of("music", "users"); (1)

		return (sourceBuilder) -> sourceBuilder.configureRuntimeWiring((wiringBuilder) ->
				queryWrappers.forEach((field) -> wiringBuilder.type("Query",
						(builder) -> builder.dataFetcher(field, (env) -> Collections.emptyMap()))) (2)
		);
	}

}

1	列出“Query”类型的所有包装类型
2	手动为每个包装类型声明数据提取器，并返回一个空映射

带注解的控制器

声明

@SchemaMapping

方法参数

返回值

接口模式映射

@Argument

ArgumentValue

@Arguments

@ProjectedPayload 接口

源

Subrange

Sort

DataLoader

验证

@BatchMapping

方法参数

返回值

接口批量映射

@GraphQlExceptionHandler

方法签名

命名空间

`@SchemaMapping`

`@Argument`

`ArgumentValue`

`@Arguments`

`@ProjectedPayload` 接口

`Subrange`

`Sort`

`DataLoader`

`@BatchMapping`

`@GraphQlExceptionHandler`