I lettori come te aiutano a sostenere MUO. Quando effettui un acquisto utilizzando i link sul nostro sito, potremmo guadagnare una commissione di affiliazione.

GraphQL è una specifica basata su HTTP che risolve la maggior parte dei problemi che incontrerai durante la creazione di RESTful API. È adatto per la creazione di API complesse poiché puoi utilizzare un endpoint per accedere ai dati da molti schemi.

GraphQL mitiga problemi come il recupero eccessivo e il recupero insufficiente in REST. Puoi creare un client che richiede campi specifici senza dover effettuare chiamate API aggiuntive.

Esistono diversi pacchetti Go che puoi sfruttare per creare applicazioni basate su GraphQL, dai server alle API.

1. Il pacchetto gqlgen

gqlgen (Generatore GraphQL) è un pacchetto ricco di funzionalità e sicuro per i tipi per la generazione e la creazione di server e API GraphQL.

Il pacchetto gqlgen adotta un approccio schema-first, mediante il quale utilizzi GraphQL SDL per definire il tuo schema. Quindi genera il codice boilerplate che puoi modificare per configurare il tuo server GraphQL e l'API.

instagram viewer

gqlgen è uno dei pacchetti GraphQL più completi in l'ecosistema Go. Puoi generare documentazione ed esempi con il pacchetto e creare query, mutazioni e abbonamenti.

gqlgen garantisce associazioni di tipi, incorporamenti, interfacce, input generati ed enumerazioni. Il pacchetto fornisce inoltre funzionalità per l'analisi aperta, hook per la registrazione degli errori, il caricamento dei dati, la concorrenza e una maggiore complessità delle query.

Dopo aver definito il tuo schema GraphQL, come faresti con qualsiasi libreria schema-first, utilizzerai l'app della riga di comando gqlgen per generare il codice boilerplate dallo schema nel tuo progetto.

Creare un strumenti.go file nella tua directory di lavoro e aggiungi queste righe di codice per includere il file gqlgen pacchetto:

// +crea strumenti
pacchetto utensili
importa _ "github.com/99designs/gqlgen"

IL strumenti.go file specifica gli strumenti di compilazione per il file gqlgen pacchetto.

Esegui questi comandi nella tua directory di lavoro per installare il pacchetto gqlgen e le sue dipendenze:

andare installa github.com/99designs/gqlgen@latest
andare mod ordinato

Puoi inizializzare un nuovo progetto GraphQL quando esegui il pacchetto GraphQL con il file dentro comando come argomento:

andare esegui github.com/99disegni/gqlgen init

Dovrai avere il tuo schema in a schema.graphql file che si trova nella tua directory di lavoro per inizializzare un progetto.

Corri il server.go file per avviare il tuo server GraphQL dopo aver aggiunto funzionalità alla tua app GraphQL:

andare eseguire il server.andare

2. Il pacchetto graphql-go

Il pacchetto graphql-go è una popolare libreria GraphQL che mira a fornire il file completo Bozza di specifica GraphQL per la creazione di servizi GraphQL in Go.

Il pacchetto graphql-go adotta l'approccio dei tipi di runtime; hai la possibilità di dichiarare il tuo schema nel codice Go e il pacchetto controlla in fase di esecuzione.

Puoi implementare query, mutazioni e sottoscrizioni e generare esempi con il pacchetto, ma non è disponibile alcuna funzionalità per enumerazioni generate, input o traccia aperta.

graphql-go presenta un'API minima con supporto sia per i pacchetti integrati che per quelli popolari di terze parti. Ha il supporto per il ApriTelemetria E OpenTracing standard, controllo del tipo di schema rispetto ai resolver, esecuzione parallela dei resolver e molte altre funzionalità.

Se hai familiarità con costruire servizi RESTful in Go with the http pacchetto, troverai il pacchetto graphql-go facile da usare.

Esegui questi comandi nella tua directory di lavoro per aggiungere il pacchetto graphql-go e le sue dipendenze al tuo progetto:

andare scarica github.com/graph-gophers/graphql-andare

Ecco un esempio di avvio di un semplice server GraphQL:

pacchetto principale
importare (
 "tronco d'albero"
 "rete/http"


graphql "github.com/graph-gophers/graphql-andare"
 "github.com/graph-gophers/graphql-andare/relay"
)


tipo domanda struct{}


funz(_ *interrogazione)Ciao()corda { ritorno "Ciao mondo!" }


funzprincipale() {
 schemaEsempio := `
tipo Domanda {
 ciao: stringa!
 }
`
schema := graficoql. MustParseSchema (schemaExample, &query{})
 http. Handle("/query", &relay. Gestore{Schema: schema})
 tronco d'albero. fatale (http. AscoltaEServi(":8080", zero))
}

IL Ciao metodo del domanda struct è un resolver per l'endpoint GraphQL che restituisce hello world. IL schemaEsempio variabile è la definizione dello schema e il server verrà eseguito sulla porta 8080 con l'estensione http Pacchetti Ascolta e servi metodo.

3. Il Pacchetto Tuono

IL Tuono framework adotta l'approccio struct first; dichiari una struttura che modella il tuo schema GraphQL. Genera il Schema GraphQL dai dati Go per gestire il batch di query, le query live, le mutazioni, le sottoscrizioni e la generazione di esempi.

Thunder fornisce la sicurezza dei tipi con associazioni di tipi e altre funzionalità, tra cui la creazione di schemi basati su reflection, esecuzione parallela e batch integrati, un editor GraphiQL integrato e schemi divisi per GraphQL più grandi server.

Non ci sono funzionalità per l'incorporamento, le interfacce, le enumerazioni o gli input generati, la federazione, la traccia aperta o gli errori personalizzati nel pacchetto Thunder. Tuttavia, è uno dei più facili da usare rispetto ad altri pacchetti popolari ed è un eccellente pacchetto di partenza se non hai esperienza con GraphQL.

Dovrai eseguire questo comando nel terminale della tua directory di lavoro per installare il pacchetto Thunder e le sue dipendenze:

andare scarica github.com/samsarahq/thunder/graphql

Dovrai dichiarare un modello struct per lo schema, scrivere i resolver e istanziare il server per avviare un semplice server GraphQL con il pacchetto Thunder.

importare (
 "contesto"
 "rete/http"
 "tempo"
"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"
)


tipo inviare struct {
 Titolo corda
 Corpo corda
 Creato al momento. Tempo
}


// server è il nostro server graphql.
tipo server struct {
 post []post
}


// registerQuery registra il tipo di query radice.
funz(s *server)registerQuery(schema *costruttore di schemi. Schema) {
 obj := schema. Domanda()


ogg. FieldFunc("post", funz() []inviare {
ritorno s.post
 })
}


// registerMutation registra il tipo di mutazione radice.
funz(s *server)registerMutazione(schema *costruttore di schemi. Schema) {
 obj := schema. Mutazione()


ogg. FieldFunc("eco", funz(arg struct{ Messaggio corda })corda {
ritorno arg. Messaggio
 })
}


// registerPost registra il tipo di post.
funz(s *server)registratiPost(schema *costruttore di schemi. Schema) {
 obj := schema. Oggetto("Post", post{})


ogg. FieldFunc("età", funz(ctx contesto. Contesto, p *post)corda {
 reattivo. InvalidateDopo (ctx, 5*tempo. Secondo)
ritorno tempo. Poiché (pag. CreatedAt).String()
 })
}


// schema crea lo schema graphql.
funz(s *server)schema() *graphql.Schema {
 builder := schemabuilder. Nuovo schema()
 s.registerQuery (costruttore)
 s.registerMutation (costruttore)
 s.registerPost (costruttore)
ritorno costruttore. DeveCostruire()
}


funzprincipale() {
// Crea un'istanza di un server, crea un server e serve lo schema sulla porta 3030.
 server := &server{
 post: []post{
 {Title: "first post!", Body: "I was here first!", CreatedAt: time. Ora()},
 {Title: "graphql", Body: "hai sentito parlare di Thunder?", CreatedAt: time. Ora()},
 },
 }


schema := server.schema()
 introspezione. AddIntrospectionToSchema (schema)
// Espone schema e graphiql.
 http. Handle("/graphql", graphql. Gestore (schema))
 http. Handle("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Gestore()))
 http. AscoltaEServi(":3030", zero)
}

IL inviare struct è il modello per lo schema GraphQL e il server struct è l'istanza del server. IL registerQuery, registerMutazione, E registratiPost i metodi sono funzioni di risoluzione per query, mutazioni e memorizzazione dei dati.

IL principale la funzione inizia con il server GraphQL sulla porta 3030 e l'editor GraphQL.

Puoi eseguire query sulle API GraphQL in Go con i pacchetti integrati

GraphQL è basato su HTTP e puoi utilizzare le API GraphQL con il built-in http pacchetto e altri pacchetti simili alle API RESTful. Ci sono anche pacchetti nell'ecosistema di Go che ti permetteranno di consumare rapidamente le API GraphQL.