import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
public HGQLConfig(String propertyFilepath) {

        ObjectMapper mapper = new ObjectMapper();

        try {
            HGQLConfig config = mapper.readValue(new File(propertyFilepath), HGQLConfig.class);

            SchemaParser schemaParser = new SchemaParser();
            this.registry = schemaParser.parse(new File(config.schemaFile));

            this.name = config.name;
            this.schemaFile = config.schemaFile;
            this.serviceConfigs = config.serviceConfigs;
            this.graphqlConfig = config.graphqlConfig;
            HGQLSchemaWiring wiring = new HGQLSchemaWiring(this.registry,this.name,this.serviceConfigs);
            this.schema = wiring.getSchema();
            this.hgqlSchema = wiring.getHgqlSchema();

        } catch (IOException e) {
            logger.error(e);
        }


    }
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    // Set up dummy data
    categoryJdbcDao = new JdbcDao<>(new CategoryConfiguration(testDatabase.getDatabase()));
    categoryJdbcDao.save(CATEGORY_A);
    categoryJdbcDao.save(CATEGORY_B);

    snippetJdbcDao = new JdbcDao<>(new SnippetConfiguration(testDatabase.getDatabase()));
    snippetJdbcDao.save(SNIPPET_A_ONE);
    snippetJdbcDao.save(SNIPPET_A_TWO);
    snippetJdbcDao.save(SNIPPET_B_THREE);
    snippetJdbcDao.save(SNIPPET_B_FOUR);

    // Setup GraphQL
    SchemaParser schemaParser = new SchemaParser();
    final InputStream inputStream = getClass().getClassLoader().getResourceAsStream("snippets.graphqls");
    final InputStreamReader streamReader = new InputStreamReader(inputStream);
    final TypeDefinitionRegistry registry = schemaParser.parse(streamReader);
    final RuntimeWiring wiring = RuntimeWiringBuilder.getRuntimeWiring(snippetJdbcDao, categoryJdbcDao);
    SchemaGenerator schemaGenerator = new SchemaGenerator();
    GraphQLSchema schema = schemaGenerator.makeExecutableSchema(registry, wiring);
    graphQL = GraphQL.newGraphQL(schema).build();
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
@Test
public void assertScriptFormat() {
    SchemaParser schemaParser = new SchemaParser();
    SchemaGenerator schemaGenerator = new SchemaGenerator();

    TypeDefinitionRegistry typeRegistry = new TypeDefinitionRegistry();
    typeRegistry.merge(schemaParser.parse(loadSchema("common.graphqls")));
    typeRegistry.merge(schemaParser.parse(loadSchema("trace.graphqls")));
    typeRegistry.merge(schemaParser.parse(loadSchema("overview-layer.graphqls")));
    typeRegistry.merge(schemaParser.parse(loadSchema("application-layer.graphqls")));
    typeRegistry.merge(schemaParser.parse(loadSchema("server-layer.graphqls")));
    typeRegistry.merge(schemaParser.parse(loadSchema("service-layer.graphqls")));
    typeRegistry.merge(schemaParser.parse(loadSchema("alarm.graphqls")));
    typeRegistry.merge(schemaParser.parse(loadSchema("config.graphqls")));
    RuntimeWiring wiring = buildRuntimeWiring();
    assertTrue(schemaGenerator.makeExecutableSchema(typeRegistry, wiring).getAllTypesAsList().size() > 0);
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
public GraphQL getGraphQL() {
	SchemaParser schemaParser = new SchemaParser();
	SchemaGenerator schemaGenerator = new SchemaGenerator();
	
	InputStream inputStream = CartSchemaBuilder.class.getResourceAsStream("/graphql/schema/cart.graphqls");
	Reader schemaFile = new InputStreamReader(inputStream);
	TypeDefinitionRegistry typeRegistry = schemaParser.parse(schemaFile);
	RuntimeWiring wiring = buildRuntimeWiring();
	GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeRegistry, wiring);
	
	return GraphQL.newGraphQL(graphQLSchema).build();
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
@Override
public GraphQLSchema fromString(String schemaString, RuntimeWiring runtimeWiring) {
	SchemaParser schemaParser = new SchemaParser();
	TypeDefinitionRegistry typeRegistry = schemaParser.parse(schemaString);
	RuntimeWiring wiring = runtimeWiring;
	SchemaGenerator schemaGenerator = new SchemaGenerator();
	return schemaGenerator.makeExecutableSchema(typeRegistry, wiring);
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
public GraphQLHandler() throws Exception {
    final SchemaParser schemaParser = new SchemaParser();
    final TypeDefinitionRegistry registry;
    try (final InputStream inputStream = getClass().getClassLoader().getResourceAsStream(GRAPHQL_SCHEMA_IDL);
         final InputStreamReader streamReader = new InputStreamReader(inputStream)) {
        registry = schemaParser.parse(streamReader);
    } catch (Exception e) {
        throw new IllegalStateException("Could not parse graphql schema", e);
    }
    final RuntimeWiring wiring = RuntimeWiringFactory.getRuntimeWiring(companies);
    SchemaGenerator schemaGenerator = new SchemaGenerator();
    graphql = GraphQL.newGraphQL(schemaGenerator.makeExecutableSchema(registry, wiring)).build();
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
private GraphQLSchema buildSchema() {
    //
    // reads a file that provides the schema types
    //
    Reader streamReader = loadSchemaFile("stocks.graphqls");
    TypeDefinitionRegistry typeRegistry = new SchemaParser().parse(streamReader);

    RuntimeWiring wiring = RuntimeWiring.newRuntimeWiring()
            .type(newTypeWiring("Subscription")
                    .dataFetcher("stockQuotes", stockQuotesSubscriptionFetcher())
            )
            .build();

    return new SchemaGenerator().makeExecutableSchema(typeRegistry, wiring);
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
@PostConstruct
public void loadSchema() throws IOException{
    Resource schemaResource = new ClassPathResource("/demo-schema.graphqls");
    TypeDefinitionRegistry typeDefinitionRegistry = new SchemaParser().parse(new InputStreamReader(schemaResource.getInputStream()));
    RuntimeWiring runtimeWiring = buildRuntimeWiring();
    GraphQLSchema graphQLSchema = new SchemaGenerator().makeExecutableSchema(typeDefinitionRegistry,runtimeWiring);
    graphQL = GraphQL.newGraphQL(graphQLSchema).build();
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
public GraphQLSchema build() throws SchemaProblem, URISyntaxException {
    final SchemaParser parser = new SchemaParser();
    final TypeDefinitionRegistry registry = parser.parse(getSchemaFile());

    final SchemaGenerator generator = new SchemaGenerator();
    final GraphQLSchema schema = generator.makeExecutableSchema(registry,
            runtimeWiring);
    return schema;
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
@Inject
public GraphQLHandler(Dao<String, Category> categoriesDao,
                      Dao<String, Snippet> snippetDao) {
    final SchemaParser schemaParser = new SchemaParser();
    final TypeDefinitionRegistry registry;
    try (final InputStream inputStream = getClass().getClassLoader().getResourceAsStream(GRAPHQL_SCHEMA_IDL);
         final InputStreamReader streamReader = new InputStreamReader(inputStream)) {
        registry = schemaParser.parse(streamReader);
    } catch (Exception e) {
        throw new IllegalStateException("Could not parse graphql schema", e);
    }
    final RuntimeWiring wiring = RuntimeWiringBuilder.getRuntimeWiring(snippetDao, categoriesDao);
    SchemaGenerator schemaGenerator = new SchemaGenerator();
    graphql = GraphQL.newGraphQL(schemaGenerator.makeExecutableSchema(registry, wiring)).build();
}
 

import graphql.schema.idl.SchemaParser; //导入依赖的package包/类
public RootQuery(DataSetRepository dataSetRepository, SupportedExportFormats supportedFormats, String archetypes,
                 RdfWiringFactory wiringFactory, DerivedSchemaTypeGenerator typeGenerator, ObjectMapper objectMapper)
  throws IOException {
  this.dataSetRepository = dataSetRepository;
  this.supportedFormats = supportedFormats;
  this.archetypes = archetypes;
  this.wiringFactory = wiringFactory;
  this.typeGenerator = typeGenerator;
  this.objectMapper = objectMapper;
  staticQuery = Resources.toString(getResource(RootQuery.class, "schema.graphql"), Charsets.UTF_8);
  schemaParser = new SchemaParser();
}