Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation.
GraphQL est une spécification basée sur HTTP qui résout la plupart des problèmes que vous rencontrerez lors de la construction de RESTful Apis. Il convient à la création d'API complexes, car vous pouvez utiliser un point de terminaison pour accéder aux données de nombreux schémas.
GraphQL atténue les problèmes tels que la sur-extraction et la sous-extraction dans REST. Vous pouvez créer un client qui demande des champs spécifiques sans avoir à effectuer d'appels d'API supplémentaires.
Il existe plusieurs packages Go dont vous pouvez tirer parti pour créer des applications basées sur GraphQL, des serveurs aux API.
1. Le forfait gqlgen
gqlgen (générateur GraphQL) est un package riche en fonctionnalités et de type sécurisé pour générer et créer des serveurs et des API GraphQL.
Le package gqlgen adopte une approche axée sur le schéma, par laquelle vous utilisez le SDL GraphQL pour définir votre schéma. Il génère ensuite le code passe-partout que vous pouvez ajuster pour configurer votre serveur et votre API GraphQL.
gqlgen est l'un des packages GraphQL les plus complets de l'écosystème Go. Vous pouvez générer de la documentation et des exemples avec le package et créer des requêtes, des mutations et des abonnements.
gqlgen assure les liaisons de type, les incorporations, les interfaces, les entrées générées et les énumérations. Le package fournit également des fonctionnalités pour le traçage ouvert, des crochets pour la journalisation des erreurs, le chargement des données, la simultanéité et une complexité accrue des requêtes.
Après avoir défini votre schéma GraphQL, comme vous le feriez avec n'importe quelle bibliothèque de schéma en premier, vous utiliserez l'application de ligne de commande gqlgen pour générer le code passe-partout à partir du schéma de votre projet.
Créer un outils.go fichier dans votre répertoire de travail et ajoutez ces lignes de code pour inclure le gqlgen emballer:
// + construire des outilsemballer outils
importer _ "github.com/99designs/gqlgen"
Le outils.go fichier spécifie les outils de construction pour le gqlgen emballer.
Exécutez ces commandes dans votre répertoire de travail pour installer le package gqlgen et ses dépendances :
aller installez github.com/99dessins/gqlgen@latest
aller bien rangéVous pouvez initialiser un nouveau projet GraphQL lorsque vous exécutez le package GraphQL avec le initialiser commande en argument :
aller lancer github.com/99conceptions/initialisation gqlgen
Vous aurez besoin d'avoir votre schéma dans un schéma.graphql fichier situé dans votre répertoire de travail pour initialiser un projet.
Exécutez le serveur.go fichier pour démarrer votre serveur GraphQL après avoir ajouté des fonctionnalités à votre application GraphQL :
aller exécuter le serveur.aller2. Le paquet graphql-go
Le paquet graphql-go est une bibliothèque GraphQL populaire qui vise à fournir le Spécification provisoire de GraphQL pour créer des services GraphQL dans Go.
Le package graphql-go adopte l'approche des types d'exécution; vous avez la possibilité de déclarer votre schéma dans le code Go et le package vérifie lors de l'exécution.
Vous pouvez implémenter des requêtes, des mutations et des abonnements et générer des exemples avec le package, mais il n'y a pas de fonctionnalité pour les énumérations, les entrées ou le traçage ouvert générés.
graphql-go propose une API minimale prenant en charge à la fois les packages intégrés et les packages tiers populaires. Il a un support pour le OpenTelemetry et OpenTracing normes, vérification du type de schéma par rapport aux résolveurs, exécution parallèle des résolveurs et de nombreuses autres fonctionnalités.
Si vous êtes familier avec création de services RESTful dans Go avec le http emballer, vous trouverez le package graphql-go facile à utiliser.
Exécutez ces commandes dans votre répertoire de travail pour ajouter le package graphql-go et ses dépendances à votre projet :
aller obtenir github.com/graph-gophers/graphql-aller
Voici un exemple de démarrage d'un serveur GraphQL simple :
emballer principalimporter (
"enregistrer"
"net/http"graphql "github.com/graph-gophers/graphql-aller"
"github.com/graph-gophers/graphql-aller/relay"
)taper mettre en doute structure{}
fonction(_ *mettre en doute)Bonjour()chaîne { retour "Bonjour le monde!" }
fonctionprincipal() {
schémaExemple := `
taper Mettre en doute {
bonjour: Corde !
}
`
schéma := graphql. MustParseSchema (schemaExample, &query{})
http. Poignée("/requête", &relais. Gestionnaire{Schéma: schéma})
enregistrer. Fatal (http. EcouteEtServe(":8080", néant))
}
Le Bonjour méthode de la mettre en doute struct est un résolveur pour le point de terminaison GraphQL qui renvoie hello world. Le schémaExemple variable est la définition du schéma, et le serveur s'exécutera sur le port 8080 avec la http paquets ÉcouterEtServir méthode.
3. Le forfait tonnerre
Le Tonnerre framework adopte l'approche de la structure d'abord; vous déclarez une structure qui modélise votre schéma GraphQL. Il génère la Schéma GraphQL à partir des données Go pour gérer le traitement par lots des requêtes, les requêtes en direct, les mutations, les abonnements et la génération d'exemples.
Thunder fournit une sécurité de type avec des liaisons de type et d'autres fonctionnalités, y compris la construction de schéma basée sur la réflexion, exécution parallèle et traitement par lots intégrés, un éditeur GraphiQL intégré et des schémas fractionnés pour un GraphQL plus grand les serveurs.
Il n'y a pas de fonctionnalité pour l'intégration, les interfaces, les énumérations ou les entrées générées, la fédération, le traçage ouvert ou les erreurs personnalisées dans le package Thunder. Cependant, il est l'un des plus faciles à utiliser par rapport aux autres packages populaires et constitue un excellent package de départ si vous n'avez aucune expérience de GraphQL.
Vous devrez exécuter cette commande dans le terminal de votre répertoire de travail pour installer le package Thunder et ses dépendances :
aller obtenir github.com/samsarahq/thunder/graphql
Vous devrez déclarer un modèle de structure pour le schéma, écrire les résolveurs et instancier le serveur pour démarrer un serveur GraphQL simple avec le package Thunder.
importer (
"contexte"
"net/http"
"temps""github.com/samsarahq/thunder/graphql"
"github.com/samsarahq/thunder/graphql/graphiql"
"github.com/samsarahq/thunder/graphql/introspection"
"github.com/samsarahq/thunder/graphql/schemabuilder"
"github.com/samsarahq/thunder/reactive"
)taper poste structure {
Titre chaîne
Corps chaîne
Créé à l'heure. Temps
}// serveur est notre serveur graphql.
taper serveur structure {
messages [] message
}// registerQuery enregistre le type de requête racine.
fonction(s *serveur)registreRequête(schéma *schemabuilder. Schéma) {
obj := schéma. Mettre en doute()obj. FieldFunc("messages", fonction() []poste {
retour s.posts
})
}// registerMutation enregistre le type de mutation racine.
fonction(s *serveur)enregistrerMutation(schéma *schemabuilder. Schéma) {
obj := schéma. Mutation()obj. FieldFunc("echo", fonction(arguments structure{ Message chaîne })chaîne {
retour arguments. Message
})
}// registerPost enregistre le type de publication.
fonction(s *serveur)s'inscrirePoster(schéma *schemabuilder. Schéma) {
obj := schéma. Objet("Publication", publication{})obj. FieldFunc("âge", fonction(contexte ctx. Contexte, p *post)chaîne {
réactif. InvalidateAfter (ctx, 5*temps. Deuxième)
retour temps. Depuis (p. Créé à).String()
})
}// schema construit le schéma graphql.
fonction(s *serveur)schéma() *graphql.Schéma {
constructeur := constructeur de schéma. NouveauSchéma()
s.registerQuery (constructeur)
s.registerMutation (constructeur)
s.registerPost (constructeur)
retour constructeur. DoitConstruire()
}fonctionprincipal() {
// Instancie un serveur, crée un serveur et sert le schéma sur le port 3030.
serveur := &serveur{
publications: []post{
{Titre: "premier message !", Corps: "J'étais ici en premier !", CreatedAt: heure. Maintenant()},
{Title: "graphql", Body: "avez-vous entendu parler de Thunder ?", CreatedAt: time. Maintenant()},
},
}schema := serveur.schema()
introspection. AddIntrospectionToSchema (schéma)
// Expose schema et graphiql.
http. Poignée("/graphql", graphql. Gestionnaire (schéma))
http. Poignée("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Gestionnaire()))
http. EcouteEtServe(":3030", néant)
}
Le poste struct est le modèle du schéma GraphQL, et le serveur struct est l'instance du serveur. Le registreRequête, enregistrerMutation, et s'inscrirePoster Les méthodes sont des fonctions de résolution pour les requêtes, les mutations et le stockage des données.
Le principal la fonction démarre avec le serveur GraphQL sur le port 3030 et l'éditeur GraphQL.
Vous pouvez interroger les API GraphQL dans Go With Built-In Packages
GraphQL est basé sur HTTP et vous pouvez utiliser les API GraphQL avec le http package et d'autres packages similaires aux API RESTful. Il existe également des packages dans l'écosystème de Go qui vous permettront de consommer rapidement les API GraphQL.
