Leitores como você ajudam a apoiar o MUO. Quando você faz uma compra usando links em nosso site, podemos ganhar uma comissão de afiliado.

GraphQL é uma especificação baseada em HTTP que resolve a maioria dos problemas que você encontrará ao criar RESTful APIs. É adequado para criar APIs complexas, pois você pode usar um endpoint para acessar dados de vários esquemas.

GraphQL atenua problemas como busca excessiva e busca insuficiente em REST. Você pode criar um cliente que solicita campos específicos sem precisar fazer chamadas de API extras.

Existem vários pacotes Go dos quais você pode aproveitar para criar aplicativos baseados em GraphQL, de servidores a APIs.

1. O pacote gqlgen

gqlgen (Gerador GraphQL) é um pacote type-safe rico em recursos para gerar e construir APIs e servidores GraphQL.

O pacote gqlgen adota uma abordagem de primeiro esquema, pela qual você usa o GraphQL SDL para definir seu esquema. Em seguida, ele gera o código clichê que você pode ajustar para configurar o servidor GraphQL e a API.

instagram viewer

gqlgen é um dos pacotes GraphQL mais completos em o ecossistema Go. Você pode gerar documentação e exemplos com o pacote e criar consultas, mutações e assinaturas.

gqlgen garante ligações de tipo, incorporações, interfaces, entradas geradas e enums. O pacote também fornece funcionalidade para rastreamento aberto, ganchos para registro de erros, carregamento de dados, simultaneidade e maior complexidade de consulta.

Depois de definir seu esquema GraphQL, como faria com qualquer biblioteca que priorizasse o esquema, você usará o aplicativo de linha de comando gqlgen para gerar o código clichê do esquema em seu projeto.

Criar uma ferramentas.go arquivo em seu diretório de trabalho e adicione estas linhas de código para incluir o gqlgen pacote:

// +criar ferramentas
pacote ferramentas
importar _ "github.com/99designs/gqlgen"

O ferramentas.go arquivo especifica as ferramentas de compilação para o gqlgen pacote.

Execute estes comandos em seu diretório de trabalho para instalar o pacote gqlgen e suas dependências:

ir instale github.com/99designs/gqlgen@latest
ir mod arrumado

Você pode inicializar um novo projeto GraphQL ao executar o pacote GraphQL com o iniciar comando como argumento:

ir execute github.com/99designs/gqlgen init

Você precisará ter seu esquema em um schema.graphql localizado em seu diretório de trabalho para inicializar um projeto.

Execute o server.go arquivo para iniciar seu servidor GraphQL após adicionar funcionalidade ao seu aplicativo GraphQL:

ir executar servidor.ir

2. O pacote graphql-go

O pacote graphql-go é uma biblioteca GraphQL popular que visa fornecer a solução completa Especificação de rascunho do GraphQL para construir serviços GraphQL em Go.

O pacote graphql-go usa a abordagem de tipos de tempo de execução; você tem a opção de declarar seu esquema em código Go e o pacote verifica em tempo de execução.

Você pode implementar consultas, mutações e assinaturas e gerar exemplos com o pacote, mas não há funcionalidade para enums gerados, entradas ou rastreamento aberto.

O graphql-go apresenta uma API mínima com suporte para pacotes integrados e populares de terceiros. Possui suporte para OpenTelemetry e Open Tracing padrões, verificação de tipo de esquema em resolvedores, execução paralela de resolvedores e muitos outros recursos.

Se você estiver familiarizado com construindo serviços RESTful em Go com o http pacote, você achará o pacote graphql-go fácil de usar.

Execute estes comandos em seu diretório de trabalho para adicionar o pacote graphql-go e suas dependências ao seu projeto:

ir obtenha github.com/graph-gophers/graphql-ir

Aqui está um exemplo de como iniciar um servidor GraphQL simples:

pacote principal
importar (
 "registro"
 "rede/http"


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


tipo consulta estrutura{}


função(_ *consulta)Olá()corda { retornar "Olá Mundo!" }


funçãoprincipal() {
 esquemaExemplo := `
tipo Consulta {
 Olá: Corda!
 }
`
esquema := gráficoql. MustParseSchema (schemaExample, &query{})
 http. Handle("/consulta", &relay. Manipulador{Esquema: esquema})
 registro. fatal (http. OuvirEServir(":8080", nada))
}

O Olá método do consulta struct é um resolvedor para o endpoint GraphQL que retorna hello world. O esquemaExemplo variável é a definição do esquema e o servidor será executado na porta 8080 com o http pacote de OuvirEServir método.

3. O Pacote do Trovão

O Trovão framework adota a primeira abordagem struct; você declara uma estrutura que modela seu esquema GraphQL. Ele gera o Esquema GraphQL dos dados Go para lidar com lotes de consultas, consultas ao vivo, mutações, assinaturas e geração de exemplos.

O Thunder fornece segurança de tipo com ligações de tipo e outros recursos, incluindo construção de esquema baseada em reflexão, execução paralela e lotes integrados, um editor GraphiQL integrado e esquemas divididos para GraphQL maior servidores.

Não há funcionalidade para incorporação, interfaces, enumerações ou entradas geradas, federação, rastreamento aberto ou erros personalizados no pacote Thunder. No entanto, é um dos mais fáceis de usar em comparação com outros pacotes populares e é um excelente pacote inicial se você não tiver experiência em GraphQL.

Você precisará executar este comando no terminal do seu diretório de trabalho para instalar o pacote Thunder e suas dependências:

ir obtenha github.com/samsarahq/thunder/graphql

Você precisará declarar um modelo struct para o esquema, escrever os resolvedores e instanciar o servidor para iniciar um servidor GraphQL simples com o pacote Thunder.

importar (
 "contexto"
 "rede/http"
 "tempo"
"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"
)


tipo publicar estrutura {
 Título corda
 Corpo corda
 Criado na hora. Tempo
}


// server é nosso servidor graphql.
tipo servidor estrutura {
 mensagens [] mensagens
}


// registerQuery registra o tipo de consulta raiz.
função(s * servidor)registerQuery(esquema *schemabuilder. Esquema) {
 obj := esquema. Consulta()


obj. FieldFunc("postagens", função() []publicar {
retornar s.postagens
 })
}


// registerMutation registra o tipo de mutação raiz.
função(s * servidor)registrarMutação(esquema *schemabuilder. Esquema) {
 obj := esquema. Mutação()


obj. CampoFunc("eco", função(argumentos estrutura{ Mensagem corda })corda {
retornar argumentos Mensagem
 })
}


// registerPost registra o tipo de postagem.
função(s * servidor)RegisterPost(esquema *schemabuilder. Esquema) {
 obj := esquema. Object("Postagem", postagem{})


obj. CampoFunc("idade", função(ctx contexto. Contexto, p *post)corda {
 reativo. InvalidateAfter (ctx, 5*tempo. Segundo)
retornar tempo. Desde (pág. CriadoEm).String()
 })
}


// schema constrói o esquema graphql.
função(s * servidor)esquema() *gráficoql.Esquema {
 construtor := esquemaconstrutor. NovoEsquema()
 s.registerQuery (construtor)
 s.registerMutation (construtor)
 s.registerPost (construtor)
retornar construtor. DeveConstruir()
}


funçãoprincipal() {
// Instanciar um servidor, construir um servidor e servir o esquema na porta 3030.
 servidor := &servidor{
 postagens: []postagem{
 {Título: "primeiro post!", Corpo: "Cheguei primeiro!", Criado às: hora. Agora()},
 {Título: "graphql", Corpo: "você ouviu falar do Thunder?", CreatedAt: time. Agora()},
 },
 }


esquema := servidor.esquema()
 introspecção. AddIntrospectionToSchema (esquema)
// Expõe schema e graphiql.
 http. Handle("/graphql", graphql. Manipulador (esquema))
 http. Handle("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Manipulador()))
 http. OuvirEServir(":3030", nada)
}

O publicar struct é o modelo para o esquema GraphQL e o servidor struct é a instância do servidor. O registerQuery, registrarMutação, e RegisterPost métodos são funções de resolução para consultas, mutações e armazenamento de dados.

O principal função começa com o servidor GraphQL na porta 3030 e o editor GraphQL.

Você pode consultar APIs GraphQL em Go com pacotes integrados

O GraphQL é baseado em HTTP e você pode consumir APIs GraphQL com o built-in http pacote e outros pacotes semelhantes às APIs RESTful. Também existem pacotes no ecossistema Go que permitirão que você consuma APIs GraphQL rapidamente.