Criação de um CRUD em Golang

Dizem por aí que, quando você começa no mundo de programação, existe uma “maldição” que só pode ser quebrada quando você consegue rodar o primeiro “Hello Word”, verdade ou não, não vamos arriscar né? (risos).

Particularmente acredito que a história por trás do mito, refere-se às pequenas complexidades em entender, estruturar e organizar os pacotes e bibliotecas necessários para executar uma classe main, seja ela qual for a linguagem, cada uma contém suas particularidades.

E se executar um “Hello Word” te liberta de uma maldição, o que você acha de aprender a criar um CRUD?! Essa abreviação refere-se a sigla das quatros operações funcionais em um sistema, se você é iniciante em programação, te garanto que aprender a escrever um CRUD irá te ajudar a expandir seu raciocínio sobre classes, repositórios, DTO, controller, métodos, funções e etc, considere o CRUD como uma porta de entrada para aprender conceitos avançados de programação.

Mas atenção, nem tudo no dia a dia de um programador se resume a  desenvolver CRUD`S, eu diria que este é, a apenas uma gota d’água no oceano, então, não pare por aqui, continue!

CRUD é o acrônimo de:

Create   - Criar

Read       - Ler

Update    - Atualizar

Delete      - Apagar

Embora as operações CRUD sejam frequentemente usadas em sistemas que usam protocolos de rede, como HTTP, HTTPS e TCP, elas não são exclusivas desses protocolos. O conceito de CRUD é amplamente aplicável a sistemas de gerenciamento de dados em geral, incluindo bancos de dados, APIs, sistemas de arquivos e outras formas de armazenamento e comunicação de dados, como mencionei anteriormente, o CRUD é uma excelente porta de entrada para conceitos avançados de programação.

Neste artigo, vamos mapear essas operações, para um sistema web utilizando o protocolo HTTP.

Mas antes, que tal revisar alguns conceitos de HTTP?!

Conceitos HTTP

HTTP, ou Hypertext Transfer Protocol (Protocolo de Transferência de Hipertexto), é um protocolo de comunicação utilizado na World Wide Web (Web) para a transferência de informações entre um cliente (como um navegador web) e um servidor (onde estão localizados os recursos, como páginas da web). O HTTP é fundamental para a forma como navegamos na internet e acessamos recursos online.

Existem vários métodos utilizados pelo HTTP, os mais populares são:

GET - Utilizado para buscar um recurso específico no servidor, uma solicitação GET, pode ser responsável por ler milhares de arquivos, linhas, e tabelas, e retornar o resultado solicitado pelo cliente.

POST - É utilizado para enviar dados do cliente ao servidor, sabe quando preenchemos um formulário e clicamos no botão “enviar” ? Estamos realizando uma operação do tipo POST.

PUT - Utilizamos esse método para alterar dados específicos no nosso servidor, o PUT é muito utilizado nas operações de atualização de cadastros, ou edição de conteúdo.

DELETE - O delete é utilizado para excluir dados do servidor, o cliente envia uma solicitação, e o servidor ao processar o comando, exclui o dado solicitado.

E aí, já deu para notar a semelhança entre os métodos?

Create: Geralmente mapeado para o método HTTP POST.

Read: Geralmente mapeado para o método HTTP GET.

Update: Geralmente mapeado para o método HTTP PUT.

Delete: Geralmente mapeado para o método HTTP DELETE.

Portanto, enquanto as operações CRUD têm uma relação próxima com protocolos de rede como HTTP, elas têm um escopo mais amplo e podem ser aplicadas em vários contextos de gerenciamento de dados.

Então, conceitos revisados, apresentações feitas, vamos pôr a mão na massa!

Implementação Utilizando Gorila Mux

Vamos começar criando um novo projeto na IDE se sua preferência, em seguida no terminal, certifique-se de estar dentro da pasta do projeto e, utilize o comando go mod para iniciar um novo módulo, como no exemplo:

Para esse exemplo, vou chamar o projeto de Crud, pois os nomes precisam ser objetivos.

O Go Mod é uma ferramenta usada para gerenciar dependências em projetos Go. Ele foi introduzido no Go 1.11 como uma maneira de substituir a dependência em GOPATH.

Isso criará um arquivo chamado go.mod no seu diretório.

Agora você pode adicionar dependências ao seu projeto. Para fazer isso via terminal, você pode usar o comando go get seguido do caminho do pacote que você deseja adicionar. Para nosso exemplo, vamos adicionar a biblioteca gorila/mux, que ajudará a comunicação entre servidor e client:

Note que a dependência foi adicionada em nosso arquivo go.mod

Vamos criar nosso módulo principal src (source), e dentro dele adicione o arquivo main.

Em seguida, adicione as configurações básicas para iniciar um servidor web:

Neste exemplo:

r := router.StartRouter(): está chamando a função StartRouter() do pacote router, este pacote se refere a um roteador/mux personalizado que vamos criar para gerenciar rotas e requisições HTTP do aplicativo.

log.Fatal(http.ListenAndServe("localhost:8080", r)): esta linha, está usando a função http.ListenAndServe(), do pacote net/http, para iniciar o servidor web.Essa função recebe dois argumentos: o endereço que o servidor precisa escutar, neste caso, "localhost:8080”, e a variável r, que representa nosso roteador personalizado.

Dentro do módulo principal src, crie um módulo para o controller, e dentro dele crie o arquivo controller.go

Agora, dentro do módulo principal src, criamos um novo módulo chamado router, que será o responsável por organizar os demais pacotes do nosso servidor.

Dentro do módulo router, crie o módulo userrouter, neste artigo ainda não abordaremos a conexão com o banco de dados, portanto usaremos esse módulo para criar algumas configurações de mocks.

A estrutura de pacotes deve ficar assim:

• crud/src/router/userrouter/users.go
  

O arquivo deve ficar assim:

Ainda dentro do pacote userrouter, crie o arquivo routers.go, que irá conter a struct com as configurações de mock do nosso roteador:

- scr/router/userrouter/routers.go

O arquivo deve ficar assim:

Onde:

URI: é o caminho utilizado pelo servidor para buscar os dados solicitados durante a requisição.

Method: especifica o método HTTP que a requisição deve utilizar.

FunctionRouter func (w http.ResponseWriter, r *http.Request): Este campo é um tipo de função que será chamada quando uma solicitação correspondente ao URI e ao método HTTP de recebimento pelo servidor. A função recebe dois parâmetros:

(http.ResponseWriter): Esse é um objeto que permite escrever uma resposta HTTP de volta ao cliente. É usado para enviar os dados de resposta, como HTML, JSON, etc.

(*http.Request): Este é um objeto que representa a solicitação HTTP recebida do cliente. Ele contém informações sobre a solicitação, como o método, os cabeçalhos, parâmetros body, entre outros.

Auth: Habilita autenticação para segurança de nossa aplicação, neste exemplo, seu uso será sempre false, pois como mencionei estamos utilizando mock de respostas.

A função Config, recebe como parâmetro um ponteiro do tipo mux.Router, e retorna o mesmo tipo.

routers := userRouters: aqui a variável routers está sendo inicializada com o conjunto de rotas definido em userRouters.

for _, rota := range routers : Este é um loop que itera sobre cada rota definida em routers.

Dentro do loop, está sendo usado o método:

r.HandleFunc(rota.URI, rota.FunctionRouter).Methods(rota.Method)

que pertence ao roteador mux.Router, sua finalidade é  associar uma função de tratamento a uma rota específica com um método HTTP específico. Isso significa que quando uma solicitação HTTP corresponde ao URI do método especificado for enviado, a função rota.FunctionRouter será chamada para lidar com a solicitação.

Após iterar por todas as rotas e associar as funções de tratamento, a função retorna o objeto mux.Router modificado, agora configurado com as rotas definidas.

Agora com todas as configurações criadas, vamos então personalizar nosso roteador e inserir essas configurações.

Dentro do pacote router, crie o arquivo router.go

Ao final a estrutura deve seguir essa ordem:

• crud/src/router/router.go

Dentro do arquivo router.go, escreva as seguintes configurações:

Por fim a estrutura de pacotes deve ficar assim:

-Crud - Projeto

-src - módulo principal

-controller: ponto de entrada das requisições.

-router: módulo responsável por armazenar as configurações do roteador

-userrouter:

routers.go

users.go

go.mod: arquivo que contém as dependências do projeto

main: arquivo principal da aplicação

Inicie sua aplicação no arquivo pelo arquivo main, e teste o retorno das funções pelo postman:

Códigos de Retornos HTTP

Como abordamos algumas aspectos e configurações de servidores HTTP, aqui vão algumas dicas dos retornos mas comuns encontrados no dia dia, até mesmo durante alguma pesquisa web, não se preocupe em memorizar todas, mas como programador, conhecer o número inicial de cada retorno, pode te ajudar a identificar rapidamente os tipos de problema da sua aplicação:

1xx (Informativo) : Esses códigos indicam que a solicitação foi recebida e o servidor está aguardando mais ações do cliente.

2xx (Bem-sucedido) : Esses códigos indicam que a solicitação foi bem-sucedida. O código mais comum é 200 (OK), que é retornado quando uma página é fornecida com sucesso.

3xx (Redirecionamento) : Esses códigos indicam que a solicitação precisa de ações adicionais para ser concluída. Isso pode ser um redirecionamento para outra URL ou um cache sendo usado.

4xx (Erro do Cliente) : Esses códigos indicam que ocorreu um erro por parte do cliente. O código 404 (Not Found) é o mais conhecido, indicando que o recurso solicitado não foi encontrado no servidor.

5xx (Server Error) : Esses códigos indicam que ocorreu um erro no servidor ao processar a solicitação. O código 500 (Internal Server Error) é um exemplo, detalhando um erro interno no servidor.

Espero que esse artigo tenha sido útil e contribuído para a sua jornada, bons estudos!