Cititorii ca tine ajută la sprijinirea MUO. Când efectuați o achiziție folosind link-uri de pe site-ul nostru, este posibil să câștigăm un comision de afiliat.
GraphQL este o specificație bazată pe HTTP care rezolvă majoritatea problemelor pe care le veți întâlni în timpul construirii RESTful API-uri. Este potrivit pentru construirea de API-uri complexe, deoarece puteți utiliza un punct final pentru a accesa date din mai multe scheme.
GraphQL atenuează probleme precum preluarea excesivă și preluarea insuficientă în REST. Puteți crea un client care solicită anumite câmpuri fără a fi nevoie să efectuați apeluri API suplimentare.
Există mai multe pachete Go de care puteți profita pentru a construi aplicații bazate pe GraphQL, de la servere la API-uri.
1. Pachetul gqlgen
gqlgen (generator GraphQL) este un pachet bogat în funcții, sigur de tip pentru generarea și construirea de servere și API-uri GraphQL.
Pachetul gqlgen adoptă o abordare bazată pe schema, prin care utilizați SDL-ul GraphQL pentru a vă defini schema. Apoi generează codul standard pe care îl puteți ajusta pentru a vă configura serverul și API-ul GraphQL.
gqlgen este unul dintre cele mai complete pachete GraphQL din ecosistemul Go. Puteți genera documentație și exemple cu pachetul și puteți crea interogări, mutații și abonamente.
gqlgen asigură legături de tip, încorporare, interfețe, intrări generate și enumerări. Pachetul oferă, de asemenea, funcționalități pentru urmărirea deschisă, cârlige pentru înregistrarea erorilor, încărcarea datelor, concurență și complexitate crescută a interogărilor.
După definirea schemei GraphQL, așa cum ați face cu orice bibliotecă de schemă, veți folosi aplicația de linie de comandă gqlgen pentru a genera codul standard din schema din proiectul dvs.
Creeaza o instrumente.go fișier în directorul dvs. de lucru și adăugați aceste linii de cod pentru a include fișierul gqlgen pachet:
// +construiți instrumentepachet unelte
import _ "github.com/99designs/gqlgen"
The instrumente.go fișierul specifică instrumentele de compilare pentru gqlgen pachet.
Rulați aceste comenzi în directorul dvs. de lucru pentru a instala pachetul gqlgen și dependențele acestuia:
merge instalați github.com/99designs/gqlgen@latest
merge mod ordonatPuteți inițializa un nou proiect GraphQL atunci când rulați pachetul GraphQL cu init comanda ca argument:
merge rulați github.com/99designs/gqlgen init
Va trebui să aveți schema dvs. într-un schema.graphql fișier aflat în directorul de lucru pentru a inițializa un proiect.
Rulați server.go fișier pentru a porni serverul dvs. GraphQL după adăugarea de funcționalități la aplicația GraphQL:
merge rulați serverul.merge2. Pachetul graphql-go
Pachetul graphql-go este o bibliotecă GraphQL populară care își propune să ofere complet Proiectul de specificație GraphQL pentru construirea de servicii GraphQL în Go.
Pachetul graphql-go adoptă abordarea tipurilor de rulare; aveți opțiunea de a vă declara schema în codul Go, iar pachetul verifică timpul de execuție.
Puteți implementa interogări, mutații și abonamente și puteți genera exemple cu pachetul, dar nu există nicio funcționalitate pentru enumerări generate, intrări sau urmărire deschisă.
graphql-go dispune de un API minim cu suport atât pentru pachetele încorporate, cât și pentru cele populare de la terți. Are suport pentru OpenTelemetry și OpenTracing standarde, verificarea tipului de schemă cu soluții, execuția paralelă a rezolutorilor și multe alte caracteristici.
Dacă ești familiarizat cu construirea de servicii RESTful în Go cu http pachet, veți găsi pachetul graphql-go ușor de utilizat.
Rulați aceste comenzi în directorul dvs. de lucru pentru a adăuga pachetul graphql-go și dependențele acestuia la proiect:
merge obțineți github.com/graph-gophers/graphql-merge
Iată un exemplu de pornire a unui server GraphQL simplu:
pachet principalimport (
"Buturuga"
"net/http"graphql "github.com/graph-gophers/graphql-merge"
„github.com/graph-gophers/graphql-merge/relay"
)tip interogare struct{}
func(_ *interogare)Buna ziua()şir { întoarcere "Salut Lume!" }
funcprincipal() {
schemaExemple := `
tip Interogare {
salut: String!
}
`
schema := graphql. MustParseSchema (schemaExample, &query{})
http. Găsiți ("/interogare", &relau. Handler{Schema: schema})
Buturuga. Fatal (http. ListenAndServe(":8080", zero))
}
The Buna ziua metoda de interogare struct este un rezolutor pentru punctul final GraphQL care returnează hello world. The schemaExemplu variabila este definiția schemei, iar serverul va rula pe portul 8080 cu http pachetelor ListenAndServe metodă.
3. Pachetul Thunder
The Tunet framework-ul adoptă prima abordare struct; declarați o structură care vă modelează schema GraphQL. Acesta generează Schema GraphQL din datele Go pentru a gestiona gruparea interogărilor, interogările live, mutațiile, abonamentele și generarea de exemple.
Thunder oferă siguranța tipului cu legături de tip și alte caracteristici, inclusiv construirea schemei bazată pe reflexie, execuție și loturi în paralel încorporate, un editor GraphiQL încorporat și scheme împărțite pentru GraphQL mai mare servere.
Nu există nicio funcționalitate pentru încorporare, interfețe, enumerări sau intrări generate, federație, urmărire deschisă sau erori personalizate în pachetul Thunder. Cu toate acestea, este unul dintre cele mai ușor de utilizat în comparație cu alte pachete populare și este un pachet de pornire excelent dacă nu aveți experiență GraphQL.
Va trebui să rulați această comandă în terminalul directorului dvs. de lucru pentru a instala pachetul Thunder și dependențele acestuia:
merge obțineți github.com/samsarahq/thunder/graphql
Va trebui să declarați un model de structură pentru schemă, să scrieți soluțiile și să instanțiați serverul pentru a porni un server GraphQL simplu cu pachetul Thunder.
import (
"context"
"net/http"
"timp"„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”
)tip post struct {
Titlu şir
Corp şir
CreatedLa timp. Timp
}// serverul este serverul nostru graphql.
tip Server struct {
postări []post
}// registerQuery înregistrează tipul de interogare rădăcină.
func(s *server)registerQuery(schemă *schemabuilder. Schemă) {
obj := schema. Interogare()obj. FieldFunc("postări", func() []post {
întoarcere s.posturi
})
}// registerMutation înregistrează tipul de mutație rădăcină.
func(s *server)registerMutation(schemă *schemabuilder. Schemă) {
obj := schema. Mutaţie()obj. FieldFunc("eco", func(arg struct{ Mesaj şir })şir {
întoarcere argumente. Mesaj
})
}// registerPost înregistrează tipul postării.
func(s *server)registerPost(schemă *schemabuilder. Schemă) {
obj := schema. Obiect(„Postare”, postare{})obj. FieldFunc("varsta", func(context ctx. Context, p *post)şir {
reactiv. InvalidateAfter (ctx, 5*timp. Al doilea)
întoarcere timp. Din moment ce (pag. CreatedAt).String()
})
}// schema construiește schema graphql.
func(s *server)schemă() *graphql.Schemă {
constructor := schemabuilder. NewSchema()
s.registerQuery (generator)
s.registerMutation (constructor)
s.registerPost (constructor)
întoarcere constructor. MustBuild()
}funcprincipal() {
// Instanciați un server, construiți un server și serviți schema pe portul 3030.
server := &server{
postări: []postează{
{Titlu: „primul post!”, Corp: „Am fost aici primul!”, CreatedAt: time. Acum()},
{Title: „graphql”, Body: „ai auzit despre Thunder?”, CreatedAt: time. Acum()},
},
}schema := server.schema()
introspecţie. AddIntrospectionToSchema (schemă)
// Expune schema și graphiql.
http. Mâner ("/graphql", graphql. Handler (schemă))
http. Mâner ("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Handler()))
http. ListenAndServe(":3030", zero)
}
The post struct este modelul pentru schema GraphQL și Server struct este instanța serverului. The registerQuery, registerMutation, și registerPost metodele sunt funcții de rezoluție pentru interogări, mutații și stocare de date.
The principal funcția începe cu serverul GraphQL pe port 3030 și editorul GraphQL.
Puteți interoga API-urile GraphQL în Go, cu pachetele încorporate
GraphQL este bazat pe HTTP și puteți consuma API-uri GraphQL cu ajutorul încorporat http pachet și alte pachete similare cu API-urile RESTful. Există, de asemenea, pachete în ecosistemul Go care vă vor permite să consumați rapid API-urile GraphQL.