Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen.
GraphQL is een op HTTP gebaseerde specificatie die de meeste problemen oplost die u tegenkomt tijdens het bouwen van RESTful API's. Het is geschikt voor het bouwen van complexe API's, omdat u één eindpunt kunt gebruiken om toegang te krijgen tot gegevens uit vele schema's.
GraphQL lost problemen op zoals te veel en te weinig ophalen in REST. U kunt een client bouwen die specifieke velden opvraagt zonder dat u extra API-aanroepen hoeft te doen.
Er zijn verschillende Go-pakketten waarvan u kunt profiteren om op GraphQL gebaseerde applicaties te bouwen, van servers tot API's.
1. Het gqlgen-pakket
gqlgen (GraphQL-generator) is een functierijk, typeveilig pakket voor het genereren en bouwen van GraphQL-servers en API's.
Het gqlgen-pakket hanteert een schema-eerst-benadering, waarbij u de GraphQL SDL gebruikt om uw schema te definiëren. Vervolgens wordt de boilerplate-code gegenereerd die u kunt aanpassen om uw GraphQL-server en API in te stellen.
gqlgen is een van de meer complete GraphQL-pakketten in het Go-ecosysteem. U kunt met het pakket documentatie en voorbeelden genereren en queries, mutaties en abonnementen aanmaken.
gqlgen zorgt voor typebindingen, inbeddingen, interfaces, gegenereerde invoer en opsommingen. Het pakket biedt ook functionaliteit voor open tracering, hooks voor foutregistratie, het laden van gegevens, gelijktijdigheid en verhoogde querycomplexiteit.
Nadat u uw GraphQL-schema hebt gedefinieerd, zoals u zou doen met elke schema-eerst-bibliotheek, gebruikt u de opdrachtregel-app gqlgen om de boilerplate-code te genereren op basis van het schema in uw project.
Maak een tools.go bestand in uw werkdirectory en voeg deze regels code toe om de gqlgen pakket:
// +gereedschappen bouwenpakket hulpmiddelen
importeren _ "github.com/99designs/gqlgen"
De tools.go bestand specificeert de build-tools voor het gqlgen pakket.
Voer deze opdrachten uit in uw werkmap om het gqlgen-pakket en zijn afhankelijkheden te installeren:
gaan installeer github.com/99designs/gqlgen@latest
gaan mod netjesU kunt een nieuw GraphQL-project initialiseren wanneer u het GraphQL-pakket uitvoert met de in het opdracht als argument:
gaan voer github.com/ uit99ontwerpen/gqlgen init
U moet uw schema in een schema.graphql bestand in uw werkmap om een project te initialiseren.
Voer de... uit server.go bestand om uw GraphQL-server te starten na het toevoegen van functionaliteit aan uw GraphQL-app:
gaan server draaien.gaan2. Het graphql-go-pakket
Het graphql-go-pakket is een populaire GraphQL-bibliotheek die tot doel heeft het complete te bieden GraphQL-ontwerpspecificatie voor het bouwen van GraphQL-services in Go.
Het pakket graphql-go volgt de aanpak van runtime-types; je hebt de mogelijkheid om je schema in Go-code te declareren en het pakket controleert de runtime.
U kunt query's, mutaties en abonnementen implementeren en voorbeelden genereren met het pakket, maar er is geen functionaliteit voor gegenereerde opsommingen, invoer of open tracering.
graphql-go heeft een minimale API met ondersteuning voor zowel ingebouwde pakketten als populaire pakketten van derden. Het heeft steun voor de Open telemetrie En OpenTracering standaarden, controle van schematypes tegen resolvers, parallelle uitvoering van resolvers en vele andere functies.
Als je bekend bent met RESTful-services bouwen in Go with the http pakket, u zult merken dat het graphql-go-pakket gemakkelijk te gebruiken is.
Voer deze opdrachten uit in uw werkmap om het graphql-go-pakket en zijn afhankelijkheden aan uw project toe te voegen:
gaan ga naar github.com/graph-gophers/graphql-gaan
Hier is een voorbeeld van het starten van een eenvoudige GraphQL-server:
pakket voornaamstimporteren (
"logboek"
"net/http"graphql "github.com/graph-gophers/graphql-gaan"
"github.com/graph-gophers/graphql-gaan/relay"
)type vraag structuur{}
func(_ *vraag)Hallo()snaar { opbrengst "Hallo Wereld!" }
funcvoornaamst() {
schemaVoorbeeld := `
type Vraag {
hallo: String!
}
`
schema := graphql. MustParseSchema (schemaExample, &query{})
http. Handgreep("/query", &relay. Handler{Schema: schema})
loggen. Fataal (http. ListenAndServe(":8080", nihil))
}
De Hallo methode van de vraag struct is een resolver voor het GraphQL-eindpunt dat hallo wereld retourneert. De schemaVoorbeeld variabele is de schemadefinitie en de server draait op poort 8080 met de http pakketjes ListenAndServe methode.
3. Het Thunder-pakket
De Donder framework volgt de struct first-benadering; u declareert een structuur die uw GraphQL-schema modelleert. Het genereert de GraphQL-schema van de Go-gegevens om het batchen van query's, live query's, mutaties, abonnementen en het genereren van voorbeelden af te handelen.
Thunder biedt typeveiligheid met typebindingen en andere functies, waaronder op reflectie gebaseerde schemabouw, ingebouwde parallelle uitvoering en batching, een ingebouwde GraphiQL-editor en gesplitste schema's voor grotere GraphQL servers.
Er is geen functionaliteit voor inbedding, interfaces, gegenereerde opsommingen of invoer, federatie, open tracering of aangepaste fouten in het Thunder-pakket. Het is echter een van de gemakkelijkst te gebruiken vergeleken met andere populaire pakketten en is een uitstekend startpakket als je geen GraphQL-ervaring hebt.
U moet deze opdracht uitvoeren in de terminal van uw werkmap om het Thunder-pakket en zijn afhankelijkheden te installeren:
gaan ga naar github.com/samsarahq/thunder/graphql
U moet een struct-model voor het schema declareren, de resolvers schrijven en de server instantiëren om een eenvoudige GraphQL-server te starten met het Thunder-pakket.
importeren (
"context"
"net/http"
"tijd""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"
)type na structuur {
Titel snaar
Lichaam snaar
Op tijd gemaakt. Tijd
}// server is onze graphql-server.
type server structuur {
posten []posten
}// registerQuery registreert het rootquerytype.
func(s * server)registerQuery(schema *schemabuilder. Schema) {
obj := schema. Vraag()obj. FieldFunc("berichten", func() []na {
opbrengst s.berichten
})
}// registerMutation registreert het type rootmutatie.
func(s * server)registrerenMutatie(schema *schemabuilder. Schema) {
obj := schema. Mutatie()obj. VeldFunc("echo", func(args structuur{ Bericht snaar })snaar {
opbrengst argumenten. Bericht
})
}// registerPost registreert het berichttype.
func(s * server)registrerenPosten(schema *schemabuilder. Schema) {
obj := schema. Object("Berichten", plaatsen{})obj. VeldFunc("leeftijd", func(ctx-context. Context, p *bericht)snaar {
reactief. OngeldigNa (ctx, 5*tijd. Seconde)
opbrengst tijd. Sinds (blz. CreatedAt).String()
})
}// schema bouwt het graphql-schema.
func(s * server)schema() *grafiekql.Schema {
bouwer := schemabouwer. NieuwSchema()
s.registerQuery (bouwer)
s.registerMutation (bouwer)
s.registerPost (bouwer)
opbrengst bouwer. Moet bouwen()
}funcvoornaamst() {
// Creëer een server, bouw een server en lever het schema op poort 3030.
server := &server{
berichten: []bericht{
{Title: "eerste post!", Body: "Ik was hier eerst!", CreatedAt: time. Nu()},
{Title: "graphql", Body: "heb je gehoord van Thunder?", CreatedAt: time. Nu()},
},
}schema := server.schema()
zelfreflectie. AddIntrospectionToSchema (schema)
// Leg schema en graphiql bloot.
http. Handvat("/graphql", graphql. Behandelaar (schema))
http. Handvat("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Beheerder()))
http. ListenAndServe(":3030", nihil)
}
De na struct is het model voor het GraphQL-schema en het server struct is de serverinstantie. De registerQuery, registrerenMutatie, En registrerenPosten methoden zijn resolverfuncties voor query's, mutaties en gegevensopslag.
De voornaamst functie begint met de GraphQL-server op poort 3030 en de GraphQL-editor.
U kunt GraphQL-API's opvragen in Go met ingebouwde pakketten
GraphQL is op HTTP gebaseerd en u kunt GraphQL API's gebruiken met de ingebouwde http pakket en andere pakketten vergelijkbaar met RESTful API's. Er zijn ook pakketten in het ecosysteem van Go waarmee u GraphQL API's snel kunt gebruiken.
