Arquitetura Limpa em Go – Parte 8 – APIs RESTful

Saudações queridos devs, neste post vamos falar brevemente de APIs RESTful dentro do contexto da Arquitetura Limpa.

Fundamentos da Arquitetura Limpa em APIs RESTful

Conforme estamos repetindo ao longo dessa série de posts, a Arquitetura Limpa nos orienta a separar claramente as preocupações do nosso sistema, promovendo uma estrutura que é ao mesmo tempo robusta, flexível e escalável. Ao aplicar esses princípios no desenvolvimento de APIs RESTful em Go, estamos nos comprometendo com a qualidade e a longevidade do nosso software.

Começando com as Entidades

Nossas entidades são o coração da aplicação. São os objetos de domínio que definem a estrutura de dados e as regras de negócio essenciais.

// user.go
package entities

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

Estruturando as Camadas

A separação em camadas permite que cada parte da nossa aplicação tenha responsabilidades bem definidas, facilitando tanto o desenvolvimento quanto a manutenção.

• Camada de Repositório: Abstrai a lógica de acesso aos dados.
• Camada de Caso de Uso (Serviço): Contém a lógica de negócio.
• Camada de Controlador: Interage com o mundo externo (HTTP).

Repository

// userRepository.go
package repositories

import "context"

type UserRepository interface {
    FindByID(ctx context.Context, id string) (*User, error)
}

Service

// userService.go
package services

import (
    "context"
    "yourapp/entities"
    "yourapp/repositories"
)

type UserService interface {
    GetUser(ctx context.Context, id string) (*entities.User, error)
}

type userService struct {
    repo repositories.UserRepository
}

func NewUserService(repo repositories.UserRepository) UserService {
    return &userService{repo}
}

func (s *userService) GetUser(ctx context.Context, id string) (*entities.User, error) {
    return s.repo.FindByID(ctx, id)
}

Controller

// userController.go
package controllers

import (
    "encoding/json"
    "net/http"
    "yourapp/services"
)

type UserController struct {
    userService services.UserService
}

func NewUserController(userService services.UserService) *UserController {
    return &UserController{userService}
}

func (c *UserController) GetUser(w http.ResponseWriter, r *http.Request) {
    id := r.URL.Query().Get("id") // Supondo uma rota simples
    user, err := c.userService.GetUser(r.Context(), id)
    if err != nil {
        // Tratar erro
        return
    }

    json.NewEncoder(w).Encode(user)
}

Implementando a Comunicação RESTful

Agora que temos nossa estrutura básica, vamos detalhar como as requisições e respostas são tratadas em uma API RESTful.

// main.go
package main

import (
    "net/http"
    "yourapp/controllers"
    "yourapp/repositories"
    "yourapp/services"
)

func main() {
    userRepo := repositories.NewUserRepository() // Implementação específica
    userService := services.NewUserService(userRepo)
    userController := controllers.NewUserController(userService)

    http.HandleFunc("/users", userController.GetUser)
    http.ListenAndServe(":8080", nil)
}

Melhores Práticas e Padrões Avançados

Desenvolver APIs RESTful seguindo a Arquitetura Limpa vai além de apenas estruturar o código. Envolve seguir as melhores práticas REST, como o uso correto dos métodos HTTP, a definição clara dos endpoints, a implementação de autenticação e autorização, e o tratamento adequado de erros.

• Autenticação e Segurança: Utilize tokens JWT ou OAuth para proteger suas APIs.
• Versionamento: Versione suas APIs para facilitar a manutenção e evolução.
• Documentação: Use ferramentas como Swagger ou Postman para documentar suas APIs.

Conclusão

A criação de APIs RESTful em Go, orientadas pelos princípios da Arquitetura Limpa nos força a pensar cuidadosamente sobre a estrutura do nosso código, as dependências entre os componentes e como expomos nossa lógica de negócio ao mundo.

No próximo post vamos falar sobre performance e otimização de uma aplicação no contexto da Arquitetura Limpa.

Let’s code!