GraphQL API mit Go: Schritt-für-Schritt-Tutorial in der Praxis

Einleitung

GraphQL ist eine moderne Abfragesprache für APIs, entwickelt von Facebook. Im Gegensatz zu REST ermöglicht es dem Client, nur die benötigten Daten anzufordern, was die Netzwerklast reduziert und die Entwicklung beschleunigt. In diesem Tutorial erstellen wir eine vollständige GraphQL-API in der Sprache Go (Golang) unter Verwendung der beliebten Bibliothek gqlgen. Sie erfahren, wie Sie einen Server einrichten, ein Schema definieren, Resolver schreiben und Abfragen ausführen. Der Artikel richtet sich an Entwickler, die mit den Grundlagen von Go vertraut sind, aber auch Anfänger können die Schritte dank detaillierter Kommentare nachvollziehen.

1. Projekteinrichtung und Installation von Abhängigkeiten

Als erstes erstellen wir ein neues Go-Projekt und installieren die erforderlichen Pakete.

Schritt 1: Modul initialisieren

mkdir graphql-go-tutorialcd graphql-go-tutorialgo mod init graphql-go-tutorial

Schritt 2: gqlgen installieren

gqlgen ist ein GraphQL-Codegenerator für Go. Er erstellt automatisch Resolver basierend auf dem Schema.

go get github.com/99designs/gqlgen@latest

Schritt 3: Projektskelett generieren

Führen Sie den Initialisierungsbefehl aus:

go run github.com/99designs/gqlgen init

Nach der Ausführung sehen Sie folgende Struktur:

• graph/ — Ordner mit Schema und Resolvern
• server.go — Einstiegspunkt
• gqlgen.yml — Konfiguration des Generators

2. Definition des GraphQL-Schemas

Das Schema beschreibt die Datentypen und Operationen der API. Öffnen Sie die Datei graph/schema.graphqls und ersetzen Sie deren Inhalt durch Folgendes:

type User {  id: ID!  name: String!  email: String!  age: Int!}

type Query {  users: [User!]!  user(id: ID!): User}

type Mutation {  createUser(name: String!, email: String!, age: Int!): User!  updateUser(id: ID!, name: String, email: String, age: Int): User  deleteUser(id: ID!): Boolean}

Hier haben wir definiert:

• User — ein Objekt mit den Feldern id, name, email, age.
• Query — Leseoperationen (alle Benutzer oder einen nach ID abrufen).
• Mutation — Schreiboperationen (erstellen, aktualisieren, löschen).

Nach dem Speichern starten Sie die Codegenerierung:

go run github.com/99designs/gqlgen generate

Dies erstellt die Dateien models_gen.go (Go-Typen) und generated.go (Resolver-Schnittstellen).

3. Implementierung von Resolvern und Datenspeicher

Jetzt müssen wir die Logik zur Verarbeitung von Anfragen schreiben. Der Einfachheit halber speichern wir die Daten im Arbeitsspeicher (Slice von Strukturen).

Schritt 1: Speicher erstellen

Erstellen Sie die Datei graph/store.go:

package graph

import "sync"

type Store struct {  mu    sync.RWMutex  users []User  nextID int}

func NewStore() *Store {  return &Store{    users: []User{      {ID: "1", Name: "Alice", Email: "alice@example.com", Age: 30},      {ID: "2", Name: "Bob", Email: "bob@example.com", Age: 25},    },    nextID: 3,  }}

func (s *Store) GetUsers() []User {  s.mu.RLock()  defer s.mu.RUnlock()  return s.users}

func (s *Store) GetUser(id string) *User {  s.mu.RLock()  defer s.mu.RUnlock()  for _, u := range s.users {    if u.ID == id {      return &u    }  }  return nil}

func (s *Store) CreateUser(name, email string, age int) User {  s.mu.Lock()  defer s.mu.Unlock()  user := User{    ID:    fmt.Sprintf("%d", s.nextID),    Name:  name,    Email: email,    Age:   age,  }  s.nextID++  s.users = append(s.users, user)  return user}

func (s *Store) UpdateUser(id string, name, email *string, age *int) *User {  s.mu.Lock()  defer s.mu.Unlock()  for i, u := range s.users {    if u.ID == id {      if name != nil {        s.users[i].Name = *name      }      if email
```