实现 GraphQL 服务器

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>io.vertx.howtos</groupId>
  <artifactId>graphql-howto</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <vertx.version>5.0.0.CR2</vertx.version>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-stack-depchain</artifactId>
        <version>${vertx.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-web-graphql</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.13.0</version>
        <configuration>
          <release>17</release>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>3.5.0</version>
        <configuration>
          <mainClass>io.vertx.howtos.graphql.GraphQLVerticle</mainClass>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

plugins {
  java
  application
}

repositories {
  mavenCentral()
}

java {
  toolchain {
    languageVersion.set(JavaLanguageVersion.of(17))
  }
}

dependencies {
  implementation(platform("io.vertx:vertx-stack-depchain:5.0.0.CR2"))
  implementation("io.vertx:vertx-web-graphql")
}

application {
  mainClass.set("io.vertx.howtos.graphql.GraphQLVerticle")
}

package io.vertx.howtos.graphql;

import java.util.UUID;

public record Task(String id, String description, boolean completed) {

  public Task(String description) {
    this(UUID.randomUUID().toString(), description, false); // (1)
  }
}

  private Map<String, Task> initData() {
    return Stream.of(
      new Task("Learn GraphQL"),
      new Task("Build awesome GraphQL server"),
      new Task("Profit")
    ).collect(toMap(Task::id, identity()));
  }

  private GraphQL setupGraphQL() {
    var schema = vertx.fileSystem().readFileBlocking("tasks.graphqls").toString(); // (1)

    var schemaParser = new SchemaParser();
    var typeDefinitionRegistry = schemaParser.parse(schema); // (2)

    var runtimeWiring = newRuntimeWiring() // (3)
      .type("Query", builder -> builder.dataFetcher("allTasks", this::allTasks))
      .type("Mutation", builder -> builder.dataFetcher("complete", this::complete))
      .build();

    var schemaGenerator = new SchemaGenerator();
    var graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring); // (4)

    return GraphQL.newGraphQL(graphQLSchema).build(); // (5)
  }

  private List<Task> allTasks(DataFetchingEnvironment env) {
    boolean uncompletedOnly = env.getArgument("uncompletedOnly");
    return tasks.values().stream()
      .filter(task -> !uncompletedOnly || !task.completed())
      .collect(toList());
  }

  private boolean complete(DataFetchingEnvironment env) {
    String id = env.getArgument("id");
    var task = tasks.get(id);
    if (task == null) {
      return false;
    }
    tasks.put(id, new Task(task.id(), task.description(), true));
    return true;
  }

  private Map<String, Task> tasks;

  @Override
  public Future<?> start() {
    tasks = initData();

    var graphQL = setupGraphQL();
    var graphQLHandler = GraphQLHandler.create(graphQL); // (1)

    var router = Router.router(vertx);
    router.route().handler(BodyHandler.create()); // (2)
    router.route("/graphql").handler(graphQLHandler); // (3)

    return vertx.createHttpServer()
      .requestHandler(router)
      .listen(8080);
  }