Aula 01
Como Criar uma API JSON em Golang - CRUD Simples
Nesta aula nós aprendemos a usar o pacote net/http
para iniciar um servidor com uma rota principal.
O método HandleFunc
do pacote http é usado para rotear uma requisição para uma função que tem dois parâmetros: o ResponseWriter
e o *Request
.
Podemos usar o Fprintf
do pacote fmt
para enviar uma resposta em texto plano.
Summary
Resumo do Curso: Criando uma API JSON em Go
Introdução
Neste curso, vamos aprender a desenvolver uma API simples em Go (Golang) que lida com operações CRUD (Create, Read, Update, Delete) usando JSON. O objetivo é demonstrar como listar, buscar, atualizar e remover dados através de uma API.
Configuração do Projeto
-
Criação do Projeto:
- Inicie um novo projeto chamado
go-api-json-crud-simple
. - Crie um arquivo
main.go
, que será o arquivo principal onde escreveremos nosso código.
- Inicie um novo projeto chamado
-
Ambiente de Desenvolvimento:
- Começaremos sem uma conexão com um banco de dados, focando nas rotas e funções de controle.
Estrutura do Código
-
Pacote e Função Principal:
- Defina o pacote como
main
. - Crie a função principal
main()
.
- Defina o pacote como
-
Importação de Pacotes:
- Importe o pacote
net/http
efmt
no início do arquivo.
- Importe o pacote
-
Instanciando o Servidor:
- Utilize
http.ListenAndServe
para rodar um servidor HTTP:http.ListenAndServe(":1337", nil)
- Utilize
-
Definindo uma Rota:
- Antes de chamar o
ListenAndServe
, defina uma rota para o diretório raiz (/
) usandohttp.HandleFunc
:http.HandleFunc("/", handler)
- Crie a função
handler
que responderá às requisições:func handler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Bem-vindo") }
- Antes de chamar o
Executando a Aplicação
- Compilar e rodar o projeto com:
go run main.go
- Acesse o servidor no navegador em
localhost:1337
. A resposta deve ser "Bem-vindo".
Recapitulando
Nesta aula, aprendemos:
- A configuração básica de um projeto em Go.
- Como implementar um servidor HTTP e uma rota simples.
- O uso do
http.ResponseWriter
para enviar respostas.
Próximos Passos
- Nas próximas aulas, iremos expandir a API para adicionar mais rotas e implementar funcionalidades de CRUD.
Video Transcript
Olá pessoal, nesse curso nós vamos aprender a fazer um API de JSON na linguagem go long,
vai ser um crud, bem simples, só para a terade demonstrar como você pode listar, buscar,
atualizar e remover coisas através de um API no go, nós vamos usar o módulo net-http
para poder rodar um servidor de HTTP, tá certo? Então vai ser bem simples, gente vai começar sem
nenhuma conexão para a data base, banco de dados, porque a gente quer focar mais como
você lidar com as rotas e fazer as funções de controle no go. Tá? Então para poder começar
aqui eu criei uma parte daqui para o meu projeto go long, traço API, traço JSON, traço crud
simples e criei um arquivo dentro do projeto chamado main.go, vai ser o arquivo principal
de a gente vai começar a escrever o nosso código. Então esse curso vai ser bem prático, a gente vai
começar a escrever código já sem nenhum, sem perder tempo, vamos começar e vamos, da maneira que a
gente escreve o código, vamos refatorizar e mudar umas coisas de canto e aprimorar mais e mais desde o
início, tá? Começar do zero aqui e ver no que dá, vamos criar um servidor de HTTP para dar um crud.
Então para começar aqui vamos no nosso arquivo main.go, vamos já começar escrevendo o nome do
pacote package, eu vou chamar de main mesmo, vamos começar no pacote principal e temos como sempre
aqui, função principal, main, sem nenhum parâmetro, abro as chaves e aqui que a gente vai começar a
escrever o nosso negócio. Então vamos lá, então a gente vai usar o pacote net barhtp, tá? Então vamos
lá em cima, importar o pacote, vou adicionar o import, abro os parâmetros, em nenhuma cada linha
vai por importar, a linha aqui, você vai fazer o seguinte, para importar o HTTP só dizer net barhtp.
Com isso nós vamos poder usar esse pacote HTTP, tá? Agora vamos aqui embaixo. Então primeiro de
aqui, para você rodar o servidor de HTTP usando Go, só faz o seguinte, faz HTTP.listen, tá?
And serve, é o nome do método aqui e esse método vai levar dois argumentos, o primeiro
argumento vai ser o endereço aqui desse servidor. Normalmente a gente pode pôr só a porta aqui,
se a gente vai usar o localhost, o local, vou botar dois pontos e o número da porta, eu vou usar
um 337 como número da porta. Segundo argumento vai ser o chamado servidor max, você pode
pôr o meu, e ele vai usar o padrão que é o default server max, tá? Então só pôr o meu aqui e ele
vai usar como padrão esse aqui default server max. Não se preocupe muito com isso, vamos ver no que dá, tá?
Então quando você rodar esse programa, listen and serve vai gerar aqui, vai rodar o servidor
HTTP lá no localhost, dois pontos, um 337, você pode isso no seu navegador e o servidor vai
estar rodando lá. Agora não tem nenhuma rota, não tem nenhum local para você ir, não tem o barra
aqui, então o que tal a gente fazer o barra? Então aqui antes do chamado do listen and serve, tá?
Vou fazer o seguinte, a gente vai chamar o HTTP de novo aqui e vai usar essa função chamada
handle func, tá? Essa função também leva dois argumentos. O primeiro argumento vai ser
onde é o local, da rota aqui nesse caso, se você quiser o diretor raiz, o servidor, que é o barra,
né? Só pôr o barra aqui. Aí no segundo argumento vai ser a função
para você lidar com essa rota, esse end point. E você pode escrever a função aqui ou fazer a
função em outro local e pôr o nome da função aqui. Vamos começar direto aqui, escrever a função
aqui já como função de valor. Então eu vou escrever uma função aqui, função aqui, tá?
Dessa maneira aqui. Agora essa função chamada função de handler, né? Que vem desse handle,
vai ser dois argumentos. Primeiro, normalmente ele se chama de W, tá? Vai ser do tipo HTTP.response
writer, tá? A escritor de resposta. Significa isso. Segundo argumento vai ser o R,
normalmente chama. Vai ser um ponteiro com estrela, HTTP.request, requisição ou pedido, tá?
Agora com isso, dentro dessa função, quando você rodar o servidor e você foi lá no navegador
localhost, dois pontos, um, três, três, sete. E vai ser no diretor raiz, vai bater nessa
rota aqui, né? Aí essa função aqui vai ser executada para você fazer a sua resposta, né?
O cliente. Para a resposta eu vou fazer bem simples a mensagem bem vindo.
Para poder fazer a resposta é só você usar o W aqui. O W é para você
passar a resposta. Você pode usar o F printf do pacote FMT. FMT.F printf. Antes de
usar esse, vamos importar lá em cima o pacote FMT. Depois de adicionar o pacote FMT no
import na linha 4, voltamos para a linha 10. Vamos terminar a chamada do F printf do FMT.
O primeiro argumento vai ser o W, para ele poder escrever para o response writer,
escritor de resposta. E o segundo vai ser o conteúdo da sua mensagem. Eu vou dizer bem vindo, né?
Tá?
Então vamos ver aqui no que dá.
Vamos lá no terminal. Eu estou no terminal dentro da pasta do meu projeto já.
Tem um usuarquivo aqui, main.go, deu LS.
LS lá. Eu vou compilar e rodar ao mesmo tempo. Então vou usar go run main.go.
Então aconteceu nada, parece né? Mas na verdade ele já rodou o servidor. Você
não acha que ele está parado aqui e não deu mais o meu prompt? É porque o servidor
se você quiser matar o servidor dá o Ctrl C. Ctrl C para matar o servidor.
Eu vou rodar de novo e deixar rodando. Aí eu vou no navegador agora.
Eu vou fazer localhost 2.1337, que é a porta que a gente escreveu lá no nosso código.
Tá?
Quando eu fui para o localhost 3.1337, ele falou bem vindo aqui com resposta.
Esse bem vindo veio lá do fprintf que a gente fez. Então deixa eu pegar o editor aqui e te
mostrar. Tá? Essa é a mensagem.
Localhost 2.1337.
Para recapitular tudo isso que a gente fez nessa aula,
nós temos nosso arquivo principal main.go.
Fizemos o pacote main. Fizemos os nossos importos do fmt.net.http.
Na função principal, nós primeiros começamos aqui fazendo o seguinte.
Nós pegamos aqui do modo HTTP e nós chamamos do método handle func.
Primeiro argumento é o local da rota. Nesse caso, a raiz do servidor barra.
E quando você bater lá no barra, vai chamar a função aqui que a gente escreveu.
A função de handler, que é o segundo argumento do handle func,
é normalmente tem dois argumentos. O W e o R. O W é para, normalmente, relacionar
sua resposta. É o tipo HTTP, response, writer, escritor de resposta.
O segundo argumento R é sobre a requisição. O pedido que foi feito,
que vem do cliente. Você pode obter informações do cliente
através dessa entidade aqui, que é not the star here, reference.
Então, nós podemos dar uma resposta através do fprintf,
basado com o argumento W. E segundo argumento, a mensagem,
nesse caso, só foi a resposta como texto plano.
Então, nós podemos ter vários handle func aqui para cada rota do nosso servidor.
Nesse servidor agora só tem uma rota básica da raiz.
Então, para poder realmente rodar o servidor, é que vem o HTTP.list and serve.
Esse método recebe dois argumentos. O primeiro sendo o endereço do seu servidor aqui.
Nesse caso, a gente só precisa, mais básico, é só por dois pontos e um número da porta.
Ele vai bater lá no localhost. Localhost 2.1337.
Segundo argumento, você pode deixar new e ele vai escolher o default server
mocks por padrão. Então, o HTTP.list and serve, ele rodam um servidor de HTTP
com o endereço que foi fornecido e o handler, nesse caso, a gente põe new que bate no default
server mocks. E esses handle func aqui vão ser associados aqui a essas rotas ao default server mocks.
Então, por essa aula é só e até a próxima.
Nenhum comentário ainda (loading...)
Nenhum comentário ainda (loading...)
Gostou da aula? 😆👍
Apoie nosso trabalho com uma doação: