import graphql.language.SourceLocation; //导入依赖的package包/类
private GraphQLError sanitize(GraphQLError error) {
  if (error instanceof ExceptionWhileDataFetching) {
    return new GraphQLError() {
      @Override
      public String getMessage() {
        Throwable cause = ((ExceptionWhileDataFetching) error).getException().getCause();
        return cause instanceof InvocationTargetException ? ((InvocationTargetException) cause).getTargetException().getMessage() : cause.getMessage();
      }

      @Override
      public List<SourceLocation> getLocations() {
        return error.getLocations();
      }

      @Override
      public ErrorType getErrorType() {
        return error.getErrorType();
      }
    };
  }
  return error;
}
 

import graphql.language.SourceLocation; //导入依赖的package包/类
public <T extends ExecutionResult> T execute() {

        assertNotNull(arguments, "Arguments can't be null");
        LOGGER.info("Executing request. Operation name: {}. Request: {} ", operationName, requestQuery);

        Parser parser = new Parser();
        Document document;
        try {
            document = parser.parseDocument(requestQuery);
        } catch (ParseCancellationException e) {
            RecognitionException recognitionException = (RecognitionException) e.getCause();
            SourceLocation sourceLocation = new SourceLocation(recognitionException.getOffendingToken().getLine(), recognitionException.getOffendingToken().getCharPositionInLine());
            InvalidSyntaxError invalidSyntaxError = new InvalidSyntaxError(sourceLocation);
            return (T) new GraphQLRxExecutionResult(Observable.just(null), Observable.just(Arrays.asList(invalidSyntaxError)));
        }

        Validator validator = new Validator();
        List<ValidationError> validationErrors = validator.validateDocument(graphQLSchemaHolder.getGraphQLSchema(), document);
        if (validationErrors.size() > 0) {
            return (T) new GraphQLRxExecutionResult(Observable.just(null), Observable.just(validationErrors));
        }

        if (executionStrategy == null) {
            if (executorService == null) {
                executionStrategy = new GraphQLDefaultRxExecutionStrategy(graphQLSchemaHolder, maxQueryDepth, maxQueryComplexity);
            } else {
                executionStrategy = new GraphQLExecutorServiceRxExecutionStrategy(graphQLSchemaHolder, executorService, maxQueryDepth, maxQueryComplexity);
            }
        }

        RxExecution execution = new RxExecution(graphQLSchemaHolder, maxQueryDepth, maxQueryComplexity, executionStrategy);
        ExecutionResult executionResult = execution.execute(graphQLSchemaHolder.getGraphQLSchema(), context, document, operationName, arguments);

        return (T) (executionResult instanceof GraphQLRxExecutionResult ?
                executionResult : new GraphQLRxExecutionResult(Observable.just(executionResult.getData()), Observable.just(executionResult.getErrors())));
    }
 

import graphql.language.SourceLocation; //导入依赖的package包/类
/**
 * Add the listed errors to the response.
 * 
 * @param errors
 * @param response
 */
private void addErrors(List<GraphQLError> errors, JsonObject response) {
	JsonArray jsonErrors = new JsonArray();
	response.put("errors", jsonErrors);
	for (GraphQLError error : errors) {
		JsonObject jsonError = new JsonObject();
		if (error instanceof ExceptionWhileDataFetching) {
			ExceptionWhileDataFetching dataError = (ExceptionWhileDataFetching) error;
			if (dataError.getException() instanceof PermissionException) {
				PermissionException restException = (PermissionException) dataError.getException();
				// TODO translate error
				// TODO add i18n parameters
				jsonError.put("message", restException.getI18nKey());
				jsonError.put("type", restException.getType());
				jsonError.put("elementId", restException.getElementId());
				jsonError.put("elementType", restException.getElementType());
			} else {
				log.error("Error while fetching data.", dataError.getException());
				jsonError.put("message", dataError.getMessage());
				jsonError.put("type", dataError.getErrorType());
			}
		} else {
			jsonError.put("message", error.getMessage());
			jsonError.put("type", error.getErrorType());
			if (error.getLocations() != null && !error.getLocations().isEmpty()) {
				JsonArray errorLocations = new JsonArray();
				jsonError.put("locations", errorLocations);
				for (SourceLocation location : error.getLocations()) {
					JsonObject errorLocation = new JsonObject();
					errorLocation.put("line", location.getLine());
					errorLocation.put("column", location.getColumn());
					errorLocations.add(errorLocation);
				}
			}
		}
		jsonErrors.add(jsonError);
	}
}
 

import graphql.language.SourceLocation; //导入依赖的package包/类
@Override
public String getMessage() {
  String result = "";
  for (GraphQLError error : errors) {
    result += error.getErrorType() + ": " + error.getMessage() + "\n";
    for (SourceLocation sourceLocation : error.getLocations()) {
      result += "  at line: " + sourceLocation.getLine() + " column: " + sourceLocation.getColumn();
    }
  }
  return result;
}
 

import graphql.language.SourceLocation; //导入依赖的package包/类
@Override
public List<SourceLocation> getLocations() {
    return error.getLocations();
}
 

import graphql.language.SourceLocation; //导入依赖的package包/类
@Override
public List<SourceLocation> getLocations() {
    return null;
}
 

import graphql.language.SourceLocation; //导入依赖的package包/类
GraphQLResult buildErrorResult(final String message) {
    return new GraphQLResult() {
        @Override
        public boolean isSuccessful() {
            return false;
        }

        @SuppressWarnings("unchecked")
        @Override
        public Object getData() {
            return null;
        }

        @Override
        public List<GraphQLError> getErrors() {
            return Collections.singletonList(new GraphQLError() {
                @Override
                public String getMessage() {
                    return message;
                }

                @Override
                public List<SourceLocation> getLocations() {
                    return Collections.emptyList();
                }

                @Override
                public ErrorType getErrorType() {
                    return ErrorType.ValidationError;
                }
            });
        }

        @Override
        public Map<Object, Object> getExtensions() {
            return Collections.emptyMap();
        }

        @Override
        public Map<String, Object> toSpecification() {
            return Collections.emptyMap();
        }

    };
}
 

import graphql.language.SourceLocation; //导入依赖的package包/类
public ValidatedQuery validateQuery(String query) {

        ValidatedQuery result = new ValidatedQuery();
        result.errors = validationErrors;

        Document document;

        try {

            document = parser.parseDocument(query);
            result.parsedQuery = document;

        } catch (Exception e) {
            ValidationError err = new ValidationError(ValidationErrorType.InvalidSyntax, new SourceLocation(0, 0), "Invalid query syntax.");
            validationErrors.add(err);
            result.valid = false;

            return result;
        }

        validationErrors.addAll(validator.validateDocument(schema, document));
        if (validationErrors.size() > 0) {
            result.valid = false;

            return result;

        }

        result.valid = true;

        return result;

    }