Como fazer solicitações HTTP em Go

Um dos princípios fundamentais que regem o funcionamento da World Wide Web é a troca de solicitações e respostas. Quando você envia uma solicitação para acessar uma página da Web, o servidor responde com os dados apropriados.

Protocolos populares que regem diferentes tipos de comunicação na Internet incluem HTTP (Protocolo de Transferência de Hipertexto), FTP (Protocolo de Transferência de Arquivos) e SMTP (Protocolo de transferência de correio simples).

HTTP é o protocolo que você normalmente usará ao visualizar um site ou usar um aplicativo habilitado para web. Você também pode trabalhar com solicitações HTTP de várias linguagens de programação, incluindo Go.

O que é uma solicitação HTTP?

O HTTP define como os clientes, como os navegadores da Web, enviam solicitações aos servidores que retornam uma resposta. Uma solicitação HTTP contém informações sobre um recurso que o cliente está tentando acessar. A mensagem de solicitação geralmente inclui uma URL que identifica o recurso e outros dados opcionais, como cabeçalhos e parâmetros de consulta.

Há vários tipos de solicitação HTTP, incluindo GET, POST, PUT, DELETE, HEAD, OPTIONS e CONNECT. Os primeiros quatro tipos de método são os mais comuns; eles espelham as operações CRUD lidas, criadas, atualizadas e excluídas, respectivamente.

O tipo de solicitação PUT geralmente é usado de forma intercambiável com o tipo de solicitação PATCH. Eles atingem o mesmo objetivo, apenas diferem nos dados que esperam que a solicitação inclua.

Enviando solicitações usando métodos HTTP comuns

integrado do Go http pacote fornece um conjunto de funções e estruturas que você pode usar para criar servidores da Web e gerenciar solicitações HTTP. É um pacote muito robusto e todos os frameworks da web Go são construídos sobre ele de uma forma ou de outra. É um sub-pacote do Go's líquido pacote.

Para criar uma solicitação HTTP em Go, você pode usar o http. Novo pedido() e defina o método apropriado, URL, cabeçalhos e corpo da solicitação. Depois de criar a solicitação, você pode usar o Go rede/http pacote de http. Cliente{} estrutura para executá-lo e receber a resposta.

Os exemplos de código a seguir usam reqres.in, uma API disponível publicamente para testar solicitações HTTP. Você pode usá-lo para testar solicitações GET, POST, PUT e DELETE em seus programas Go.

Solicitação POST

O código abaixo é uma função que envia uma solicitação POST para o /api/users endpoint de reqres.in para criar um novo usuário com um nome e um trabalho.

pacote principal
importar (
"bytes"
"codificação/json"
"fmt"
"io"
"rede/http"
)
funçãocriarusuário(nome, trabalho corda) {
 fmt. Imprimirln("Criando usuário...")
 apiUrl := " https://reqres.in/api/users"
 userData := []byte(`{"nome":"` + nome + `","trabalho":"` + trabalho + `"}`)
// cria nova requisição http
 solicitação, erro := http. Novo pedido("PUBLICAR", apiUrl, bytes. NovoBuffer (userData))
 solicitar. Cabeçalho. Definir("Tipo de conteúdo", "aplicativo/json; conjunto de caracteres = utf-8")
//envia a requisição
 cliente := &http. Cliente{}
 resposta, erro := cliente. Fazer (solicitar)
se erro!= nada {
 fmt. Println (erro)
 }
 responseBody, erro := io. ReadAll (resposta. Corpo)
se erro!= nada {
 fmt. Println (erro)
 }
 formattedData := formatJSON(responseBody)
 fmt. Imprimirln("Status: ", resposta. Status)
 fmt. Imprimirln("Corpo da resposta: ",formatadoData)
// limpa a memória após a execução
adiar resposta. Corpo. Fechar()
}

formatoJSON é uma função personalizada que você pode gravar para formatar os dados de saída. Veja como você pode implementá-lo:

// função para formatar dados JSON
funçãoformatoJSON(dados []byte)corda {
var bytes de saída. Amortecedor
 erro := json. Recuo(&saída, dados, "", " ")
se erro != nada {
 fmt. Println (err)
 }
 d := fora. Bytes()
retornarcorda(d)
}

Você pode ligar para o criarUsuário() funcionar em um programa como este:

funçãoprincipal() {
 fmt. Imprimirln("Fazendo solicitação POST...")
 criarUsuário("Tim Omolana", "Escritor")
}

Ao executar o programa em um terminal, usando o vá correr comando, você verá uma saída como esta:

Solicitação GET

O código a seguir é uma função que envia uma solicitação GET para recuperar um usuário do servidor reqres.in usando seu ID exclusivo.

// main.go
funçãogetUser(eu ia corda) {
 fmt. Imprimirln("Obtendo usuário por ID...")
// faz solicitação GET para a API para obter o usuário por ID
 apiUrl := " https://reqres.in/api/users/" + id
 solicitação, erro := http. Novo pedido("PEGAR", apiUrl, nada)
se erro!= nada {
 fmt. Println (erro)
 }
 solicitar. Cabeçalho. Definir("Tipo de conteúdo", "aplicativo/json; conjunto de caracteres = utf-8")
 cliente := &http. Cliente{}
 resposta, erro := cliente. Fazer (solicitar)
se erro!= nada {
 fmt. Println (erro)
 }
 responseBody, erro := io. ReadAll (resposta. Corpo)
se erro!= nada {
 fmt. Println (erro)
 }
 formattedData := formatJSON(responseBody)
 fmt. Imprimirln("Status: ", resposta. Status)
 fmt. Imprimirln("Corpo da resposta: ",formatadoData)
// limpa a memória após a execução
adiar resposta. Corpo. Fechar()
}

Uma solicitação GET não envia dados ao servidor, portanto, não aceita ou envia um corpo de solicitação ao servidor quando feita. Veja como será uma chamada de exemplo para a função acima:

funçãoprincipal() {
 fmt. Imprimirln("Fazendo solicitação GET...")
 getUser("2")
}

Saída:

Solicitação PUT

A solicitação PUT é muito semelhante a uma solicitação POST porque também envia dados para o servidor. A principal diferença é que POST cria um novo recurso enquanto PUT atualiza um existente.

Aqui está uma implementação de uma solicitação PUT:

// main.go
funçãoatualizarUsuário(nome, trabalho, id corda) {
 fmt. Imprimirln("Atualizando usuário...")
// faz a solicitação PUT para a API para atualizar o usuário
 apiUrl := " https://reqres.in/api/users/" + id
 userData := []byte(`{"nome":"` + nome + `","trabalho":"` + trabalho + `"}`)
// cria nova requisição http PUT
 solicitação, erro := http. Novo pedido("COLOCAR", apiUrl, bytes. NovoBuffer (userData))
 solicitar. Cabeçalho. Definir("Tipo de conteúdo", "aplicativo/json; conjunto de caracteres = utf-8")
// Corpo da função restante da função createUser...
// Faz a solicitação, obtém a resposta e limpa a memória...
}

A partir desse código, você pode ver que as únicas diferenças entre a solicitação PUT e a solicitação POST acima são o nome do método e a URL. Ao usar um PUT para atualizar os dados existentes, você precisará anexar o id ao URL da solicitação. Um exemplo de chamada para esta função ficaria assim:

função principal() {
// atualiza a entrada com o ID 2.
 updateUser("Tim Novo Nome", "Funcionário escritor", "2")
}

O código acima atualiza o usuário e produz a seguinte saída:

Apagar solicitação

Use o método de solicitação DELETE para executar uma operação de exclusão em um servidor da web. Uma solicitação de exclusão exclui o recurso identificado pelo URI. Uma solicitação DELETE em Go se parece com isto:

funçãodeletar usuário(eu ia corda) {
 fmt. Imprimirln("Excluindo usuário...")
// faz solicitação DELETE à API para excluir usuário
 apiUrl := " https://reqres.in/api/users/" + id
// cria nova requisição http
 solicitação, erro := http. Novo pedido("EXCLUIR", apiUrl, nada)
 solicitar. Cabeçalho. Definir("Tipo de conteúdo", "aplicativo/json; conjunto de caracteres = utf-8")
 cliente := &http. Cliente{}
 resposta, erro := cliente. Fazer (solicitar)
se erro!= nada {
 fmt. Println (erro)
 }
 fmt. Imprimirln("Status: ", resposta. Status)
}

Uma solicitação DELETE não aceita nem retorna um corpo, portanto, não há necessidade de analisar ou formatar a solicitação JSON e o corpo da resposta. A resposta retorna apenas um status para indicar sucesso ou falha. Aqui está a aparência de uma chamada de amostra para a função com sua saída:

funçãoprincipal() {
 fmt. Imprimirln("Fazendo solicitação DELETE...")
 deletar usuário("2")
}

Saída:

Economize tempo usando o http. Publicar() e http. Pegar() métodos do rede/http pacote para fazer PUBLICAR e PEGAR pedidos diretamente, sem ter que usar o Novo pedido() função e o Cliente{} estrutura para criar e fazer a requisição separadamente. Confira a documentação net/http Para maiores informações.

Fazendo solicitações HTTP em aplicativos Go

O http O pacote em Go fornece tudo o que é necessário para fazer solicitações HTTP e lidar com respostas em aplicativos Go. As funções e estruturas fornecidas pelo pacote permitem criar e enviar diferentes tipos de solicitações como GET, POST, PUT, DELETE e muito mais.

Isso facilita a criação de aplicativos da Web em Go que podem interagir com outros serviços da Web e APIs. Uma boa maneira de obter mais familiarizado com fazer solicitações HTTP em Go é criar um aplicativo que faz solicitações para outra API REST de seu.