O desenvolvimento de APIs em Go tem se tornado cada vez mais popular graças à simplicidade e eficiência que a linguagem oferece. Atualmente, existem diversos packages e frameworks que facilitam a construção de APIs robustas e performáticas.

Neste post, vamos explorar o que é o framework Echo, como ele se compara com outros packages e frameworks populares, e como implementar um CRUD completo utilizando essa poderosa ferramenta.

O que é o Echo Framework

Como o próprio nome já diz, Echo framework é um framework web extensível para a construção de APIs em Go. Criada com foco em simplicidade e eficiência, ele permite que desenvolvedores construam APIs RESTful de maneira rápida e com um código limpo.

Principais características do Echo

• Roteamento eficiente: O Echo utiliza um sistema de roteamento otimizado, permitindo que as requisições sejam tratadas com baixa latência.
• Suporte nativo a middleware: Echo facilita a criação e o uso de middlewares, como autenticação, logging e compressão de respostas.
• Manipulação de erros: O framework oferece um sistema simples e robusto para lidar com erros.
• Suporte a WebSocket: Echo também possui suporte integrado para WebSockets, permitindo aplicações em tempo real.

Comparativo: Echo x Gin x Chi x Fiber

Package	Desempenho	Facilidade de Uso	Extensibilidade	GitHub Stars
Echo	Alta	Fácil	Alta	30.7k
Gin	Alta	Fácil	Média	80.9k
Chi	Média	Média	Alta	19.3k
Fiber	Altíssima	Muito Fácil	Alta	35.5k

O Echo se destaca por oferecer um ótimo equilíbrio entre desempenho, facilidade de uso e extensibilidade. Embora o Gin seja o framework mais popular, o Echo oferece funcionalidades extras, como suporte a WebSocket, que podem ser úteis em determinadas aplicações.

O Chi, que não chega a ser um framework, é mais indicado para projetos que precisam de uma API altamente modular, enquanto o Fiber foca em ser extremamente rápido, inspirado no framework Express do Node.js.

Para saber mais sobre o Fiber, convido a ler o post APIs de alta performance com Fiber.

Implementando uma API com Echo

Agora vamos criar uma API RESTful completa utilizando o Echo. Essa API será um CRUD para gerenciar os usuários de uma aplicação.

Iniciando o projeto

Antes de qualquer outro passo, vamos iniciar um novo projeto com o seguinte comando.

go mod init github.com/aprendagolang/echoapp

Na sequência, utilizando o comando abaixo, adicionaremos o Echo como dependência ao nosso projeto.

go get -u github.com/labstack/echo/v4

Estruturando o Projeto

Para esse “Hello World” diferenciado, vamos criar uma estrutura de pastas bem básica.

project/
├── main.go
├── handlers/
│   └── user.go
└── models/
    └── user.go

Criando o Modelo User

Na pasta models/, crie o arquivo user.go com o seguinte conteúdo:

package models

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

Implementando o Handler

Agora, na pasta handlers/, crie o arquivo user.go. Nele, vamos definir a lógica para cada tipo de request do CRUD.

package handlers

import (
    "fmt"
    "net/http"
    "github.com/labstack/echo/v4"
    "github.com/aprendagolang/echoapp/models"
)

var users = []models.User{}

// Cria um novo usuário
func CreateUser(c echo.Context) error {
    user := new(models.User)
    if err := c.Bind(user); err != nil {
        return err
    }
    user.ID = len(users) + 1
    users = append(users, *user)
    return c.JSON(http.StatusCreated, user)
}

// Retorna todos os usuários
func GetUsers(c echo.Context) error {
    return c.JSON(http.StatusOK, users)
}

// Retorna somente 1 usuário
func GetUser(c echo.Context) error {
    id := c.Param("id")
    for _, user := range users {
        if fmt.Sprintf("%d", user.ID) == id {
            return c.JSON(http.StatusOK, user)
        }
    }
    return c.JSON(http.StatusNotFound, map[string]string{"message": "User not found"})
}

// Atualiza um usuário
func UpdateUser(c echo.Context) error {
    id := c.Param("id")
    updatedUser := new(models.User)
    if err := c.Bind(updatedUser); err != nil {
        return err
    }
    for i, user := range users {
        if fmt.Sprintf("%d", user.ID) == id {
            users[i] = *updatedUser
            return c.JSON(http.StatusOK, updatedUser)
        }
    }
    return c.JSON(http.StatusNotFound, map[string]string{"message": "User not found"})
}

// Deleta um usuário
func DeleteUser(c echo.Context) error {
    id := c.Param("id")
    for i, user := range users {
        if fmt.Sprintf("%d", user.ID) == id {
            users = append(users[:i], users[i+1:]...)
            return c.JSON(http.StatusOK, map[string]string{"message": "User deleted"})
        }
    }
    return c.JSON(http.StatusNotFound, map[string]string{"message": "User not found"})
}

Note que, para facilitar o exemplo, o “banco de dados” escolhido é um simples slice.

Configurando o main.go

Por fim, crie o arquivo main.go na raiz do projeto. Nele, vamos iniciar o servidor do ECHO e configurar cada uma das rotas.

package main

import (
    "github.com/labstack/echo/v4"
    "github.com/aprendagolang/echoapp/handlers"
)

func main() {
    e := echo.New()

    e.POST("/users", handlers.CreateUser)
    e.GET("/users", handlers.GetUsers)
    e.GET("/users/:id", handlers.GetUser)
    e.PUT("/users/:id", handlers.UpdateUser)
    e.DELETE("/users/:id", handlers.DeleteUser)

    e.Start(":8080")
}

Antes de executar o programa, faça um go mod tidy para atualizar os arquivos go.mod e go.sum. Feito isso, execute o comando go run main.go para iniciar a API.

Prós e Contras

Assim como em qualquer decisão técnica, antes de bater o martelo na utilização do Echo, vale verificar todos os prós e contras de se utilizar determinado framework.

Abaixo listo alguns para o Echo:

Prós

• Simplicidade e facilidade de uso
• Suporte a middlewares
• Roteamento eficiente
• Suporte a WebSocket
• Comunidade ativa

Contras

• Mais funcionalidades podem significar uma curva de aprendizado maior
• Pode ser considerado “overkill” para projetos pequenos
• Menor controle granular se comparado ao net/http
• Assinatura dos métodos não segue o padrão oficial do net/http

Além disso, também é muito importante entender a dimensão e complexidade do projeto onde ele será aplicado. Muitas vezes, o que é bom para um projeto pode ser péssimo para outro.

Conclusão

O framework Echo é uma excelente escolha para quem busca construir APIs robustas em Go. Com uma API simples e poderosa, ela permite criar aplicações escaláveis rapidamente.

No entanto, é sempre bom pesar os prós e contras antes de tomar a decisão de qual framework, caso deseje utilizar, será utilizado na construção de uma API. Mesmo que seja investido 2 ou 3 semanas em testes e pesquisas, COM CERTEZA é um tempo muito pequeno quando comparado a refatoração de uma decisão errônea do passado.

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.