Leser wie Sie helfen, MUO zu unterstützen. Wenn Sie über Links auf unserer Website einen Kauf tätigen, erhalten wir möglicherweise eine Affiliate-Provision.

GraphQL ist eine HTTP-basierte Spezifikation, die die meisten Probleme löst, auf die Sie beim Erstellen von RESTful stoßen werden APIs. Es eignet sich zum Erstellen komplexer APIs, da Sie einen Endpunkt verwenden können, um auf Daten aus vielen Schemas zuzugreifen.

GraphQL mindert Probleme wie Overfetching und Underfetching in REST. Sie können einen Client erstellen, der bestimmte Felder anfordert, ohne zusätzliche API-Aufrufe durchführen zu müssen.

Es gibt mehrere Go-Pakete, die Sie nutzen können, um GraphQL-basierte Anwendungen zu erstellen, von Servern bis hin zu APIs.

1. Das gqlgen-Paket

gqlgen (GraphQL-Generator) ist ein funktionsreiches, typsicheres Paket zum Generieren und Erstellen von GraphQL-Servern und APIs.

Das gqlgen-Paket verfolgt einen Schema-First-Ansatz, bei dem Sie das GraphQL-SDL verwenden, um Ihr Schema zu definieren. Anschließend generiert es den Boilerplate-Code, den Sie anpassen können, um Ihren GraphQL-Server und Ihre API einzurichten.

instagram viewer

gqlgen ist eines der vollständigeren GraphQL-Pakete in das Go-Ökosystem. Sie können mit dem Paket Dokumentationen und Beispiele generieren und Abfragen, Mutationen und Abonnements erstellen.

gqlgen stellt Typbindungen, Einbettungen, Schnittstellen, generierte Eingaben und Aufzählungen sicher. Das Paket bietet auch Funktionen für die offene Ablaufverfolgung, Hooks für die Fehlerprotokollierung, das Laden von Daten, Parallelität und erhöhte Abfragekomplexität.

Nachdem Sie Ihr GraphQL-Schema – wie bei jeder Schema-First-Bibliothek – definiert haben, verwenden Sie die gqlgen-Befehlszeilen-App, um den Boilerplate-Code aus dem Schema in Ihrem Projekt zu generieren.

Ein... kreieren werkzeuge.go Datei in Ihrem Arbeitsverzeichnis und fügen Sie diese Codezeilen hinzu, um die gqlgen Paket:

// +Build-Tools
Paket Werkzeug
importieren _ "github.com/99designs/gqlgen"

Der werkzeuge.go Datei gibt die Build-Tools für die gqlgen Paket.

Führen Sie diese Befehle in Ihrem Arbeitsverzeichnis aus, um das gqlgen-Paket und seine Abhängigkeiten zu installieren:

gehen installiere github.com/99designs/gqlgen@latest
gehen Mod aufgeräumt

Sie können ein neues GraphQL-Projekt initialisieren, wenn Sie das GraphQL-Paket mit dem ausführen drin Befehl als Argument:

gehen Führen Sie github.com/ aus99designs/gqlgen init

Sie müssen Ihr Schema in a haben schema.graphql Datei, die sich in Ihrem Arbeitsverzeichnis befindet, um ein Projekt zu initialisieren.

Führen Sie die aus server.go Datei zum Starten Ihres GraphQL-Servers nach dem Hinzufügen von Funktionen zu Ihrer GraphQL-App:

gehen Server ausführen.gehen

2. Das graphql-go-Paket

Das graphql-go-Paket ist eine beliebte GraphQL-Bibliothek, die darauf abzielt, das Ganze bereitzustellen Entwurf der GraphQL-Spezifikation zum Erstellen von GraphQL-Diensten in Go.

Das Paket graphql-go verfolgt den Ansatz der Laufzeittypen; Sie haben die Möglichkeit, Ihr Schema im Go-Code zu deklarieren, und das Paket prüft zur Laufzeit.

Sie können mit dem Paket Abfragen, Mutationen und Abonnements implementieren und Beispiele generieren, aber es gibt keine Funktionalität für generierte Aufzählungen, Eingaben oder offene Ablaufverfolgung.

graphql-go verfügt über eine minimale API mit Unterstützung für sowohl integrierte Pakete als auch beliebte Pakete von Drittanbietern. Es hat Unterstützung für die OpenTelemetry Und OpenTracing Standards, Überprüfung des Schematyps anhand von Resolvern, parallele Ausführung von Resolvern und viele andere Funktionen.

Wenn Sie sich auskennen Erstellen von RESTful-Diensten in Go with the http Paket, Sie werden feststellen, dass das graphql-go-Paket einfach zu verwenden ist.

Führen Sie diese Befehle in Ihrem Arbeitsverzeichnis aus, um das Paket graphql-go und seine Abhängigkeiten zu Ihrem Projekt hinzuzufügen:

gehen Holen Sie sich github.com/graph-gophers/graphql-gehen

Hier ist ein Beispiel für das Starten eines einfachen GraphQL-Servers:

Paket hauptsächlich
importieren (
 "Protokoll"
 "net/http"


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


Typ Anfrage Struktur{}


Funk(_ *Anfrage)Hallo()Schnur { zurückkehren "Hallo Welt!" }


Funkhauptsächlich() {
 SchemaBeispiel := `
Typ Anfrage {
 Hallo: Saite!
 }
`
schema := graphql. MustParseSchema (SchemaExample, &query{})
 http. Handle("/query", &relais. Handler{Schema: schema})
 Protokoll. Tödlich (http. ListenAndServe(":8080", Null))
}

Der Hallo Methode der Anfrage struct ist ein Resolver für den GraphQL-Endpunkt, der hallo Welt zurückgibt. Der schemaExample Variable ist die Schemadefinition, und der Server wird auf Port 8080 mit der ausgeführt http Pakete ListenAndServe Methode.

3. Das Donnerpaket

Der Donner Framework verfolgt den Struct-First-Ansatz; Sie deklarieren eine Struktur, die Ihr GraphQL-Schema modelliert. Es generiert die GraphQL-Schema aus den Go-Daten, um Abfrage-Batching, Live-Abfragen, Mutationen, Abonnements und Beispielgenerierung zu handhaben.

Thunder bietet Typsicherheit mit Typbindungen und anderen Funktionen, einschließlich reflektionsbasierter Schemaerstellung, integrierte parallele Ausführung und Stapelverarbeitung, ein integrierter GraphiQL-Editor und geteilte Schemas für größeres GraphQL Server.

Es gibt keine Funktionen für Einbettung, Schnittstellen, generierte Aufzählungen oder Eingaben, Föderation, offene Ablaufverfolgung oder benutzerdefinierte Fehler im Thunder-Paket. Es ist jedoch eines der am einfachsten zu verwendenden im Vergleich zu anderen gängigen Paketen und ein hervorragendes Startpaket, wenn Sie keine GraphQL-Erfahrung haben.

Sie müssen diesen Befehl im Terminal Ihres Arbeitsverzeichnisses ausführen, um das Thunder-Paket und seine Abhängigkeiten zu installieren:

gehen Holen Sie sich github.com/samsarahq/thunder/graphql

Sie müssen ein Strukturmodell für das Schema deklarieren, die Resolver schreiben und den Server instanziieren, um einen einfachen GraphQL-Server mit dem Thunder-Paket zu starten.

importieren (
 "Kontext"
 "net/http"
 "Zeit"
"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"
)


Typ Post Struktur {
 Titel Schnur
 Körper Schnur
 ErstelltZur Zeit. Zeit
}


// Server ist unser Graphql-Server.
Typ Server Struktur {
 posten [] posten
}


// registerQuery registriert den Root-Abfragetyp.
Funk(s *Server)registerAbfrage(Schema *schemabuilder. Schema) {
 obj := Schema. Anfrage()


obj. FieldFunc("Beiträge", Funk() []Post {
zurückkehren an Beiträgen
 })
}


// registerMutation registriert den Root-Mutationstyp.
Funk(s *Server)registrierenMutation(Schema *schemabuilder. Schema) {
 obj := Schema. Mutation()


obj. FieldFunc("Echo", Funk(arg Struktur{ Nachricht Schnur })Schnur {
zurückkehren Argumente. Nachricht
 })
}


// registerPost registriert den Beitragstyp.
Funk(s *Server)registrierenPost(Schema *schemabuilder. Schema) {
 obj := Schema. Objekt("Beitrag", Beitrag{})


obj. FieldFunc("Alter", Funk(ctx-Kontext. Kontext, p *post)Schnur {
 reaktiv. InvalidateAfter (ctx, 5*Zeit. Zweite)
zurückkehren Zeit. Seit (S. Erstelltbei).String()
 })
}


// schema erstellt das graphql-Schema.
Funk(s *Server)Schema() *graphql.Schema {
 Builder := Schemabuilder. NeuesSchema()
 s.registerQuery (Builder)
 s.registerMutation (Builder)
 s.registerPost (Ersteller)
zurückkehren Baumeister. MustBuild()
}


Funkhauptsächlich() {
// Instanziiere einen Server, erstelle einen Server und stelle das Schema auf Port 3030 bereit.
 server := &server{
 Beiträge: []posten{
 {Title: "first post!", Body: "I was here first!", CreatedAt: time. Jetzt()},
 {Titel: "graphql", Text: "Haben Sie von Thunder gehört?", Erstellt um: Zeit. Jetzt()},
 },
 }


schema := server.schema()
 Selbstbeobachtung. AddIntrospectionToSchema (Schema)
// Schema und Grafik verfügbar machen.
 http. Handle("/graphql", graphql. Handler (Schema))
 http. Handle("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Handler()))
 http. ListenAndServe(":3030", Null)
}

Der Post struct ist das Modell für das GraphQL-Schema und die Server struct ist die Serverinstanz. Der registerAbfrage, registrierenMutation, Und registrierenPost Methoden sind Resolver-Funktionen für Abfragen, Mutationen und Datenspeicherung.

Der hauptsächlich Die Funktion startet mit dem GraphQL-Server am Port 3030 und der GraphQL-Editor.

Sie können GraphQL-APIs in Go mit integrierten Paketen abfragen

GraphQL ist HTTP-basiert, und Sie können GraphQL-APIs mit der integrierten verwenden http -Paket und andere Pakete, die RESTful-APIs ähneln. Es gibt auch Pakete im Ökosystem von Go, mit denen Sie GraphQL-APIs schnell nutzen können.