Czytelnicy tacy jak ty pomagają wspierać MUO. Kiedy dokonujesz zakupu za pomocą linków na naszej stronie, możemy otrzymać prowizję partnerską.

GraphQL to specyfikacja oparta na protokole HTTP, która rozwiązuje większość problemów, które napotkasz podczas budowania RESTful Pszczoła. Nadaje się do tworzenia złożonych interfejsów API, ponieważ można używać jednego punktu końcowego do uzyskiwania dostępu do danych z wielu schematów.

GraphQL łagodzi problemy, takie jak nadmierne pobieranie i niedostateczne pobieranie w REST. Możesz zbudować klienta, który żąda określonych pól bez konieczności wykonywania dodatkowych wywołań API.

Istnieje kilka pakietów Go, które można wykorzystać do tworzenia aplikacji opartych na GraphQL, od serwerów po interfejsy API.

1. Pakiet gqlgen

gqlgen (Generator GraphQL) to bogaty w funkcje, bezpieczny typowo pakiet do generowania i budowania serwerów i interfejsów API GraphQL.

Pakiet gqlgen przyjmuje podejście oparte na schemacie, w którym używasz GraphQL SDL do zdefiniowania swojego schematu. Następnie generuje kod wzorcowy, który można dostosować, aby skonfigurować serwer i interfejs API GraphQL.

instagram viewer

gqlgen jest jednym z bardziej kompletnych pakietów GraphQL w ekosystem Go. Za pomocą pakietu można generować dokumentację i przykłady oraz tworzyć zapytania, mutacje i subskrypcje.

gqlgen zapewnia powiązania typów, osadzania, interfejsy, generowane dane wejściowe i wyliczenia. Pakiet zapewnia również funkcjonalność otwartego śledzenia, zaczepy do rejestrowania błędów, ładowania danych, współbieżności i zwiększonej złożoności zapytań.

Po zdefiniowaniu schematu GraphQL — tak jak w przypadku każdej biblioteki opartej na schemacie — użyjesz aplikacji wiersza poleceń gqlgen do wygenerowania kodu wzorcowego ze schematu w swoim projekcie.

Stwórz narzędzia.go plik w swoim katalogu roboczym i dodaj te wiersze kodu, aby uwzględnić plik gqlgen pakiet:

// + narzędzia do budowania
pakiet narzędzia
import _ "https://github.com/99designs/gqlgen"

The narzędzia.go plik określa narzędzia do budowania dla gqlgen pakiet.

Uruchom te polecenia w swoim katalogu roboczym, aby zainstalować pakiet gqlgen i jego zależności:

Iść zainstaluj github.com/99projekty/gqlgen@najnowsze
Iść modny porządek

Możesz zainicjować nowy projekt GraphQL po uruchomieniu pakietu GraphQL z w tym polecenie jako argument:

Iść uruchom github.com/99projekty/gqlgen init

Musisz mieć swój schemat w pliku schemat.grafql plik znajdujący się w twoim katalogu roboczym, aby zainicjować projekt.

Uruchom serwer.go plik, aby uruchomić serwer GraphQL po dodaniu funkcjonalności do aplikacji GraphQL:

Iść uruchomić serwer.Iść

2. Pakiet graphql-go

Pakiet graphql-go to popularna biblioteka GraphQL, której celem jest zapewnienie kompletności Projekt specyfikacji GraphQL do budowania usług GraphQL w Go.

Pakiet graphql-go przyjmuje podejście typów środowiska uruchomieniowego; masz możliwość zadeklarowania swojego schematu w kodzie Go, a pakiet sprawdza się w czasie wykonywania.

Możesz implementować zapytania, mutacje i subskrypcje oraz generować przykłady za pomocą pakietu, ale nie ma funkcji dla generowanych wyliczeń, danych wejściowych ani otwartego śledzenia.

graphql-go oferuje minimalny interfejs API z obsługą zarówno wbudowanych pakietów, jak i popularnych pakietów innych firm. Posiada wsparcie dla OpenTelemetry I OpenTracing standardów, sprawdzanie typu schematu względem programów tłumaczących, równoległe wykonywanie programów tłumaczących i wiele innych funkcji.

Jeśli jesteś zaznajomiony z budowanie usług RESTful w Go z http pakiet, przekonasz się, że pakiet graphql-go jest łatwy w użyciu.

Uruchom te polecenia w swoim katalogu roboczym, aby dodać pakiet graphql-go i jego zależności do swojego projektu:

Iść pobierz https://github.com/graph-gophers/graphql-Iść

Oto przykład uruchomienia prostego serwera GraphQL:

pakiet główny
import (
 "dziennik"
 „sieć/http”


graphql "github.com/graph-gophers/graphql-Iść"
 „github.com/graph-gophers/graphql-Iść/relay"
)


typ zapytanie struktura{}


funkcja(_ *zapytanie)Cześć()strunowy { powrót "Witaj świecie!" }


funkcjagłówny() {
 schematPrzykład := `
typ Zapytanie {
 cześć: String!
 }
`
schemat := graphql. MustParseSchema (schemaExample, &query{})
 http. Handle("/query", &relay. Handler{Schemat: schemat})
 dziennik. fatalny (https://www. ListenAndServe(":8080", zero))
}

The Cześć metoda tzw zapytanie struct jest narzędziem tłumaczącym dla punktu końcowego GraphQL, który zwraca hello world. The schemat Przykład zmienna jest definicją schematu, a serwer będzie działał na porcie 8080 z rozszerzeniem http paczka Słuchaj i służ metoda.

3. Pakiet Thunder

The Grzmot framework przyjmuje podejście struct first; deklarujesz strukturę, która modeluje twój schemat GraphQL. Generuje tzw Schemat GraphQL z danych Go do obsługi przetwarzania wsadowego zapytań, zapytań na żywo, mutacji, subskrypcji i generowania przykładów.

Thunder zapewnia bezpieczeństwo typów dzięki powiązaniom typów i innym funkcjom, w tym budowaniu schematów w oparciu o odbicia, wbudowane wykonywanie równoległe i przetwarzanie wsadowe, wbudowany edytor GraphiQL i podzielone schematy dla większego GraphQL serwery.

W pakiecie Thunder nie ma funkcji osadzania, interfejsów, generowanych wyliczeń ani danych wejściowych, federacji, otwartego śledzenia ani niestandardowych błędów. Jest to jednak jeden z najłatwiejszych w użyciu pakietów w porównaniu z innymi popularnymi pakietami i jest doskonałym pakietem startowym, jeśli nie masz doświadczenia z GraphQL.

Będziesz musiał uruchomić to polecenie w terminalu swojego katalogu roboczego, aby zainstalować pakiet Thunder i jego zależności:

Iść pobierz https://github.com/samsarahq/thunder/graphql

Będziesz musiał zadeklarować model struktury dla schematu, napisać resolwery i utworzyć instancję serwera, aby uruchomić prosty serwer GraphQL z pakietem Thunder.

import (
 "kontekst"
 „sieć/http”
 "czas"
"github.com/samsarahq/thunder/graphql"
 "github.com/samsarahq/thunder/graphql/graphiql"
 „github.com/samsarahq/thunder/graphql/introspekcja”
 "github.com/samsarahq/thunder/graphql/schemabuilder"
 "github.com/samsarahq/thunder/reactive"
)


typ post struktura {
 Tytuł strunowy
 Ciało strunowy
 Utworzono w czasie. Czas
}


// serwer to nasz serwer graphql.
typ serwer struktura {
 posty []post
}


// registerQuery rejestruje główny typ zapytania.
funkcja(s *serwer)RegisterQuery(schemat *program do tworzenia schematów. Schemat) {
 obiekt := schemat. Zapytanie()


obj. FieldFunc("posty", funkcja() []post {
powrót s.posty
 })
}


// registerMutation rejestruje główny typ mutacji.
funkcja(s *serwer)zarejestruj Mutację(schemat *program do tworzenia schematów. Schemat) {
 obiekt := schemat. Mutacja()


obj. FieldFunc("echo", funkcja(argumenty struktura{ Wiadomość strunowy })strunowy {
powrót argumenty Wiadomość
 })
}


// registerPost rejestruje typ posta.
funkcja(s *serwer)zarejestrujPost(schemat *program do tworzenia schematów. Schemat) {
 obiekt := schemat. Obiekt("Opublikuj", opublikuj{})


obj. FieldFunc("wiek", funkcja(kontekst ctx. Kontekst, p *post)strunowy {
 reaktywny. Unieważnij po (ctx, 5*czas. Drugi)
powrót czas. Ponieważ (s. UtworzonoAt).String()
 })
}


// schemat buduje schemat graphql.
funkcja(s *serwer)schemat() *wykresql.Schemat {
 budowniczy := konstruktor schematów. NowySchemat()
 s.registerQuery (konstruktor)
 s.registerMutation (konstruktor)
 s.registerPost (konstruktor)
powrót budowniczy. MusiBuild()
}


funkcjagłówny() {
// Utwórz instancję serwera, zbuduj serwer i udostępnij schemat na porcie 3030.
 serwer := &serwer{
 posty: []post{
 {Title: „pierwszy post!”, Body: „Byłem tu pierwszy!”, CreatedAt: time. Teraz()},
 {Title: „graphql”, Body: „czy słyszałeś o Thunder?”, CreatedAt: time. Teraz()},
 },
 }


schemat := serwer.schemat()
 introspekcja. AddIntrospectionToSchema (schemat)
// Ujawnij schemat i graphiql.
 http. Uchwyt("/grafql", wykresql. Program obsługi (schemat))
 http. Uchwyt("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Treser()))
 http. ListenAndServe(":3030", zero)
}

The post struct jest modelem schematu GraphQL, a serwer struct to instancja serwera. The RegisterQuery, zarejestruj Mutację, I zarejestrujPost metody to funkcje rozpoznawania nazw dla zapytań, mutacji i przechowywania danych.

The główny funkcja uruchamia się z serwerem GraphQL na porcie 3030 oraz edytor GraphQL.

Możesz wysyłać zapytania do GraphQL API w Go z wbudowanymi pakietami

GraphQL jest oparty na protokole HTTP i możesz korzystać z interfejsów API GraphQL za pomocą wbudowanego http package i inne pakiety podobne do RESTful API. W ekosystemie Go dostępne są również pakiety, które pozwolą Ci szybko korzystać z interfejsów API GraphQL.