Lectores como tú ayudan a apoyar a MUO. Cuando realiza una compra utilizando enlaces en nuestro sitio, podemos ganar una comisión de afiliado.
GraphQL es una especificación basada en HTTP que resuelve la mayoría de los problemas que encontrará al crear RESTful API. Es adecuado para crear API complejas, ya que puede usar un punto final para acceder a datos de muchos esquemas.
GraphQL mitiga problemas como la obtención excesiva y la obtención insuficiente en REST. Puede crear un cliente que solicite campos específicos sin tener que realizar llamadas API adicionales.
Hay varios paquetes de Go que puede aprovechar para crear aplicaciones basadas en GraphQL, desde servidores hasta API.
1. El paquete gqlgen
gqlgen (Generador GraphQL) es un paquete rico en funciones y con seguridad de tipos para generar y construir API y servidores GraphQL.
El paquete gqlgen adopta un enfoque de esquema primero, mediante el cual utiliza GraphQL SDL para definir su esquema. Luego genera el código repetitivo que puede ajustar para configurar su servidor y API GraphQL.
gqlgen es uno de los paquetes GraphQL más completos en el ecosistema Go. Puede generar documentación y ejemplos con el paquete y crear consultas, mutaciones y suscripciones.
gqlgen garantiza enlaces de tipos, incrustaciones, interfaces, entradas generadas y enumeraciones. El paquete también proporciona funcionalidad para seguimiento abierto, enlaces para registro de errores, carga de datos, simultaneidad y mayor complejidad de consultas.
Después de definir su esquema de GraphQL, como lo haría con cualquier biblioteca de esquema primero, utilizará la aplicación de línea de comandos gqlgen para generar el código repetitivo del esquema en su proyecto.
Crear un herramientas.ir archivo en su directorio de trabajo y agregue estas líneas de código para incluir el gqlgen paquete:
// +herramientas de construcciónpaquete herramientas
importar _ "github.com/99designs/gqlgen"
El herramientas.ir El archivo especifica las herramientas de compilación para el gqlgen paquete.
Ejecute estos comandos en su directorio de trabajo para instalar el paquete gqlgen y sus dependencias:
ir instalar github.com/99diseños/gqlgen@latest
ir mod ordenadoPuede inicializar un nuevo proyecto GraphQL cuando ejecuta el paquete GraphQL con el en eso comando como argumento:
ir ejecuta github.com/99diseños/gqlgen init
Deberá tener su esquema en un esquema.graphql archivo ubicado en su directorio de trabajo para inicializar un proyecto.
ejecutar el servidor.ir archivo para iniciar su servidor GraphQL después de agregar funcionalidad a su aplicación GraphQL:
ir ejecutar servidor.ir2. El paquete graphql-go
El paquete graphql-go es una biblioteca GraphQL popular que tiene como objetivo proporcionar la completa Borrador de especificación de GraphQL para crear servicios GraphQL en Go.
El paquete graphql-go adopta el enfoque de tipos de tiempo de ejecución; tiene la opción de declarar su esquema en el código Go, y el paquete verifica el tiempo de ejecución.
Puede implementar consultas, mutaciones y suscripciones y generar ejemplos con el paquete, pero no hay funcionalidad para enumeraciones generadas, entradas o seguimiento abierto.
graphql-go presenta una API mínima con soporte tanto para paquetes integrados como para paquetes populares de terceros. Tiene soporte para el OpenTelemetry y Seguimiento abierto estándares, verificación de tipo de esquema contra resolutores, ejecución paralela de resolutores y muchas otras características.
Si estás familiarizado con construir servicios RESTful en Go with the http paquete, encontrará que el paquete graphql-go es fácil de usar.
Ejecute estos comandos en su directorio de trabajo para agregar el paquete graphql-go y sus dependencias a su proyecto:
ir obtener github.com/graph-gophers/graphql-ir
Aquí hay un ejemplo de cómo iniciar un servidor GraphQL simple:
paquete principalimportar (
"registro"
"red/http"graphql "github.com/graph-gophers/graphql-ir"
"github.com/graph-gophers/graphql-ir/relay"
)tipo consulta estructura{}
función(_ *consulta)Hola()cadena { devolver "¡Hola Mundo!" }
funciónprincipal() {
esquemaEjemplo := `
tipo Consulta {
hola: cadena!
}
`
esquema := graphql. MustParseSchema (esquemaEjemplo, &consulta{})
http. Manejar("/consulta", &retransmisión. Manejador{Esquema: esquema})
registro. fatal (http. Escuchar y servir (":8080", nulo))
}
El Hola metodo de la consulta struct es un solucionador para el punto final de GraphQL que devuelve hola mundo. El esquemaEjemplo variable es la definición del esquema, y el servidor se ejecutará en el puerto 8080 con la http paquete escucharyservir método.
3. El paquete del trueno
El Trueno framework toma el primer enfoque de estructura; declaras una estructura que modela tu esquema GraphQL. Genera el esquema GraphQL de los datos de Go para manejar el procesamiento por lotes de consultas, consultas en vivo, mutaciones, suscripciones y generación de ejemplos.
Thunder proporciona seguridad de tipos con enlaces de tipos y otras funciones, incluida la creación de esquemas basados en reflejos, procesamiento por lotes y ejecución en paralelo incorporados, un editor GraphiQL incorporado y esquemas divididos para GraphQL más grande servidores.
No hay funcionalidad para incrustar, interfaces, enumeraciones o entradas generadas, federación, seguimiento abierto o errores personalizados en el paquete Thunder. Sin embargo, es uno de los más fáciles de usar en comparación con otros paquetes populares y es un excelente paquete inicial si no tiene experiencia con GraphQL.
Deberá ejecutar este comando en la terminal de su directorio de trabajo para instalar el paquete Thunder y sus dependencias:
ir obtener github.com/samsarahq/thunder/graphql
Deberá declarar un modelo de estructura para el esquema, escribir los resolutores e instanciar el servidor para iniciar un servidor GraphQL simple con el paquete Thunder.
importar (
"contexto"
"red/http"
"tiempo""github.com/samsarahq/thunder/graphql"
"github.com/samsarahq/thunder/graphql/graphiql"
"github.com/samsarahq/thunder/graphql/introspección"
"github.com/samsarahq/thunder/graphql/schemabuilder"
"github.com/samsarahq/trueno/reactivo"
)tipo correo estructura {
Título cadena
Cuerpo cadena
Creado a la hora. Tiempo
}// el servidor es nuestro servidor graphql.
tipo servidor estructura {
publicaciones [] publicación
}// registerQuery registra el tipo de consulta raíz.
función(s *servidor)registroConsulta(esquema *constructor de esquemas. Esquema) {
obj := esquema. Consulta()objeto FieldFunc("publicaciones", función() []correo {
devolver s.posts
})
}// registerMutation registra el tipo de mutación raíz.
función(s *servidor)registrarseMutación(esquema *constructor de esquemas. Esquema) {
obj := esquema. Mutación()objeto FieldFunc("eco", función(argumentos estructura{ Mensaje cadena })cadena {
devolver argumentos Mensaje
})
}// registerPost registra el tipo de publicación.
función(s *servidor)registrarsePublicar(esquema *constructor de esquemas. Esquema) {
obj := esquema. Objeto("Publicar", publicar{})objeto FieldFunc("edad", función(contexto ctx. Contexto, p * publicación)cadena {
reactivo. InvalidarDespués (ctx, 5*tiempo. Segundo)
devolver tiempo. Desde (pág. Creado en).String()
})
}// esquema construye el esquema de graphql.
función(s *servidor)esquema() *gráficoql.Esquema {
constructor := constructor de esquemas. NuevoEsquema()
s.registerQuery (constructor)
s.registerMutation (constructor)
s.registerPost (constructor)
devolver constructor. debe construir ()
}funciónprincipal() {
// Cree una instancia de un servidor, construya un servidor y sirva el esquema en el puerto 3030.
servidor := &servidor{
publicaciones: []publicación{
{Título: "¡primera publicación!", Cuerpo: "¡Estuve aquí primero!", Creado a las: hora. Ahora()},
{Título: "graphql", Cuerpo: "¿Escuchaste sobre Thunder?", Creado a las: hora. Ahora()},
},
}esquema := servidor.esquema()
introspección. AddIntrospectionToSchema (esquema)
// Exponer esquema y graphiql.
http. Manejar("/graphql", graphql. Controlador (esquema))
http. Manejar("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Manipulador()))
http. Escuchar y servir (":3030", nulo)
}
El correo struct es el modelo para el esquema GraphQL, y el servidor struct es la instancia del servidor. El registroConsulta, registrarseMutación, y registrarsePublicar Los métodos son funciones de resolución para consultas, mutaciones y almacenamiento de datos.
El principal la función comienza con el servidor GraphQL en el puerto 3030 y el editor GraphQL.
Puede consultar las API de GraphQL en Go con paquetes integrados
GraphQL está basado en HTTP y puede consumir las API de GraphQL con el http paquete y otros paquetes similares a las API RESTful. También hay paquetes en el ecosistema de Go que le permitirán consumir las API de GraphQL rápidamente.
