知識庫 / REST RSS 訂閱

public class Book {
    private String id;
    private String title;
    private String author;

    // constructor, getter and setter methods
}

public class BookService {
    private final List<Book> books = new ArrayList<>();

    public BookService() {
        books.add(new Book("1", "Clean Code", "Robert"));
        books.add(new Book("2", "Effective Java", "Joshua"));
    }

    public List<Book> getBooks() {
        return books;
    }

    public Book getBookById(String id) {
        return books.stream().filter(b -> b.getId().equals(id)).findFirst().orElse(null);
    }

    public Book addBook(Book book) {
        books.add(book);
        return book;
    }
}

public class BookRoute extends RouteBuilder {
    private final BookService bookService = new BookService();

    @Override
    public void configure() {
        onException(Exception.class)
          .handled(true)
          .setHeader("Content-Type", constant("application/json"))
          .setBody(simple("{\"error\": \"${exception.message}\"}"));
        restConfiguration()
          .component("jetty")
          .host("localhost")
          .port(8080)
          .contextPath("/api")
          .bindingMode(RestBindingMode.json);

        //...
    }
}

rest("/books") 
  .get().to("direct:getAllBooks") 
  .get("/{id}").to("direct:getBookById")
  .post().type(Book.class).to("direct:addBook");

from("direct:getAllBooks")
  .bean(bookService, "getBooks");

from("direct:getBookById")
  .bean(bookService, "getBookById(${header.id})");

from("direct:addBook")
  .bean(bookService, "addBook");

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

type Query {
  books: [Book]
  bookById(id: String!): Book
}

type Mutation {
  addBook(id: String!, title: String!, author: String): Book
}

模式從一個 Book 類型開始，它代表我們系統中的主要實體。該類型包含三個字段：id、title 和 author。 id 和 title 字段已用感嘆號 (!) 註釋，指示這些字段不能為空。

在類型定義之後，Query 類型概述了客户端可以執行的數據檢索操作。 具體來説，它允許客户端使用 books 查詢檢索所有書籍，或使用 bookById 查詢檢索單個書籍的 ID。

為了允許客户端創建新的書籍條目，我們添加一個 Mutation 類型。 addBook mutation 接受兩個參數——title（必需）和 author（可選），並返回新創建的 Book 對象。

現在我們需要創建一個將 GraphQL 查詢連接到 Java 服務的 schema 加載器類。我們創建一個名為 CustomSchemaLoader 的類，該類加載模式、將其解析為註冊表，並定義如何使用數據獲取器解決每個 GraphQL 操作：

public class CustomSchemaLoader{
    private final BookService bookService = new BookService();

    public GraphQLSchema loadSchema() {
        try (InputStream schemaStream = getClass().getClassLoader().getResourceAsStream("books.graphqls")) {
            if (schemaStream == null) {
                throw new RuntimeException("GraphQL schema file 'books.graphqls' not found in classpath");
            }

            TypeDefinitionRegistry registry = new SchemaParser()
              .parse(new InputStreamReader(schemaStream));

            RuntimeWiring wiring = buildRuntimeWiring();
            return new SchemaGenerator().makeExecutableSchema(registry, wiring);

        } catch (Exception e) {
            logger.error("Failed to load GraphQL schema", e);
            throw new RuntimeException("GraphQL schema initialization failed", e);
        }
    }

    public RuntimeWiring buildRuntimeWiring() {
        return RuntimeWiring.newRuntimeWiring()
          .type("Query", builder -> builder
            .dataFetcher("books", env -> bookService.getBooks())
            .dataFetcher("bookById", env -> bookService.getBookById(env.getArgument("id"))))
          .type("Mutation", builder -> builder
            .dataFetcher("addBook", env -> {
                String id = env.getArgument("id");
                String title = env.getArgument("title");
                String author = env.getArgument("author");
                if (title == null || title.isEmpty()) {
                    throw new IllegalArgumentException("Title cannot be empty");
                }
                return bookService.addBook(new Book(id, title, author));
          }))
          .build();
    }
}

dataFetcher() 作為 GraphQL 查詢或變更操作與我們服務層中實際方法的連接器。例如，當客户端查詢 書籍 時，系統內部會調用 。

同樣，對於 addBook 變更操作，解析器從請求中提取 標題 和 作者 參數，並將其傳遞給 。

7. 添加 GraphQL 路由

有了我們的 schema 和服務邏輯，下一步是使用 Apache Camel 暴露我們的 GraphQL 端點。 為此，我們定義一條 Camel 路由，該路由監聽傳入的 HTTP POST 請求並將它們委託給 GraphQL 引擎進行處理。

我們使用 Jetty 組件配置路由，監聽 HTTP 請求，端口為 8080，具體路徑為 /graphql:

from("jetty:http://localhost:8088/graphql?matchOnUriPrefix=true")
    .log("Received GraphQL request: ${body}")
    .convertBodyTo(String.class)
    .process(exchange -> {
        String body = exchange.getIn().getBody(String.class);
        try {
            Map<String, Object> payload = new ObjectMapper().readValue(body, Map.class);
            String query = (String) payload.get("query");
            if (query == null || query.trim().isEmpty()) {
                throw new IllegalArgumentException("Missing 'query' field in request body");
            }
            ExecutionInput executionInput = ExecutionInput.newExecutionInput()
              .query(query)
              .build();
            ExecutionResult result = graphQL.execute(executionInput);
            Map<String, Object> response = result.toSpecification();
            exchange.getIn().setBody(response);
        } catch (Exception e) {
            throw new RuntimeException("GraphQL processing error", e);
        }
    })
    .marshal().json(JsonLibrary.Jackson)
    .setHeader(Exchange.CONTENT_TYPE, constant("application/json"));

該路由監聽對 /graphql 發送的 HTTP POST 請求。它從傳入的 payload 中提取 query 字段，並將其執行到加載的 GraphQL schema 上。 查詢結果被轉換成標準的 GraphQL 響應格式，然後重新 marshaled 成 JSON。

8. 主應用程序類

現在路由已定義，我們需要一個主類來啓動應用程序。該類負責初始化 Camel 文檔上下文、註冊 Schema 加載器、添加路由以及保持服務器運行狀態。

我們創建一個名為 CamelRestGraphQLApp 的類，其中包含一個主方法，用於執行必要的設置：

public class CamelRestGraphQLApp {
    public static void main(String[] args) throws Exception {
        CamelContext context = new DefaultCamelContext();
        context.addRoutes(new BookRoute());
        context.start();
        logger.info("Server running at http://localhost:8080");
        Thread.sleep(Long.MAX_VALUE);
        context.stop();
    }
}

此類將模式加載器註冊為 Bean，添加路由，並啓動服務器。

調用 Thread.sleep(LONG.MAX_VALUE) 是一個簡單的保持應用程序運行的方法。 在生產級應用程序中，這將被更健壯的機制用於管理應用程序生命週期替換，但出於演示目的，此方法保持服務器運行以處理傳入請求。

9. 測試

我們可以使用 Camel 的 CamelContext 和 ProducerTemplate 來編寫測試，模擬發送 HTTP 請求：

@Test
void whenCallingRestGetAllBooks_thenShouldReturnBookList() {
    String response = template.requestBodyAndHeader(
      "http://localhost:8080/api/books",
      null,
      Exchange.CONTENT_TYPE,
      "application/json",
      String.class
    );

    assertNotNull(response);
    assertTrue(response.contains("Clean Code"));
    assertTrue(response.contains("Effective Java"));
}

@Test
void whenCallingBooksQuery_thenShouldReturnAllBooks() {
    String query = """
    {
        "query": "{ books { id title author } }"
    }""";

    String response = template.requestBodyAndHeader(
      "http://localhost:8080/graphql",
      query,
      Exchange.CONTENT_TYPE,
      "application/json",
      String.class
    );
    assertNotNull(response);
    assertTrue(response.contains("Clean Code"));
    assertTrue(response.contains("Effective Java"));
}

10. 結論

在本文中，我們成功地將 REST 和 GraphQL 端點集成到我們的 Camel 應用程序中，從而通過查詢式和 Mutation 驅動的 API 有效地管理圖書數據。