import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
/**
 * A GraphQL object ready to execute queries
 *
 * @param graphQLSchema    the schema to use
 * @param queryStrategy    the query execution strategy to use
 * @param mutationStrategy the mutation execution strategy to use
 * @deprecated use the {@link #newAsyncGraphQL(GraphQLSchema)} builder instead.  This will be
 * removed in a future version.
 */
public GraphQL(GraphQLSchema graphQLSchema, ExecutionStrategy queryStrategy,
               ExecutionStrategy mutationStrategy) {
  super(graphQLSchema, queryStrategy, mutationStrategy);
  assert queryStrategy instanceof AsyncExecutionStrategy :
    "Async graphql requires an async query strategy";
  assert mutationStrategy instanceof AsyncExecutionStrategy  :
    "Async graphql requires an async mutation strategy";
  assert ((AsyncExecutionStrategy) mutationStrategy).isSerial() :
    "Async graphql requires a serial mutation strategy";
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
protected ExecutionStrategy createQueryExecutionStrategy() {
    return createExecutionStrategy(
            processorProperties.getMinimumThreadPoolSizeQuery(),
            processorProperties.getMaximumThreadPoolSizeQuery(),
            processorProperties.getKeepAliveTimeInSecondsQuery(),
            "graphql-query-thread-"
    );
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
protected ExecutionStrategy createMutationExecutionStrategy() {
    return createExecutionStrategy(
            processorProperties.getMinimumThreadPoolSizeMutation(),
            processorProperties.getMaximumThreadPoolSizeMutation(),
            processorProperties.getKeepAliveTimeInSecondsMutation(),
            "graphql-mutation-thread-"
    );
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
protected ExecutionStrategy createSubscriptionExecutionStrategy() {
    return createExecutionStrategy(
            processorProperties.getMinimumThreadPoolSizeSubscription(),
            processorProperties.getMaximumThreadPoolSizeSubscription(),
            processorProperties.getKeepAliveTimeInSecondsSubscription(),
            "graphql-subscription-thread-"
    );
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
private ExecutionStrategy createExecutionStrategy(Integer minimumThreadPoolSize, Integer maximumThreadPoolSize, Integer keepAliveTimeInSeconds, String threadNamePrefix) {
    return new ExecutorServiceExecutionStrategy(new ThreadPoolExecutor(
            minimumThreadPoolSize,
            maximumThreadPoolSize,
            keepAliveTimeInSeconds,
            TimeUnit.SECONDS,
            new SynchronousQueue<>(),
            new CustomizableThreadFactory(threadNamePrefix),
            new ThreadPoolExecutor.CallerRunsPolicy())
    );
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的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.ExecutionStrategy; //导入依赖的package包/类
public Builder queryExecutionStrategy(ExecutionStrategy executionStrategy) {
  assertNotNull(executionStrategy, "Query ExecutionStrategy must be non null");
  this.queryExecutionStrategy = executionStrategy;
  return this;
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
public Builder mutationExecutionStrategy(ExecutionStrategy executionStrategy) {
  assertNotNull(executionStrategy, "Mutation ExecutionStrategy must be non null");
  this.mutationExecutionStrategy = executionStrategy;
  return this;
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
public ExecutionStrategy getExecutionStrategy() {
    return delegate.getExecutionStrategy();
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
public void setExecutionStrategy(ExecutionStrategy executionStrategy) {
    delegate.setExecutionStrategy(executionStrategy);
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
private GraphQLQueryExecutor(final GraphQLSchemaHolder graphQLSchemaHolder, final ExecutionStrategy executionStrategy) {
    Assert.notNull(graphQLSchemaHolder, "GraphQL Schema holder can not be null");
    this.graphQLSchemaHolder = graphQLSchemaHolder;
    this.executionStrategy = executionStrategy;
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
public static GraphQLQueryExecutor create(final GraphQLSchemaHolder graphQLSchemaHolder, final ExecutionStrategy executionStrategy) {
    return new GraphQLQueryExecutor(graphQLSchemaHolder, executionStrategy);
}
 

import graphql.execution.ExecutionStrategy; //导入依赖的package包/类
protected ExecutionStrategy getStrategy() {
    return new SimpleTraversalStrategy();
}