Java BatchedExecutionStrategy类代码示例

import graphql.execution.batched.BatchedExecutionStrategy; //导入依赖的package包/类
@JsonProperty
public ExecutionStrategy getExecutionStrategy() {
    switch (executionStrategy) {
    case "batched":
        return new BatchedExecutionStrategy();
    case "async_serial":
        return new AsyncSerialExecutionStrategy();
    case "subscription":
        return new SubscriptionExecutionStrategy();
    case "async":
    default:
        return new AsyncExecutionStrategy();
    }
}
 

import graphql.execution.batched.BatchedExecutionStrategy; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void batchingTest() {
    GraphQLSchema schema = new TestSchemaGenerator()
            .withOperationsFromSingleton(new CandidatesService())
            .generate();

    AtomicBoolean runBatched = new AtomicBoolean(false);
    GraphQL batchExe = GraphQLRuntime.newGraphQL(schema).queryExecutionStrategy(new BatchedExecutionStrategy()).build();
    ExecutionResult result;
    result = batchExe.execute(ExecutionInput.newExecutionInput()
            .query("{candidates {educations {startYear}}}")
            .context(runBatched).build());
    assertTrue("Query didn't run in batched mode", runBatched.get());
    assertTrue(result.getErrors().isEmpty());
    assertEquals(3, ((Map<String, List>) result.getData()).get("candidates").size());

    //TODO put this back when/if the ability to expose nested queries as top-level is reintroduced
    /*runBatched.getAndSet(false);
    GraphQL simpleExe = GraphQLRuntime.newGraphQL(schema).build();
    result = simpleExe.execute("{educations(users: [" +
                "{fullName: \"One\"}," +
                "{fullName: \"Two\"}," +
                "{fullName: \"Three\"}" +
            "]) {startYear}}", runBatched);
    assertTrue(result.getErrors().isEmpty());*/
}
 

import graphql.execution.batched.BatchedExecutionStrategy; //导入依赖的package包/类
@Test
public void testQuery() throws Exception {
    Injector injector = setup();

    // TODO: Support "schema" type so this is generated too :)
    Map<String, GraphQLType> types =
        injector.getInstance(Key.get(new TypeLiteral<Map<String, GraphQLType>>(){}));
    GraphQLSchema schema = GraphQLSchema.newSchema()
        .query((GraphQLObjectType)types.get("QueryPosts"))
        .mutation((GraphQLObjectType)types.get("MutatePosts"))
        .build(new HashSet<>(types.values()));

    GraphQL graphQL = new GraphQL(schema, new BatchedExecutionStrategy());
    ObjectMapper om = new ObjectMapper();
    om.enable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS);

    // Using GraphQL Mutation:
    ExecutionResult result = graphQL.execute(
        "mutation{createPost(post:{title:\"NEW\" authorId:1}){title}}",
        "authorized-user");
    checkExecutionResult(result);
    assertEquals("{\"createPost\":{\"title\":\"NEW\"}}", om.writeValueAsString(result.getData()));

    // ...or the API:
    MutatePosts mutatePosts = injector.getInstance(MutatePosts.class);
    mutatePosts.createPost(new MutatePosts.CreatePostArgs() {
            public InputPost getPost() {
                return new InputPost.Builder()
                    .withTitle("API")
                    .withAuthorId(2)
                    .build();
            }
        });

    // Using GraphQL Query:
    result = graphQL.execute("{posts{title author{firstName lastName}}}");
    checkExecutionResult(result);

    String value = om.writeValueAsString(result.getData());
    assertEquals("{\"posts\":[{\"author\":{\"firstName\":\"Brian\",\"lastName\":\"Maher\"},\"title\":\"GraphQL Rocks\"},{\"author\":{\"firstName\":\"Rahul\",\"lastName\":\"Singh\"},\"title\":\"Announcing Callisto\"},{\"author\":{\"firstName\":\"Rahul\",\"lastName\":\"Singh\"},\"title\":\"Distelli Contributing to Open Source\"},{\"author\":{\"firstName\":\"Brian\",\"lastName\":\"Maher\"},\"title\":\"NEW\"},{\"author\":{\"firstName\":\"Rahul\",\"lastName\":\"Singh\"},\"title\":\"API\"}]}", value);

    // ...or the API:
    QueryPosts queryPosts = injector.getInstance(QueryPosts.class);
    List<Post> posts = queryPosts.getPosts();
    // ...since we are not using GraphQL, the authors will not be resolved:
    assertEquals(posts.get(0).getAuthor().getClass(), Author.Unresolved.class);
    assertArrayEquals(
        new String[]{"GraphQL Rocks", "Announcing Callisto", "Distelli Contributing to Open Source", "NEW", "API"},
        posts.stream().map((post) -> post.getTitle()).toArray(size -> new String[size]));
    assertArrayEquals(
        new Integer[]{1,2,2,1,2},
        posts.stream().map((post) -> post.getAuthor().getId()).toArray(size -> new Integer[size]));
}