DEV Community: Breno Almeida

Trabalhando com interfaces em Go

Breno Almeida — Thu, 06 Oct 2022 20:58:39 +0000

Interface é um tipo de dado que define um conjunto de métodos.
Por exemplo, podemos criar uma interface chamada FormaGeometrica que todas as formas geométricas deverão implementar pois todas elas possuem um perímetro e uma área.

type FormaGeometrica interface {
    Perimetro() float32
    Area() float32
}

Podemos criar, por exemplo, o tipo Circulo que implementa essa interface da seguinte forma:

type Circulo struct {
    raio float32
}

func NewCirculo(raio float32) Circulo {
    return Circulo{
        radius: raio,
    }
}

func (c Circulo) Perimetro() float32 {
    return 2 * math.Pi * c.raio
}

func (c Circulo) Area() float32 {
    return math.Pi * c.raio * c.raio
}

Note que não tem nenhuma indicação explícita indicando que o tipo Circulo implementa a interface FormaGeometrica. Isso ocorre porque em Go isso é feito de forma implícita, ou seja, se um tipo implementa os métodos contidos em uma interface, esse tipo automaticamente implementa essa interface.

Como não especificamos explicitamente que um tipo implementa uma interface específica, não é possível gerar um erro de compilação caso o tipo não implemente essa interface, mas isso pode ser resolvido com um truque simples. Podemos adicionar a seguinte linha no nosso código:

var _ FormaGeometrica = NewCirculo(3)

Aqui estamos usando o identificador em branco para definir uma variável que nunca será utilizada no código. Como essa variável é do tipo da interface que criamos, teremos um erro de compilação caso a struct Circulo não implementar essa interface. Fazendo isso, conseguimos forçar nossos tipos a implementar alguma interface em específica.

Outro ponto importante é saber que existe a interface{} que nada mais é do que uma interface que não possui nenhum método, ou seja, todos os tipos de dados implementam essa interface. Isso significa que se algum método receber um parâmetro do tipo interface{}, qualquer variável poderá ser enviado nesse parâmetro, independente do tipo.

Vamos criar agora mais um tipo para exemplificar:

type Quadrado struct {
    lado float32
}

func NewQuadrado(lado float32) Quadrado {
    return Quadrado{
        lado: lado,
    }
}

func (c Quadrado) Perimetro() float32 {
    return 4 * c.lado
}

func (c Quadrado) Area() float32 {
    return c.lado * c.lado
}

Agora podemos usar esses tipos em variáveis do tipo interface de FormaGeometrica. No código abaixo está sendo criada uma slice do tipo FormaGeometrica que pode armazenar variáveis tanto do tipo Circulo quanto do tipo Quadrado. Ao iterar sobre os elementos dessa slice, não precisamos saber qual o tipo concreto de cada elemento, basta utilizar os métodos definidos pela interface.

package main

import "fmt"

type FormaGeometrica interface {
    Perimetro() float32
    Area() float32
}

func main() {
    var formas []FormaGeometrica
    circulo := NewCirculo(2)
    quadrado := NewQuadrado(2)
    formas = append(formas, circulo)
    formas = append(formas, quadrado)

    for _, f := range formas {
        fmt.Println(f.Perimetro())
    }
}

Criando um CRUD em Go com persistência em arquivos

Breno Almeida — Tue, 21 Dec 2021 01:36:31 +0000

Construindo um CRUD em Go com persistência em Arquivos

Introdução

O objetivo desse artigo é mostrar o passo a passo necessário para construir uma API de um CRUD (Create, Read, Update, Delete). Ou seja, nossa API permitirá criar, ler, atualizar e deletar pessoas.

Antes de começar de fato a fazer o código, vou mostrar aqui de maneira visual o que pretendo ter contruído no final desse post.

A gente pode ver na figura que teremos 4 rotas:

Rota de POST para criação de pessoas.
Rota GET para leitura das pessoas. No caso podemos ler todas as pessoas armazenadas ou apenas uma pessoa com base no ID fornecido na URL.
Rota PUT para atualização de uma pessoa já existente.
Rota DELETE para remover uma pessoa.

Todas essas rotas vão utilizar a mesma fonte de dados que será um arquivo de nome person.json, ou seja, nessa API nós não vamos utilizar banco de dados como forma de armazenamento. Futuramente pretendo fazer um post onde eu modifico esse código atual para utilizar banco de dados ao invés de arquivo, mas nesse caso aqui vou fazer com arquivos para mostrar algumas funções de manipulação de arquivo com Go.

Com isso em mente, a gente já consegue ir para a parte de implementação do código.

Rota de criação de pessoas (POST /person/)

O primeiro passo é criar o projeto. Para isso, vou abrir um terminal, criar uma pasta com o nome do projeto, no nosso caso vai ser api-crud-persistencia-arquivo. Em seguida, vou inicializar um novo módulo nessa pasta que a gente acabou de criar utilizando o go mod init github.com/brenoassp/api-crud-persistencia-arquivo. Agora que nosso módulo já está inicializado, vamos criar aqui um arquivo main.go que vai ser a nossa API.

package main

func main(){
    http.HandleFunc("/person/", func(w http.ResponseWriter, r *http.Request){
        http.Error(w, "Not implemented", http.StatusInternalServerError)
    })

    http.ListenAndServe(":8080", nil)
}

A primeira coisa que estamos fazendo aqui é criando uma função que será executada quando chegar requisições que começam com /person/. Note que nesse caso aqui não estamos escolhendo qual o método HTTP utilizado, ou seja, todas as requisições que se encaixarem no padrão de URL executarão essa mesma função.

Podemos executar o código para ver que independente do método, o retorno será o mesmo. Para isso faça:

go run main.go

curl -XPOST localhost:8080/person/

curl -XGET localhost:8080/person/

Ambos os resultados são iguais pois não há distinção de método e teremos que ter isso em mente durante a implementação da API.

Vou começar primeiramente com a implementação da operação de criação de uma pessoa.

package main

func main(){
    http.HandleFunc("/person/", func(w http.ResponseWriter, r *http.Request){
        if r.Method == "POST" {
            type Person struct {
                ID   int    `json:"id"`
                Name string `json:"name"`
                Age  int    `json:"age"`
            }
            var person Person
            err := json.NewDecoder(r.Body).Decode(&person)
            if err != nil {
                fmt.Printf("Error trying to decode body. Body should be a json. Error: %s\n", err.Error())
                http.Error(w, "Error trying to create person", http.StatusBadRequest)
                return
            }
            if person.ID <= 0 {
                http.Error(w, "person ID should be a positive integer", http.StatusBadRequest)
                return
            }

            // criar pessoa

            // montar resposta
            w.WriteHeader(http.StatusCreated)
            return
        }
        http.Error(w, "Not implemented", http.StatusInternalServerError)
    })

    http.ListenAndServe(":8080", nil)
}

Primeiro eu vou verificar se o método da requisição é POST, se sim então podemos continuar.
A primeira operação que devemos fazer é decodificar o corpo da requisição, que no nosso caso deverá ser um JSON com os campos ID, Name e Age. Para isso é preciso criar uma variável de uma struct nesse formato para receber o resultado da decodificação. Com essa variável criada, basta decodificar o JSON recebido da seguinte forma: json.NewDecoder(r.Body).Decode(&person). Esse código tá criando um decodificador com base no corpo da requisição e chamando a função de decodificar passando o endereço de memória da variável que foi criada acima do tipo Person. Esse método retorna um erro que se for diferente de nil significa que algo deu errado durante a decodificação. Faremos um tratamento usando esse erro para retornar um erro para o usuário com o status de BadRequest que indica que o erro ocorreu por conta de valor inválido fornecido pelo próprio usuário.

Caso dê tudo certo a resposta será o status http OK (200).

curl -XPOST localhost:8080/person/ -d '{"id": 1, "name": "joao}' (Faltando fechar as aspas duplas no nome, dá erro na decodificação do JSON)

curl -XPOST localhost:8080/person/ -d '{"id": 1, "name": "joao"}' (Tudo ok)

Se não tiver dado erro nenhum na decodificação, vou verificar se o ID fornecido é maior do que zero, pois o ID tem que ser positivo.

Se deu tudo certo, agora vou tentar adicionar essa pessoa, persistindo em um arquivo.
A princípio vou só deixar um comentário aqui indicando que essa parte da implementação tá faltando e retornar uma resposta com status de criado.

Antes de implementar essa etapa final da rota, vou extrair a struct que foi criada aqui que representa a pessoa para um arquivo separado. Vou criar uma pasta domain e dentro dela o arquivo entities.go que terá as entidades. No nosso caso aqui, vou mover a struct Person pra esse arquivo.

// Arquivo: api-crud-salvando-arquivo/domain/entities.go
package domain

type Person struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

Pronto, agora eu já vou conseguir usar essa struct no nosso serviço sem precisar duplicar código.

O próximo passo agora é criar o nosso serviço. Dentro de domínio, vou criar a pasta person e dentro dela o arquivo person.go

// Arquivo: api-crud-salvando-arquivo/domain/person/person.go
package person

type Service struct {
    dbFilePath string
    people     domain.People
}

A primeira coisa que vou fazer é criar uma struct que armazenará as informações utilizadas pelo serviço, essas informações serão:

1 - o caminho do arquivo onde serão armazenadas as pessoas.

2 - as pessoas que estão armazenadas nesse arquivo.

No arquivo de entidades vou criar um tipo chamado People que será a representação do nosso arquivo de persistência.

type People struct {
    People []Person `json:"people"`
}

Voltando pra criação do serviço responsável pela lógica de negócio de pessoas, eu vou receber o caminho completo do arquivo como parâmetro. Se o arquivo não existir, então eu crio um arquivo vazio. Se ele existir então eu vou pegar todas as pessoas armazenadas nele e colocar na variável people. Essa abordagem tá longe de ser a ideal porque vamos gastar bastante memória se o arquivo for grande, mas como no nosso caso aqui o objetivo é mostrar como manipular arquivos e construir uma API, eu não estou preocupado com essa otimização. Até porque, num caso real a gente provavelmente utilizaria um banco de dados ao invés de um arquivo como forma de persistência.

O primeiro passo é verificar se o arquivo passado já existe. O método Stat do pacote os nos dá informações sobre o arquivo e caso o arquivo não exista é retornado um erro. Esse erro pode ser usado no método IsNotExist para ver se o arquivo não existe. Se for esse o caso a gente cria o arquivo. Se o erro não for desse tipo então aconteceu algo inesperado que não sabemos como tratar, nesse caso vamos apenas retornar esse erro na criação do serviço.

package person

type Service struct {
    dbFilePath string
    people     domain.People
}

func NewService(dbFilePath string) (Service, error) {
    _, err := os.Stat(dbFilePath)
    if err != nil {
        if os.IsNotExist(err) {
            err = createEmptyFile(dbFilePath)
            if err != nil {
                return Service{}, err
            }
            return Service{
                dbFilePath: dbFilePath,
                people:     domain.People{},
            }, nil
        } else {
            return Service{}, err
        }
    }

    jsonFile, err := os.Open(dbFilePath)
    if err != nil {
        return Service{}, fmt.Errorf("Error trying to open file that contains all people: %s", err.Error())
    }

    jsonFileContentByte, err := ioutil.ReadAll(jsonFile)
    if err != nil {
        return Service{}, fmt.Errorf("Error trying to read people file: %s", err.Error())
    }

    var allPeople domain.People
    json.Unmarshal(jsonFileContentByte, &allPeople)

    return Service{
        dbFilePath: dbFilePath,
        people:     allPeople,
    }, nil
}

A parte de criação de um arquivo vazio eu vou mover para um método separado, nesse método o primeiro passo
será criar uma variável do tipo People que vai ter uma slice vazia de pessoas, já que o arquivo não terá nenhuma pessoa inicialmente. Eu vou codificar essa variável para json utilizando o método Marshal do pacote json. Se der algum erro na codificação um erro será retornado.
Se der tudo certo eu vou salvar esse JSON no arquivo, pra isso vou utilizar a função WriteFile do pacote ioutil. Aqui eu vou passar as permissões do arquivo como 0755, mas na prática acho que poderia ter um pouco menos de permissão nesse caso. Se der erro eu vou retornar erro e se der tudo certo eu retorno nil.

func createEmptyFile(dbFilePath string) error {
    var people domain.People = domain.People{
        People: []domain.Person{},
    }
    peopleJSON, err := json.Marshal(people)
    if err != nil {
        return fmt.Errorf("Error trying to encode people as JSON: %s", err.Error())
    }

    err = ioutil.WriteFile(dbFilePath, peopleJSON, 0755)
    if err != nil {
        return fmt.Errorf("Error trying to writing people file: %s", err.Error())
    }

    return nil
}

O que tá faltando agora é abrir o arquivo caso ele exista e colocar todas as pessoas que tem nesse arquivo dentro da variável people da nossa struct.
Primeiro é preciso abrir o arquivo com a função Open do pacote os.
Em seguida ler o conteúdo desse arquivo com o método ReadAll do pacote ioutil e jogá-lo pra uma nova variável.
E por fim decodificar esse JSON para uma variável da struct people com o json.Unmarshal.
Agora só retornar o serviço criado.

    jsonFile, err := os.Open(dbFilePath)
    if err != nil {
        return Service{}, fmt.Errorf("Error trying to open file that contains all people: %s", err.Error())
    }

    jsonFileContentByte, err := ioutil.ReadAll(jsonFile)
    if err != nil {
        return Service{}, fmt.Errorf("Error trying to read people file: %s", err.Error())
    }

    var allPeople domain.People
    json.Unmarshal(jsonFileContentByte, &allPeople)

    return Service{
        dbFilePath: dbFilePath,
        people:     allPeople,
    }, nil

Pronto, agora o construtor do serviço já está implementado e podemos partir pra implementação do método de criação de pessoa.

func (s *Service) Create(person domain.Person) error {
    // verifica se ja a pessoa ja existe, se já existe retorna erro

    s.people.People = append(s.people.People, person)
    // salvo o arquivo

    return nil
}

Para verificar se a pessoa já existe eu vou criar uma função que vai receber uma pessoa e com base no ID dela eu procuro na nossa slice de pessoas.

func (s Service) exists(person domain.Person) bool {
    for _, currentPerson := range s.people.People {
        if currentPerson.ID == person.ID {
            return true
        }
    }
    return false
}

Pronto, agora eu já posso substituir na função de criação de pessoa a parte que tá com comentário fazendo essa verificação.

func (s *Service) Create(person domain.Person) error {
    if s.exists(person) {
        return fmt.Errorf("There is already a person with this ID registered")
    }

    s.people.People = append(s.people.People, person)

    // salvar arquivo

    return nil
}

Por fim, basta criar uma função pra salvar o arquivo e chamar ela no lugar do comentário. Essa parte de salvar eu vou extrair pra uma função porque vou precisar na hora de implementar os outros métodos do CRUD.

func (s *Service) Create(person domain.Person) error {
    if s.exists(person) {
        return fmt.Errorf("There is already a person with this ID registered")
    }

    s.people.People = append(s.people.People, person)
    err := s.saveFile()
    if err != nil {
        return fmt.Errorf("Error trying to add Person to file: %s", err.Error())
    }

    return nil
}

func (s Service) saveFile() error {
    allPeopleJSON, err := json.Marshal(s.people)
    if err != nil {
        return fmt.Errorf("Error trying to encode people as JSON: %s", err.Error())
    }
    return ioutil.WriteFile(s.dbFilePath, allPeopleJSON, 0755)
}

Pronto. A parte do serviço agora tá pronta.
Agora falta apenas criar esse serviço na função main e utilizar na nossa função que é chamada na rota de criação de pessoa.

package main

import (
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/brenoassp/api-crud-salvando-arquivo/domain"
    "github.com/brenoassp/api-crud-salvando-arquivo/domain/person"
)

func main() {
    personService, err := person.NewService("person.json")
    if err != nil {
        fmt.Printf("Error trying to creating personService: %s\n", err.Error())
    }

    http.HandleFunc("/person/", func(w http.ResponseWriter, r *http.Request) {
        if r.Method == "POST" {
            var person domain.Person
            err := json.NewDecoder(r.Body).Decode(&person)
            if err != nil {
                fmt.Printf("Error trying to decode body. Body should be a json. Error: %s\n", err.Error())
                http.Error(w, "Error trying to create person", http.StatusBadRequest)
                return
            }
            if person.ID <= 0 {
                http.Error(w, "person ID should be a positive integer", http.StatusBadRequest)
                return
            }

            err = personService.Create(person)
            if err != nil {
                fmt.Printf("Error trying to create person: %s\n", err.Error())
                http.Error(w, "Error trying to create person", http.StatusInternalServerError)
                return
            }
            w.WriteHeader(http.StatusCreated)
            return
        }
    })

    http.ListenAndServe(":8080", nil)
}

Rota de atualização de pessoas (PUT /person/)

A rota de atualização de pessoas é, de certa forma, similar à rota de criação de pessoas.
Ela também receberá como payload as mesmas informações da pessoa, com a única diferença de que
ao invés de criar a pessoa, ela utilizará o ID fornecido para buscar a pessoa que precisa ser atualizada
no nosso arquivo. Caso não exista nenhuma pessoa com o ID fornecido, é preciso retornar um erro.

O primeiro passo é criar o código para tratar o método PUT no arquivo main.go que ficará quase igual
ao código de criação de pessoa, como pode ser visto abaixo:

if r.Method == "PUT" {
    var person domain.Person
    err := json.NewDecoder(r.Body).Decode(&person)
    if err != nil {
        fmt.Printf("Error trying to decode body. Body should be a json. Error: %s\n", err.Error())
        http.Error(w, "Error trying to update person", http.StatusBadRequest)
        return
    }
    if person.ID <= 0 {
        http.Error(w, "person ID should be a positive integer", http.StatusBadRequest)
        return
    }

    err = personService.Update(person)
    if err != nil {
        fmt.Printf("Error trying to update person: %s\n", err.Error())
        http.Error(w, "Error trying to update person", http.StatusInternalServerError)
        return
    }
    w.WriteHeader(http.StatusOK)
    return
}

Em seguida, é preciso criar o método responsável pela atualizar da pessoa no serviço. Antes de fazer a atualização
é preciso verificar se existe uma pessoa com o ID fornecido para fazer a atualização, caso contrário um erro é gerado.
Se o registro foi encontrado, basta atualizar a slice de pessoas e salvar o arquivo.
Um ponto importante aqui é a necessidade de utilizar ponteiro na assinatura do método pois estamos alterando a slice,
caso contrário iríamos estar alterando a cópia e as futuras chamadas de métodos do serviço utilizaria dados desatualizados com a
realidade do nosso arquivo.

func (s *Service) Update(person domain.Person) error {
    var indexToUpdate int = -1
    for index, currentPerson := range s.people.People {
        if currentPerson.ID == person.ID {
            indexToUpdate = index
            break
        }
    }
    if indexToUpdate < 0 {
        return fmt.Errorf("There is no person with the given ID to be updated")
    }

    s.people.People[indexToUpdate] = person
    return s.saveFile()
}

Rota de listagem de pessoas (GET /person/ e GET /person/{id})

O primeiro passo a fazer na rota de listagem de pessoas é a distinção entre
a rota de listagem de uma única pessoa e a rota de listagem de todas as pessoas
do nosso arquivo. Para isso, vamos utilizar o método TrimPrefix passando o
que veio no PATH da URL e o prefixo que queremos excluir /person/, com isso
teremos dois possíveis resultados:

1 - a string vazia "" se não tiver nada após o prefixo.

2 - uma string com o conteúdo contido após a string /person/.

No primeiro caso significa que precisamos retornar todas as pessoas.

Já no segundo precisamos verificar se o conteúdo é um ID válido e, caso for, buscar a pessoa
que possui esse ID no nosso arquivo. Primeiro tentamos converter para inteiro essa string com
o método Atoi do pacote strconv, se der errado então já sabemos que não é um ID válido e
podemos responder com um erro. Caso a conversão aconteça com sucesso, fazemos a validação se
o ID fornecido é um número inteiro positivo. Por fim, se passar em todas as validações,
estamos aptos a buscar a pessoa com o ID fornecido.

if r.Method == "GET" {
    path := strings.TrimPrefix(r.URL.Path, "/person/")
    if path == "" {
        // list all people
        w.WriteHeader(http.StatusOK)
        w.Header().Set("Content-Type", "application/json")
        err = json.NewEncoder(w).Encode(personService.List())
        if err != nil {
            http.Error(w, "Error trying to list people", http.StatusInternalServerError)
            return
        }
    } else {
        personID, err := strconv.Atoi(path)
        if err != nil {
            http.Error(w, "Invalid id given. person ID must be an integer", http.StatusBadRequest)
            return
        }
        person, err := personService.GetByID(personID)
        if err != nil {
            http.Error(w, err.Error(), http.StatusNotFound)
            return
        }
        w.WriteHeader(http.StatusOK)
        w.Header().Set("Content-Type", "application/json")
        err = json.NewEncoder(w).Encode(person)
        if err != nil {
            http.Error(w, "Error trying to get person", http.StatusInternalServerError)
            return
        }
    }
    return
}

No nosso serviço nós teremos duas funções diferentes, uma para cada um dos cenários acima.
No caso de não ser passado nenhum ID, iremos listar todas as pessoas do nosso arquivo. Como
o código que fizemos foi feito de tal forma a deixar sempre a slice do serviço atualizada
com o nosso arquivo, basta retornar o conteúdo dessa slice quando quisermos saber quais
são as pessoas presentes no arquivo.

Já no caso de retornar uma pessoa com base no ID, é preciso buscar na slice se existe
alguma pessoa com o ID fornecido e retorná-la caso a encontre. Se não for o caso, basta
retornar um erro de Pessoa não encontrada.

func (s Service) List() domain.People {
    return s.people
}

func (s Service) GetByID(personID int) (domain.Person, error) {
    for _, currentPerson := range s.people.People {
        if currentPerson.ID == personID {
            return currentPerson, nil
        }
    }
    return domain.Person{}, fmt.Errorf("Person not found")
}

Rota de deleção de pessoas (DELETE /person/{id})

Para a rota de deleção de pessoas iremos exigir que um ID seja passado na URL para
identificar qual a pessoa que precisará ser deletada. Com base nesse ID, iremos
procurar a pessoa no nosso arquivo para deletá-la caso exista. A validação do ID
é feita da mesma forma que foi feita na rota de listagem de pessoas.

if r.Method == "DELETE" {
    path := strings.TrimPrefix(r.URL.Path, "/person/")
    if path == "" {
        http.Error(w, "ID is required to delete a person", http.StatusBadRequest)
        return
    } else {
        personID, err := strconv.Atoi(path)
        if err != nil {
            http.Error(w, "Invalid id given. person ID must be an integer", http.StatusBadRequest)
            return
        }
        err = personService.DeleteByID(personID)
        if err != nil {
            fmt.Printf("Error trying to delete person: %s\n", err.Error())
            http.Error(w, "Error trying to delete person", http.StatusInternalServerError)
            return
        }
        w.WriteHeader(http.StatusOK)
    }
    return
}

Será necessário criar o método DeleteByID no serviço para deletar a pessoa com o ID passado.
Assim como no método de Update, é necessário utilizar o ponteiro na assinatura do método para
realizar a alteração da slice original.

O primeiro passo é pesquisar na slice se existe uma pessoa com o ID fornecido, caso não exista,
um erro de pessoa não encontrada deve ser retornado. Caso a pessoa seja encontrada, criamos uma
nova slice que não contenha a pessoa que deve ser deletada e a armazenamos na variável people do
nosso serviço. Por fim, atualizamos nosso arquivo com o conteúdo novo dessa variável com o método
saveFile().

func (s *Service) DeleteByID(personID int) error {
    var indexToRemove int = -1
    for index, currentPerson := range s.people.People {
        if currentPerson.ID == personID {
            indexToRemove = index
            break
        }
    }
    if indexToRemove < 0 {
        return fmt.Errorf("There is no person with the provided ID")
    }

    s.people.People = append(
        s.people.People[:indexToRemove],
        s.people.People[indexToRemove+1:]...,
    )

    return s.saveFile()
}

Concorrência em Go

Breno Almeida — Wed, 20 Oct 2021 01:15:02 +0000

Concorrência em Go

Em Go é possível fazer programas que utilizam de concorrência para melhorar o seu desempenho. A concorrência consiste em executar múltiplas funções independentes ao mesmo tempo para tentar otimizar a utilização de recursos e diminuir o tempo gasto com processamento.

Suponhamos que temos uma API que faz duas requisições para APIs de terceiros e cada uma delas demore 1 segundo. Em um código sequencial sem concorrência, nossa API demoraria no mínimo 2 segundos para responder. Caso as requisições para essas duas APIs sejam independentes, é possível fazer essas chamadas ao mesmo tempo. Essa abordagem poderia diminuir em 50% o tempo de resposta da nossa API somente com essa simples alteração para utilizar concorrência.

Sem concorrência

Abaixo vemos a imagem que representa o fluxo sem concorrência onde as requisições para serviços externos são feitas em sequência.

Código sem concorrência

package main

import (
    "log"
    "time"
)

func main() {
    log.Println("inicio")
    log.Println(requestApiTerceiros1())
    log.Println(requestApiTerceiros2())
    log.Println("fim")
}

func requestApiTerceiros1() string {
    time.Sleep(1 * time.Second)
    return "resposta api terceiros 1"
}

func requestApiTerceiros2() string {
    time.Sleep(1 * time.Second)
    return "resposta api terceiros 2"
}

Resultado da execução do código

go run main.go
2021/10/11 16:59:35 inicio
2021/10/11 16:59:36 resposta api terceiros 1
2021/10/11 16:59:37 resposta api terceiros 2
2021/10/11 16:59:37 fim

Com concorrência

Ao utilizar concorrência ambas as requisições podem ser feitas ao mesmo tempo para diminuir o tempo como mostra o fluxo da imagem abaixo.

Código com concorrência

package main

import (
    "log"
    "time"
)

func main() {
    log.Println("inicio")
    go requestApiTerceiros1()
    go requestApiTerceiros2()
    time.Sleep(5 * time.Second)
}

func requestApiTerceiros1() {
    time.Sleep(1 * time.Second)
    log.Println("resposta api terceiros 1")
}

func requestApiTerceiros2() {
    time.Sleep(1 * time.Second)
    log.Println("resposta api terceiros 2")
}

Resultado da execução do código

go run main2.go
2021/10/11 17:01:17 inicio
2021/10/11 17:01:18 resposta api terceiros 2
2021/10/11 17:01:18 resposta api terceiros 1

Em suma, podemos ver que conseguimos otimizar nosso código usando concorrência. Desse modo, é importante saber como trabalhar com concorrência para ter a habilidade de fazer o uso dessa característica da linguagem quando for apropriado.

É importante conhecer alguns conceitos da linguagem para trabalhar bem com concorrência, são eles:

Go Routines
Channels
WaitGroup

Go Routines

Uma Go routine é uma thread leve que é gerenciada pelo Go e é utilizada para rodar algum código específico que esteja dentro de uma função.

Não é preciso ter nenhuma característica específica para conseguir executar uma função dentro de uma Go Routine, basta utilizar a palavra chamada go antes da chamada dessa função.

Chamada de função normal

func main(){
    sayHi(1)
}

func sayHi(n int){
    fmt.Printf("hi %d\n", n)
}

Chamada de função com Go Routine

func main(){
    go sayHi(1)
}

Ao executar ambos os códigos é possível notar que na chamada normal de função é exibido na tela o texto normalmente, enquanto que ao chamar utilizando Go Routine o texto não é exibido.

O motivo de isso acontecer é porque esse código executa a função sayHi em uma thread separada e não fica esperando a finalização dessa thread. Como não existe mais nenhum código após a criação dessa Go Routine então o programa é finalizado sem nunca ter o retorno da função. Um jeito simples de resolver isso é adicionar um tempo de espera no código da seguinte forma:

func main(){
    go sayHi(1)
    time.Sleep(1 * time.Second)
}

Apesar dessa abordagem resolver o problema, ela está longe de ser a ideal pois nunca saberemos exatamente o tempo necessário para uma função ser executada e dessa forma estamos adicionando atraso no nosso código.

Esse exemplo acima foi feito apenas para entender a sintaxe utilizada para executar funções dentro de Go Routines e mostrar que o código não aguarda a execução dessas funções antes de continuar seu fluxo normal. Para o gerenciamento correto de Go Routines o Go possui mecanismos próprios para isso como Channel e WaitGroup.

Channels

Channel é uma maneira que o Go possui de permitir a comunicação entre diferentes partes do código. Um dos cenários possíveis para se utilizar channels é para a comunicação entre Go Routines.

Para criar um novo channel basta criar uma nova variável do tipo chan, por exemplo:

var out chan string // valor default é nil
out := make(chan string, 1) // cria um channel vazio do tipo string que é capaz de armazenar 1 elemento

Ao criar uma variável do tipo channel o seu valor default é nil. Para inicializar o channel como sendo um channel vazio é preciso utilizar a função make, assim como é feito com variáveis do tipo slice e map.

O operador utilizado para inserir ou ler dados de um channel é o operador <-, com o sentido dessa seta apontando para onde o dado está indo.

Código

out := make(chan string, 1)
out <- "myString" //Adiciona uma string no channel criado
fmt.Println(<-out) //Imprime string armazenada no channel criado

Resultado

myString

Um fato interessante sobre como channels funcionam é que ao tentar ler o conteúdo de um channel vazio ou ao tentar escrever um dado em um channel sem espaço o código pára e fica esperando até ter espaço suficiente no channel. Podemos ver esse comportamento ao usar o exemplo acima só que removendo a escrita no channel:

Código

out := make(chan string, 1)
fmt.Println(<-out) //Imprime string armazenada no channel criado

Resultado

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
        /home/breno/programming/tmp/main.go:10 +0x39
exit status 2

A mensagem de erro mostra que ocorreu um deadlock pois não existe nenhuma Go Routine sendo executada além da função main e ela está parada esperando algo ser escrito no channel. O deadlock ocorre porque nunca será escrito algo no channel já que o main está parado tentando ler do canal e não existe nenhuma outra Go Routine sendo executada. Se criarmos uma Go Routine que não faz nada e que fique rodando direto, o erro não ocorre mais. Veja o exemplo abaixo:
Código

func main() {
    out := make(chan string, 1)
    go func() {
        for {

        }
    }()
    fmt.Print(<-out)
}

Resultado

Nada impresso na tela

Se for parar pra pensar, essa abordagem para solucionar o erro de deadlock nesse exemplo não resolve nenhum problema de fato pois esse problema de deadlock só existe porque estamos usando channel em um local que deveríamos estar usando uma simples variável do tipo string. No entanto, haverá casos onde essa tática será útil como quando formos construir alguma pipeline para execução de código concorrente.

Compartilhando channels entre Go Routines

É possível compartilhar um channel entre várias Go Routines que estejam sendo executadas ao mesmo tempo como mostra o exemplo abaixo. Nesse código quatro diferentes rotinas são executadas ao mesmo tempo e a medida que dados são escritos no channel eles são mostrados na tela.

func main() {
    out := make(chan string)
    go sayHi(1, out)
    go sayHi(2, out)
    go sayHi(3, out)
    go sayHi(4, out)

    for i := 1; i <= 4; i++ {
        fmt.Println(<-out)
    }
}

func sayHi(n int, out chan string) {
    out <- fmt.Sprintf("hi %d", n)
}

É interessante notar que o mesmo channel está sendo usado nas quatro Go Routines criadas. O channel foi criado com a função make sem passar o tamanho como segundo argumento, isso indica que o channel criado não possui buffer. Na prática isso indica que um dado só poderá fluir nesse canal quando tiver uma parte do código lendo e outra escrevendo pois não existe nenhum local para armazenar esse valor.

No exemplo acima, assim que uma Go Routine escrever no canal o channel será bloqueado para escrita até esse valor for removido do canal pela função Println, sendo assim não existe uma concorrência de fato nesse código já que as Go Routines criadas estão sempre aguardando a liberação do canal.

Também nesse exemplo, o programa não garante ordem de execução das Go Routines visto que são threads de execução independentes.

WaitGroup

Um WaitGroup permite parar a execução do código e aguardar até que todas as Go Routines escolhidas terminem sua execução. Dessa forma, é possível fazer código que depende do resultado de múltiplas Go Routines. Veja abaixo um exemplo de uso de WaitGroup para aguardar a execução da execução de 4 Go Routines.

package main

import (
    "fmt"
    "sync"
)

func main() {
    // Cria uma variável do tipo WaitGroup
    var wg sync.WaitGroup

    for i := 1; i < 5; i++ {
        // Adiciona 1 ao contador de Go Routines do WaitGroup wg
        wg.Add(1)

        // Cria Go Routine passando o WaitGroup criado como parâmetro
        go sayHi(&wg, i)
    }

    // Aguarda até o contador de Go Routines do WaitGroup wg chegar a zero
    wg.Wait()

    fmt.Println("Fim")
}

func sayHi(wg *sync.WaitGroup, n int) {
    fmt.Println(n)

    // Decrementa o contador do WaitGroup wg
    wg.Done()
}

Select

Select é uma forma de escolher qual dos caminhos o código irá seguir, similar ao funcionamento do switch, mas nesse caso o select é utilizado com Channels. Caso o select não possua um caminho default o código fica parado até que algum dos casos sejam satisfeitos. Veja abaixo um exemplo funcional e outro onde há deadlock.

Código funcional

package main

import "fmt"

func main() {
    var c1, c2 chan int
    select {
    case <-c1:
    case <-c2:
    default:
        fmt.Println("Fim")
    }
}

Código com deadlock

package main

func main() {
    var c1, c2 chan int
    select {
    case <-c1:
    case <-c2:
    }
}

Resultado da execução desse código com deadlock

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [select]:
main.main()
        /home/breno/study-programming/go/select.go:5 +0x45
exit status 2

Introdução à Linguagem Go

Breno Almeida — Mon, 18 Oct 2021 18:19:18 +0000

Por quê usar Go?

A linguagem Go possui vários pontos positivos como performance, legibilidade e simplicidade.

Performance

Linguagem com tipagem estática com boa performance se assemelhando à linguagens como C++.
Compilação rápida.
Suporte a concorrência.

Legibilidade

Uma única forma de fazer as coisas garante facilidade de leitura e escrita do código. Por exemplo, o Javascript possui a função map, já no Go precisamos utilizar o for para fazer algo similar. Veja abaixo o exemplo comparando a implementação com o for no Go e utilizando o map via Javascript.

// Javascript
numbers = [4, 9, 16, 25];
result = numbers.map(Math.sqrt);

// Go
package main

import (
    "fmt"
    "math"
)

func main() {
    numbers := []int{4, 9, 16, 25}
    result := []float64{}
    for _, value := range numbers {
        result = append(result, math.Sqrt(float64(value)))
    }
    fmt.Println(result)
}

A princípio a implementação em Go pode parecer mais complicada por exigir mais linhas de código, mas na prática é mais simples de lidar com o código pelos seguintes motivos:

1 - Por existir apenas essa forma de implementação o desenvolvedor não precisa pensar qual das alternativas disponíveis ele irá utilizar naquele momento. Isso pode parecer algo irrelevante, mas não prática não é. Ao ter várias features diferentes que podem ser utilizadas para o mesmo propósito, o desenvolvedor precisa saber sobre a implementação interna dessas features para escolher qual delas usar, caso contrário ele pode acabar optando por uma solução menos eficiente e futuramente colher os frutos dessa decisão com problemas de performance. Além disso, outros desenvolvedores que trabalharão futuramente no código precisarão desse conhecimento e ao lerem o código "perderão tempo" pensando o porquê da implementação ter sido feita daquela forma e não de outra.

2 - Em muito dos casos, o desenvolvedor não terá o conhecimento da estrutura interna da linguagem e acabará usando uma feature com performance pior sem necessidade.

Simplicidade

Gerenciamento de memória com garbage collector. Nesse caso o desenvolvedor não precisa se preocupar com gerenciamento de memória manual visto que o garbage collector roda em background e já faz esse trabalho.

Geração de documentação automática com godoc.

Por quê Go foi criado?

Go foi criado com o objetivo de ter desempenho similar ao de linguagens estaticamente tipadas como C++, mas sem a complexidade envolvida durante o desenvolvimento do código. Nesse sentido, o objetivo era ter a facilidade de escrita de código de uma linguagem dinâmica como Python. Desse modo, o melhor dos dois mundos seria extraído, a produtividade do Python com a performance do C++.

Além disso, Go foi criado com concorrência em mente, diferente de linguagens como C++ e Java que introduziram essa característica ao longo do tempo visto que são linguagens bem mais antigas.

Por fim, os criadores da linguagem Go utilizaram a experiência de muitos anos na área de desenvolvimento e todas as suas dores desse período para fazer uma linguagem que resolvesse vários problemas existentes de forma elegante e simples.

Casos de Uso

CLI
Scripts
Desenvolvimento Web
Serviços

O que é preciso saber para fazer o primeiro programa em Go

O primeiro passo é instalar o Go que pode ser baixado no site https://golang.org/

Instalação no Windows
Para instalar o Go no windows basta baixar o arquivo executável contido no site oficial e seguir o passo a passo de instalação ao abrí-lo. Ao finalizar a instalação o caminho do Go já estará configurado na variável de ambiente e todos os comandos já poderão ser usados. Vale lembrar que é preciso reabrir janelas do prompt para a configuração surtir efeito.

Instalação no Linux
No caso do Linux a instalação nada mais é do que baixar um arquivo compactado que contém uma pasta com todos os arquivos necessários para o Go funcionar. Com esse arquivo em mãos, basta descompactá-lo num diretório específico do sistema como o /user/local/go e adicionar na variável de ambiente PATH o caminho da pasta que contém os binários do Go. Em resumo o passo a passo é o seguinte (considerando a versão do Go 1.17.2):

# Descompactando o arquivo
tar -C /usr/local -xzf go1.17.2.linux-amd64.tar.gz

# adicionar no ~/.bashrc ou ~/.zshrc ou qualquer outro arquivo de configuração do shell que você esteja usando
export PATH=$PATH:/usr/local/go/bin

Após a instalação bem sucedida basta verificar se tudo está ok executando o comando abaixo para verificar se a versão instalada será mostrada.

go version

Agora que temos o Go instalado já conseguimos compilar e executar códigos em Go. Crie um arquivo com nome main.go com o seguinte conteúdo:

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello World!")
}

Esse programa imprime na tela as palavras Hello World utilizando para isso a função Println do pacote fmt que faz parte das bibliotecas padrão do Go.

fmt é o nome do pacote. Pacotes possuem todos os caracteres minúsculos.
Println é o nome da função e nesse caso ela começa com letra maiúscula e isso não ocorre por acaso. Todas as partes públicas dentro de um pacote, ou seja, que podem ser acessadas de fora desse pacote, devem iniciar com letra maíuscula.

Em seguida basta executar o código com o comando:

go run main.go

Lembrando que Go é uma linguagem compilada, o comando go run compila e executa o programa feito. Caso queira criar um binário desse programa basta utilizar o go build, por exemplo:

go build main.go

Estruturas básicas da linguagem

Declarando variáveis

Declarando variáveis sem inicializá-las

var x string // valor default string vazia ""
var y int // valor default 0
var z []string // valor default nil

Declarando variáveis e inicializando ao mesmo tempo

x := "MinhaString"
y := 10
z := []string{"s1","s2","s3"}

Loop

for {
    // loop infinito
}

x := 0
for x < 10 {
    x += 1
}

for i := 0; i < 10; i++ {

}

Structs

type Person struct {
    Name string
    Age int
}

Estrutura condicional

if x < 10 {
    fmt.Println(x)
}

Funções

func add(x int, y int) int {
    return x + y
}

Criando uma API simples

Diferentemente de outras linguagens como PHP, Java e Python, o Go não precisa de um servidor web como Apache ou Nginx para funcionar. O servidor é criado pelo próprio código do Go como mostrado no exemplo abaixo. Esse código é funcional e responde à requisições na url localhost:8080/ping.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/ping", ping)
    http.ListenAndServe(":8080", nil)
}

func ping(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "pong\n")
}

Gerenciamento de dependência em Go (Go Modules)

Breno Almeida — Sun, 26 Sep 2021 15:45:57 +0000

Go Modules

Cada linguagem de programação possui uma maneira de instalar dependências/bibliotecas e gerenciar as versões de cada uma dessas dependências no projeto. A maneira com que o Go gerencia suas dependências desde a versão 1.11 é utilizando Módulos (Go Modules). Em versões passadas do Go as dependências eram gerenciadas com ferramentas auxiliares como o dep e é possível migrar para o Go Modules, mais informações sobre como fazer isso pode ser vistas na wiki do Go.

Basicamente ao iniciar um novo projeto em Go utilizando na raíz do projeto o comando go mod init meu-modulo é criado um novo módulo. Nesse comando o meu-modulo pode ter o caminho completo para um repositório de um sistema de controle de versionamento, por exemplo , github.com/brenoassp/meu-modulo.

O comando go mod init gera um arquivo com nomego.modque contém o nome do módulo criado junto com a versão do Go utilizada, como mostrado abaixo:

module github.com/brenoassp/meu-modulo

go 1.17

A medida que novos pacotes forem sendo adicionados no projeto esse arquivo vai sendo modificado com os pacotes instalados, por exemplo, podemos instalar um novo pacote com o comando a seguir:

go get -u github.com/valyala/fasthttp

Após isso o arquivo go.mod terá o seguinte conteúdo:

module github.com/brenoassp/meu-modulo

go 1.17

require (
    github.com/andybalholm/brotli v1.0.3 // indirect
    github.com/klauspost/compress v1.13.6 // indirect
    github.com/valyala/bytebufferpool v1.0.0 // indirect
    github.com/valyala/fasthttp v1.30.0 // indirect
)

Apesar de ter instalado apenas uma dependência, mais de um pacote foi instalado, isso acontece porque geralmente todo pacote que instalamos depende também de outros pacotes. Como esses pacotes internos das dependências que instalamos não são utilizados diretamente por nós eles são marcados como dependência indireta com o comentário indirect depois da versão. Nesse caso específico, até mesmo a dependência do fasthttp que instalamos está sendo marcada como dependência indireta pois não estamos usando ela em nenhum lugar no código, apesar de ter sido instalada.

Ao criar um código que utilize o fasthttp como o código abaixo, ele deixará de ser uma dependência indireta no nosso projeto.

package main

import (
    "fmt"

    "github.com/valyala/fasthttp"
)

func main() {
    fasthttp.ListenAndServe(":8080", func(ctx *fasthttp.RequestCtx) {
        fmt.Fprintln(ctx, "Hello, world")
    })
}

O comando go mod tidy é responsável por atualizar o go.mod seja atualizando ou removendo dependências. Ao executar esse comando o go.modpassa a ter o seguinte conteúdo:

module github.com/brenoassp/meu-modulo

go 1.17

require github.com/valyala/fasthttp v1.30.0

require (
    github.com/andybalholm/brotli v1.0.3 // indirect
    github.com/klauspost/compress v1.13.6 // indirect
    github.com/valyala/bytebufferpool v1.0.0 // indirect
)

Ou seja, o fasthttp deixa de ser uma dependência indireta para ser uma dependência direta já que está sendo utilizado. Se removermos o código que utiliza o fasthttp e executarmos o go mod tidy novamente ele removerá do go.mod as dependências pois elas não estão sendo utilizadas em nenhum momento.

Além do go.mod existe também o arquivo go.sum que contém todas as dependências junto com a hash que representa o conteúdo do pacote. Isso serve pra garantir que os pacotes baixados futuramente no projeto são iguais aos pacotes baixados no momento em que a dependência foi adicionada no projeto. Ambos os arquivos devem ser versionados e é recomendável usar o comando go mod tidy regularmente para manter esses arquivos atualizados somente com as dependências que estão realmente sendo utilizadas.

Não é necessário ficar utilizando o go get para adicionar todos os pacotes que serão utilizados pois ao compilar o projeto (go build) ou executar os testes (go test) as dependências serão baixadas automaticamente com base nas importações feitas no início do aquivo com extensão .go. A única alteração que não é feita automaticamente nesses casos é a verificação se alguma dependência existente no arquivo go.mod e go.sum já não é mais necessária por não estar sendo utilizada e, consequentemente, não é removida. Nesse caso é preciso executar um go mod tidy que removerá esses pacotes não utilizados.

Diferentemente de vários gerenciadores de dependências de outras linguagens, o Go Module não instala as dependências do projeto em uma pasta contida na raiz do repositório. O que controla onde será salvo as bibliotecas são as variáveis de ambiente GOPATH e GOBIN. Caso essas variáveis não existirem, os pacotes são salvos em /home/[user]/go.

GOBIN: indica onde serão instalados os binários.
GOPATH: indica onde serão instalados os pacotes. Se essa variável existir os binários são instalados na pasta bin do primeiro diretório da lista de diretórios existentes nessa variável.

Os módulos são versionados utilizando a especificação de versionamento semântico SemVer. Em resumo, essa especificação diz que a nomenclatura do pacote deve ser do tipo X.Y.Z, onde:

X: Número que representa a versão principal do pacote (Major Version). É incrementado somente quando há quebra de compatibilidade na API.

Y: Número que representa a versão secundária (Minor Version). É incrementada quando há adição de novas funcionalidades, mas sem quebrar a compatibilidade com a versão anterior.

Z: Número que representa a versão de correção (Patch Version). É incrementada quando é realizado alguma correção de bug.

Acredito que o mais importante a se saber é que, por padrão, o Go não atualiza sozinho a major version dos pacotes ao utilizar comandos como got get -u modulo, ele apenas atualiza para a versão mais recente da minor version e patch version. Quando existe uma atualização com quebra de compatibilidade em algum módulo é possível ver de forma explícita pois é necessário indicar essa versão ao importar o pacote dentro do código da seguinte forma:

import "github.com/brenoassp/meu-modulo/v2"

De qualquer forma, sempre que for atualizada alguma biblioteca no projeto é interessante rodar os testes do projeto para garantir que nada foi quebrado, independentemente da atualização que foi feita.

TL;DR;

Comando	Exemplo	Descrição
go mod init [path]	go mod init github.com/brenoassp/meu-modulo	Inicializa um novo módulo no diretório corrente criando um arquivo `go.mod` nesse local
go mod tidy	-	Atualiza o `go.mod` seja adicionando dependências que estão faltando ou removendo as que não estão sendo utilizadas
go get modulo	go get https://github.com/valyala/fasthttp	Baixa ou atualiza o pacote fasthttp na versão mais atualizada
go get -u modulo	go get -u https://github.com/valyala/fasthttp	Atualiza tanto o pacote fasthttp e as suas dependências para a versão mais atualizada
go mod download	-	Baixa para o cache local todos os módulos existentes no arquivo `go.mod`