Cómo poner en funcionamiento su servidor GraphQL Java en poco tiempo

GraphQL es un lenguaje de consulta para obtener datos a través de Internet. Desde su anuncio público por Facebook en 2015, ha despertado interés en muchas mentes. GraphQL se ha utilizado principalmente en JavaScript. De hecho, Facebook lanzó la implementación de referencia en JavaScript (graphql-js).

Pero esta publicación de blog se centrará en el desarrollo del servidor GraphQL en Java. GraphQL-Java es la implementación GraphQL correspondiente en Java y recibe actualizaciones y mejoras de versión casi todos los meses. Características como la instrumentación, las llamadas asincrónicas al backend, el cargador de datos, las directivas y muchas más lo convierten en un repositorio muy interesante y poderoso en Java.

Cómo construir un servidor Java GraphQL en springboot

Tomemos el ejemplo de una escuela de magia del universo de Harry Potter . Los datos de la escuela de magia son los siguientes:

Aquí, los DataStores pueden ser servidores backend o incluso bases de datos. Una búsqueda RESTful se verá a continuación.

GET: /student?{parameters}GET: /House?{parameters}

Básicamente exponer una interfaz para un servicio. Por lo tanto, si se agregan profesores en el modelo anterior, entonces se debe abrir un nuevo punto final y el cliente debe realizar varios viajes de ida y vuelta. Además, si el cliente quiere datos anidados como la varita de HarryorigenoEl color de la casa de Ron,luego, el servidor API tiene que llamar al backend dos veces. También resultará en información no deseada de la Casa y la varita.

Ingrese GraphQL : GraphQL es un enfoque basado en esquemas para obtener datos. Modela los datos como gráficos y debe emitir una consulta para obtener los datos. Funciona como SQL, pero para objetos web. Entonces, una consulta graphQL para Harry se ve así:

query{Magic School{Student{namewand{origin}}}}

Antes de entrar en GraphQL, necesitamos configurar un MVC de primavera. La forma más sencilla de hacer esto es SpringBootStarter. Puede seleccionar la herramienta de automatización de compilación que desee. Esto proporciona un paquete de Tomcat integrado en Spring listo para ejecutarse en el puerto 8080. Para probar Tomcat, ejecute:

$gradle clean build$java -jar ./build/libs/graphql-demo-0.0.1-SNAPSHOT.jar

De forma predeterminada, Gradle nombra su JAR "nombre_proyecto-versión-SNAPSHOT.jar". Compruebe http: localhost: 8080para ver Tomcat ejecutándose en el puerto 8080.

Agreguemos ahora una dependencia GraphQL-Java en nuestro build.gradle .

dependencies {compile('com.graphql-java:graphql-java:{version}')compile group: 'org.json', name: 'json', version: '20170516'}

Agregue la versión actual que se encuentra en el repositorio de mavenCentral. Actualmente, la última versión es 8.0. También agregue org.json, que es una biblioteca útil ya que GraphQL maneja la solicitud-respuesta en JSON.

Como mencioné anteriormente, GraphQL es un lenguaje basado en esquemas. Pide a los usuarios que seleccionen objetos en la consulta contra el esquema.

Vamos a sumergirnos en:

Hemos abierto un / graphqlinterfaz para solicitudes POST de GraphQL . Necesitamos crear un esquema para representar datos.

  • SchemaGenerator analiza el esquema y crea un árbol de sintaxis abstracta con nombres de campo como nodos secundarios.
  • Luego, a los campos se les asignan tipos por TypeDefinitionRegistry,por ejemplo, Int, String, etc. GraphQL tiene un buen sistema de tipos en el que podemos tener tipos personalizados en el esquema que incluyen enumeración, interfaces, uniones, listas y más.
  • Eche un vistazo al paso RuntimeWiring () donde el campo "MagicSchool" se asigna a "Hogwarts" mediante un StaticDataFetcher .
  • Cada campo está respaldado por un buscador de datos, y es el trabajo del buscador de datos resolver los datos y regresar a GraphQL.
  • Luego GraphQL lo conecta con los nombres de esquema definidos, ya sea un mapa anidado de listas o un mapa genérico. GraphQL lo hace siempre que defina el esquema adecuado.
  • Después de enviar estos datos a ExecutionInput , el motor GraphQL analiza-> valida-> recupera-> ejecuta la consulta y le devuelve una salida JSON de la respuesta usando .toSpeci fiation ()

Emitamos una consulta usando GraphiQL. Agregue esta extensión a su navegador y configure el punto final.

Observe cómo la forma de su consulta determina la forma de la respuesta. El esquema se puede visualizar claramente debido a la naturaleza introspectiva de GraphQL. Esto habilita la verificación de validación y sintaxis del esquema automáticamente debido al árbol de sintaxis abstracta creado al analizar el esquema.

Agreguemos algunos campos más en el esquema. Construiremos un lenguaje de definición de esquemas. Cree un archivo llamado magicSchool.graphql.

type Query{magicSchool:MagicSchool}type MagicSchool{name: StringHeadMaster:Stringstudent:Student}type Student{name:Stringwand:Wandhouse:House}type House{name:Stringcolor:Stringpoints:Int}type Wand{name:Stringorigin:String}

Modifique la fuente del esquema en el código y verifique el nuevo esquema en GraphiQL

File schemaFile = loadSchema("magicSchool.graphql");TypeDefinitionRegistry typeRegistry=schemaParser.parse(schemaFile);

El runtimeWiring para el esquema y los buscadores cambia significativamente para incluir los otros tipos. Cada tipo tiene su DataFetcher independiente.

Aquí tenemos @Autowired todos los buscadores para obtener los datos. Cada tipo de GraphQL está respaldado por un resolutor de tipos (buscador de datos). Estos resolutores son independientes entre sí y pueden tener diferentes fuentes. Cada DataFetcher aquí tiene un DatafetchingEnvironment, que es una interfaz en la ejecución de la consulta GraphQL. Contiene las consultas argumentos , contexto , executionID , parámetros específicos de campo, y así sucesivamente .

Eche un vistazo a StudentFetcher y la salida de nuestra consulta (ignore las extensiones):

public DataFetcher getData() { return environment -> { Map student = new HashMap(); if ("1".equalsIgnoreCase(environment.getArgument("id"))) { student.put("name", "Harry Potter"); } return student; };}

Te recuerda a SQL, ¿no? Vea también cómo se eliminan la captación insuficiente y excesiva , y el control de los datos está en manos del cliente. ¡Ahora podemos obtener la información de Harry y Ron de manera ordenada y en una llamada al servidor!

Instrumentación y estrategia de ejecución GraphQL

Cada ejecución de consulta es asincrónica en graphql-java. Cuando llama a build.execute (executionInput) , devuelve un objeto CompletableFuture que se completa cuando la consulta completa su flujo de ejecución.

Además, como los campos se resuelven por separado, en el ejemplo anterior, la información de Wand y House se obtiene y ejecuta en paralelo. La ExecutionStrategy predeterminada usa el grupo de unión de bifurcaciones de Java, pero puede agregar su grupo de subprocesos personalizado usando la clase Executor.

ExecutorService executorService = new ThreadPoolExecutor( 128, /* core pool size 128 threads */ 256, /* max pool size 256 threads */ 10, TimeUnit.SECONDS, new LinkedBlockingQueue(), new ThreadPoolExecutor.CallerRunsPolicy()); return GraphQL.newGraphQL() .instrumentation(new TracingInstrumentation ()) .queryExecutionStrategy(new ExecutorServiceExecutionStrategy(executorService)) .build();}

graphql en Java que permite al instrumento de la ejecución de la consulta en cada punto: beforeExecution , beforeParsing , ybeforeFetching . Puede ampliar la clase de Instrumentación y proporcionar su propia acción en cada paso, por ejemplo, registrar las consultas y devolver la hora de cada paso.

La salida de instrumentación proporciona un mapa de extensiones en formato Apollo Tracing de forma predeterminada. Posteriormente, un cliente determinado puede utilizar esto para visualizar los datos de ejecución (por ejemplo, utilizando elastic-search y Grafana). ¡Ahora sabes lo que significan las extensiones en la imagen de arriba!

Se puede acceder al código completo del ejemplo anterior desde aquí.

Terminando

Hay muchas más funciones en graphql-java, como Dataloader (que resuelve el problema de obtención de N + 1), directivas (que facilitan la escritura de esquemas), etc. GraphQL es una tecnología emergente que facilita la vida del cliente y puede cambiar la forma en que hacemos las cosas en Internet. Es por eso que muchas empresas como Facebook, Twitter, GitHub y Coursera ya lo han adoptado.

Me encantaría escuchar sus comentarios sobre GraphQL. Comparta sus puntos de vista. Además, si te gusta la publicación del blog, no olvides aplaudir.