DEV Community: José Paulo Marinho

Como criar uma "busca inteligente" para seu Wiki utilizando Go e ElasticSearch

José Paulo Marinho — Wed, 22 Oct 2025 00:28:44 +0000

Hoje em dia, existem diversos motores de busca para diferentes finalidades. Como exemplo: o Google. O Google se destaca com técnicas avançadas de rastreamento, indexação e outras tecnologias que tornam suas buscas extremamente eficientes.

Neste post, vamos aprender a criar uma busca inteligente para o seu repositório Wiki utilizando arquivos Markdown. Não será tão complexo quanto o Google, mas será rápido, útil e bastante eficiente, utilizando o ElasticSearch.

Vamos lá?

Para começarmos, é necessário que os seguintes softwares estejam instalados e em execução no seu sistema:

Go
Elasticsearch

Observação: neste artigo, não abordaremos como instalar ou configurar esses softwares. Assumimos que eles já estão prontos para uso.

Estarei utilizando como repositório o ObsidianNotes - Cycro, um repositório recheado de conhecimento coletado e armazenado em arquivos .md.

Antes de começarmos a implementar, vou explicar como estruturaremos o motor de busca.

Motor de busca

1 - Leitura dos arquivos Markdown: Percorreremos todos os arquivos .md do repositório e extrairemos o conteúdo relevante(título, corpo, tags, etc).
2 - Indexação no ElasticSearch - Cada arquivo será transformado em um documento JSON e enviado ao ElasticSearch, que fará a indexação para permitir buscas rápidas e eficientes.
3 - Busca e retorno dos resultados - Implementaremos uma funcão simples que consulta o ElasticSearch com palavras-chave e retorna os arquivos mais relevantes.

Preparando o ambiente Go

Certifique-se de ter o Golang instalado e execute os seguintes comandos em um diretório de sua escolha:

mkdir go-md-search
cd go-md-search
go mod init go-md-search

Em seguida, vamos instalar o cliente oficial do ElasticSearch para Go:

go get github.com/elastic/go-elasticsearch/v9

Lendo arquivos Markdown

Podemos criar um script simples que percorre uma pasta e lê todos os arquivos .md:

package main

import (
    "fmt"
    "log"
    "os"
    "path/filepath"
)

func main() {
    files, err := filepath.Glob("~/ObsidianNotes/**/*.md") // sua pasta onde os arquivos estão
    if err != nil {
        log.Fatal(err)
    }
    for _, file := range files {
        content, err := os.ReadFile(file)
        if err != nil {
            log.Println("Erro ao ler arquivo:", err)
            continue
        }
        fmt.Println("Arquivo:", file)
        fmt.Println(string(content[:100]), "...")
    }
}

Note que alguns arquivos podem estar vazios de conteúdo. Para ignora-los, podemos tratar facilmente no Go antes de enviar ao ElasticSearch:

package main

import (
    "fmt"
    "log"
    "os"
    "path/filepath"
    "strings"
    "unicode/utf8"
)

func main() {
    files, err := filepath.Glob("~/ObsidianNotes/**/*.md") // sua pasta onde os arquivos estão
    if err != nil {
        log.Fatal(err)
    }

    for _, file := range files {
        content, err := os.ReadFile(file)
        if err != nil {
            log.Printf("Erro ao ler arquivo %s: %v\n", file, err)
            continue
        }

        text := strings.TrimSpace(string(content))

        if len(text) == 0 || !utf8.Valid(content) {
            log.Printf("Ignorando arquivo vazio ou inválido: %s\n", file)
            continue
        }

        clean := strings.ReplaceAll(text, "\x00", "")

        fmt.Printf("Arquivo: %s\n", file)
        fmt.Println(clean[:min(200, len(clean))], "...")
    }
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

Indexando os arquivos no ElasticSearch

Agora que já conseguimos ler e limpar nossos arquivos, o próximo passo é enviar cada documento para o ElasticSearch. Cada arquivo Markdown será representado como um documento JSON, contendo:

Caminho do arquivo
Nome do arquivo
Conteúdo do arquivo

Segue implementação:

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "path/filepath"
    "strings"
    "unicode/utf8"

    elasticsearch8 "github.com/elastic/go-elasticsearch/v9"
)

type MarkdownDoc struct {
    Path    string `json:"path"`
    Name    string `json:"name"`
    Content string `json:"content"`
}

func main() {
    cfg := elasticsearch8.Config{
        Addresses: []string{"http://localhost:9200"},
        Username:  "username",
        Password:  "password",
    }

    es, err := elasticsearch8.NewClient(cfg)

    if err != nil {
        log.Fatal(err)
    }

    res, err := es.Indices.Create("wiki")
    if err != nil {
        log.Fatalf("Erro ao criar índice: %v", err)
    }
    defer res.Body.Close()

    if res.IsError() {
        log.Printf("Aviso: índice 'wiki' pode já existir: %s\n", res.String())
    } else {
        fmt.Println("Índice 'wiki' criado com sucesso.")
    }

    files, err := filepath.Glob("/Users/josepaulomarinho/Documents/estudos/ObsidianNotes/**/**.md")
    if err != nil {
        log.Fatal(err)
    }

    for _, file := range files {
        content, err := os.ReadFile(file)
        if err != nil {
            continue
        }

        text := strings.TrimSpace(string(content))
        if len(text) == 0 || !utf8.Valid(content) {
            continue
        }

        clean := strings.ReplaceAll(text, "\x00", "")

        doc := MarkdownDoc{
            Path:    file,
            Name:    filepath.Base(file),
            Content: clean,
        }

        data, _ := json.Marshal(doc)

        res, err := es.Index("wiki", bytes.NewReader(data))
        if err != nil {
            log.Printf("Erro ao indexar %s: %v\n", file, err)
            continue
        }
        defer res.Body.Close()

        fmt.Println("Indexado:", file)
    }
}

Note que estabelecemos uma conexão utilizando autenticação básica via usuário e senha. Logo após criamos o índice, caso não haja criado, filtramos os arquivos, ignorando os inválidos e indexamos no índice wiki.

Para conferir se o conteúdo foi indexado, execute o seguinte comando com CURL no terminal do seu sistema operacional:

http://localhost:9200/wiki/_search?pretty

Realizando buscas no elasticsearch

Agora que nossos arquivos Markdown foram indexados no índice wiki, podemos testar buscas diretamente pelo conteúdo. O elasticsearch permite consultas poderosas, não apenas por palavras exatas, mas também por relevância e similaridade.

1. Consulta simples por palavra-chave

Podemos criar uma query simples que busca um termo em todos os documentos:

query := map[string]interface{}{
    "query": map[string]interface{}{
        "multi_match": map[string]interface{}{
            "query":  "locks", // termo de busca
            "fields": []string{"content"}, // campos a pesquisar
        },
    },
}

No caso estarei buscando somente pelo conteúdo a palavra locks.

multi_match - permite buscar em vários campos.
query - é o termo que o usuário quer encontrar
fields - especifica quais campos do documento serão pesquisados(title, content, etc).

2. Executando a busca em Go

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "log"

    elasticsearch8 "github.com/elastic/go-elasticsearch/v9"
)

func main() {
    cfg := elasticsearch8.Config{
        Addresses: []string{"http://localhost:9200"},
        Username:  "username",
        Password:  "password",
    }

    es, err := elasticsearch8.NewClient(cfg)

    query := map[string]interface{}{
        "query": map[string]interface{}{
            "multi_match": map[string]interface{}{
                "query":  "locks",
                "fields": []string{"content"},
            },
        },
    }

    var buf bytes.Buffer
    if err := json.NewEncoder(&buf).Encode(query); err != nil {
        log.Fatalf("Erro ao codificar query: %s", err)
    }

    res, err := es.Search(
        es.Search.WithContext(context.Background()),
        es.Search.WithIndex("wiki"),
        es.Search.WithBody(&buf),
        es.Search.WithTrackTotalHits(true),
    )
    if err != nil {
        log.Fatalf("Erro ao buscar: %s", err)
    }
    defer res.Body.Close()

    var r map[string]interface{}
    if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
        log.Fatalf("Erro ao decodificar resposta: %s", err)
    }

    fmt.Printf("Resultados encontrados: %d\n", int(r["hits"].(map[string]interface{})["total"].(map[string]interface{})["value"].(float64)))
    for _, hit := range r["hits"].(map[string]interface{})["hits"].([]interface{}) {
        source := hit.(map[string]interface{})["_source"].(map[string]interface{})
        fmt.Printf("- %s\n", source["name"])
    }
}

A saída será a seguinte:

Resultados encontrados: 1
- DistributedLocks.md

O código exibe quantos documentos foram encontrados e os nomes dos arquivos correspondentes.

Para tornar a busca mais inteligente, poderíamos utilizar alguns recursos do Elasticsearch para refinar os resultados, como: Boost por campo(peso aos títulos), Fuzzy search(permite erros de digitação), Highlight(mostra trechos do conteúdo que bateram com a busca).

Um exemplo com fuzzy search:

"multi_match": {
  "query": "locks",
  "fields": ["title^2", "content"],
  "fuzziness": "AUTO"
}

title^2 - dá peso maior para o campo title
AUTO - corrige pequenas variações de ou erros de digitação

Servidor WEB

Abaixo encontra-se um programa expondo um servidor web mínimo para executar o que foi aprendido acima:

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"

    elasticsearch8 "github.com/elastic/go-elasticsearch/v9"
)

const MediaTypeApplicationJson = "application/json"

type MarkdownDoc struct {
    Path    string `json:"path"`
    Name    string `json:"name"`
    Content string `json:"content"`
}

type MultiMatch struct {
    Query  string   `json:"query"`
    Fields []string `json:"fields"`
}

type Query struct {
    MultiMatch MultiMatch `json:"multi_match"`
}

type SearchQuery struct {
    Query Query `json:"query"`
}

var es *elasticsearch8.Client

func searchHandle(w http.ResponseWriter, r *http.Request) {
    term := r.URL.Query().Get("q")
    if term == "" {
        http.Error(w, "Informe o parâmetro 'q' para busca", http.StatusBadRequest)
        return
    }

    sq := SearchQuery{
        Query: Query{
            MultiMatch: MultiMatch{
                Query:  term,
                Fields: []string{"name", "content"},
            },
        },
    }

    var buf bytes.Buffer
    if err := json.NewEncoder(&buf).Encode(sq); err != nil {
        http.Error(w, "Erro ao codificar query", http.StatusInternalServerError)
        return
    }

    res, err := es.Search(
        es.Search.WithContext(context.Background()),
        es.Search.WithIndex("wiki"),
        es.Search.WithBody(&buf),
        es.Search.WithTrackTotalHits(true),
    )
    if err != nil {
        http.Error(w, fmt.Sprintf("Erro na busca: %s", err), http.StatusInternalServerError)
        return
    }
    defer res.Body.Close()

    var rJSON map[string]interface{}
    if err := json.NewDecoder(res.Body).Decode(&rJSON); err != nil {
        http.Error(w, "Erro ao decodificar resposta do ElasticSearch", http.StatusInternalServerError)
        return
    }

    results := []MarkdownDoc{}
    for _, hit := range rJSON["hits"].(map[string]interface{})["hits"].([]interface{}) {
        source := hit.(map[string]interface{})["_source"].(map[string]interface{})
        doc := MarkdownDoc{
            Name:    source["name"].(string),
            Content: source["content"].(string),
            Path:    source["path"].(string),
        }
        results = append(results, doc)
    }

    w.Header().Set("Content-Type", MediaTypeApplicationJson)
    json.NewEncoder(w).Encode(results)
}

func main() {
    cfg := elasticsearch8.Config{
        Addresses: []string{"http://localhost:9200"},
        Username:  "username",
        Password:  "password",
    }

    var err error
    es, err = elasticsearch8.NewClient(cfg)
    if err != nil {
        log.Fatalf("Erro ao criar cliente: %s", err)
    }

    http.HandleFunc("/search", searchHandle)
    fmt.Println("API de busca rodando em http://localhost:8080/search?q=termo")
    log.Fatal(http.ListenAndServe("localhost:8080", nil))
}

Virá uma resposta como esta:

[
  {
    "path": "~/ObsidianNotes/Concurrency/DistributedLocks.md",
    "name": "DistributedLocks.md",
    "content": "When we talk about Distributed Locks, we are mainly talking about distributed systems, before commenting on distributed Locks, we will talk about distributed systems.\n\n A distributed system is a collection of **independent  computers** (nodes) that work together and appear to the user as a single coherent system. Key characteristics:\n - Network Communication: nodes exchanges messages (they don't share memory directly)\n- Concurrency: multiple machines can execute tasks simultaneously\n- Partial failures: one machine can fail while others keep running (different from centralized systems).\n- Consistency and coordination: since data may be spread across nodes, the system must handle synchronization, consensus, and fault tolerante(e.g., Paxos or Raft algorithms)\n- Examples: distributes databases(Cassandra, MongoDb Cluster), distributed file systems (HDFS), coordination services (Zookeeper, Etcd), and cloud plataforms (AWS, Google Cloud)\n\nIn short:\n\u003e That’s a distributed system: **many people (computers) working together as if they were one.**\n\nNow, back to Distributed Locks. Distributed locks are sophisticated techniques used to synchronize access to shared resources in distributed environments, ensuring that only one process or node can perform a critical operation at a time, preventing conflicts, inconsistencies, and possible data corruption.\n\nIn distributed systems, multiple processes/nodes may attempt to access the same critical resource at the same time (e.g., updating a bank account balance, processing the same queue message, writing a file, start a schedule, job). Local locks (mutexes, semaphores) are insufficient because they only control concurrency within a single process or machine. For this we need a locking mechanism that works across multiple machines connected over the network.\n\n**A distributed lock must provide:**\n1. Mutual Exclusion\n\tOnly one client at a time can hold the lock.\n2. Deadlock prevention\n\tIf the client holding the lock crashes, the lock should eventually expire(lease or TTL)\n3. Availability\n\tEven under failures, the system should continue granting locks.\n4. Consistency\n\tNo two clients should ever believe they both hold the same lock.\n5. Fairness(**optional**)\n\tLocks can be granted in the order of requests (queue-based fairness).\n\n**Commons implementations**\n\n###### *Redis* (e.g., Redlock Algorithm)\n- Each client sets a key with a TTL.\n- If the client can successfully set the key in a majority of Redis nodes, it assumes the lock.\n- TTL ensures auto-release if the client crashes.\n\n**ASCII flow**:\n\n```

sh\nClient A tries to lock \"resource-1\"\n ├──\u003e Redis Node 1: OK\n ├──\u003e Redis Node 2: OK\n └──\u003e Redis Node 3: FAIL (timeout)\n\nMajority acquired (2/3) → Client A holds the lock\n

```\n\n###### *Zookeeper*\n- Uses ephemeral znodes: each client creates a temporary node.\n- The client with the smallest sequence number holds the lock.\n- If the client disconnects, its znode disappears automatically.\n\n**ASCII flow**:\n\n```

sh\n/locks/resource-1/\n  ├── lock-0001 (Client A)  \u003c-- LOCK OWNER\n  ├── lock-0002 (Client B)\n  └── lock-0003 (Client C)\n

```\n\n\u003e If the **Client A** crashes, Zookeeper deletes lock-0001, and **Client B** becomes the new owner\n\n###### *Etcd*\n- Uses leases (time-limited key ownership).\n- Clients acquire a key with PUT key --lease=10s.\n- When the leases expires (or client crases), the key is removed\n- Watchers notify other clients that the lock is free.\n\n\n##### *General Architecture*\n\n![[architecture-distributed-locks-system.png]]\n\n\u003e- All clients attempt to acquire a lock on resource X. \n\u003e- Only one  succeeds at a time.\n\u003e- The lock expires unless it is renewed (lease).\n\n\n**Summary**\n\nDistributed locks are a coordination mechanism in distributed systems, typically implemented with a middleware like Redis, Zookeeper, Etcd, or Consul. They guarantee **mutual exclusion**, **fault tolerance, and consistency** when multiple processes compete for shared resources."
  }
]

Chegamos ao final de mais um post. Estarei deixando alguns links de referência:

Web Server
Go Elasticsearch client
Documentação Oficial do Elasticsearch
JSON Handling in Go
Type Assertions in Go

Como implementar Feature Flags em seu Backend NestJS

José Paulo Marinho — Mon, 23 Dec 2024 21:08:21 +0000

Antes de mais nada, estarei introduzindo o significado e o poder que as Feature Flags tem em seu software.

Imagine comigo: digamos que sua aplicação tem uma funcionalidade de pagamentos, ou validação se um usuário existe, envio de email, push notification, etc. E essa funcionalidade não está funcionando corretamente em produção, o que fazer? O que fazer quando sua aplicação está enfrentando problemas em uma determinada funcionalidade que pode ser crítica na sua aplicação?

A resposta é simples: Feature Toggle.

De acordo com a wikipedia:

Feature toggle, em português alternância de recursos (também chamado de feature switch, feature flag, feature gate, feature flipper, conditional feature etc.) é uma técnica de desenvolvimento de software que tenta fornecer uma alternativa para manter várias ramificações no código-fonte (conhecidos como ramificações de recurso), de forma que um recurso de software possa ser testado antes mesmo de ser concluído e estar pronto para o lançamento. Um alternador de recurso é usado para ocultar, habilitar ou desabilitar o recurso durante o tempo de execução.

Ou seja,a gente implementa um "liga e desliga" para uma determinada funcionalidade se ela estiver dando problemas enquanto investigamos para achar a solução, acompanhe o desenho.

O desenho acima é bem simples, bem enxuto para representar um sistema de pagamento. O que acontece se acontece um problema entre a confirmação de pagamento do usuário e o gateway de pagamento, como por exemplo:

Falha de integração
Bugs no código(falta de homologação) devido a urgência da demanda
Problemas com perfomance/escalabilidade
Risco de fraudes/segurança

Entre muitos outros problemas que podem ocorrer. Dessa forma no desenho acima, não tem como desabilitar essa funcionalidade sem retirar totalmente a aplicação do ar. Veja esse outro desenho abaixo:

No desenho acima, algumas coisas novas apareceram, nele estamos verificando se a "flag" PAGAMENTO está habilitada, se está ela segue para o fluxo padrão, do contrário finalizamos o fluxo. É literamente uma estrutura de decisão na qual pode ser alterada em TEMPO REAL sem que haja alteração no código, gerado um novo build, deploy, etc.

No desenho nota-se que aparece um cara chamando Unleash, ele será nossa ferramenta para gestão de Feature Toggles, mas você pode usar o que precisar, desde um banco de dados não relacional, um banco de dados em memória, etc.

O Unleash, é uma solução poderosa de código aberto para gerenciamento de recursos. Ele simplifica seu fluxo de trabalho de desenvolvimento, acelera a entrega de software e capacita as equipes a controlar como e quando elas lançam novos recursos para os usuários finais. Com o Unleash, você pode implantar código para produção em lançamentos menores e mais gerenciáveis no seu próprio ritmo. Repositório aqui: github

Estarei executando o Unleash utilizando docker para facilitar. Não estarei ensinando a utilizar o Unleash, só como integrar em seu aplicativo NestJS.

Após já configurar o ambiente do unleash, nota-se que eu criei uma flag chamada PAYMENT_IS_ENABLED, ela está habilitada em ambiente de Desenvolvimento e Produção. No unleash é necessário que você crie um token de API para continuar com o desenvolvimento. Vamos para nossa aplicação NestJS. Nosso token só permite ver se a flag está habilitada em desenvolvimento.

Para integrar nossa aplicação NestJS com o Unleash, estarei utilizando a lib @josemarinho/unleash no NPM

Para instalar a dependência, basta rodar o comando abaixo:

$ npm install @josemarinho/unleash

Após instalação, basta configurar o módulo presente na lib no app.module.ts:

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { UnleashModule } from '@josemarinho/unleash';

@Module({
  imports: [
    UnleashModule.forRoot({
      appName: 'unleash-onboarding-node',
      url: 'http://localhost:4242/api/',
      global: true,
      apiKey: 'default:development.f73da5a65c1e5c097ccaaacaa8f9eab5a27f3d8b45ea34c4d8b4b035'
    })
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Fiz uma controller simples, só para trazer o resultado das features flags:

import { Controller, Get, Param } from '@nestjs/common';
import { UnleashService } from '@josemarinho/unleash';

@Controller()
export class FeatureToggleController {
  constructor(private readonly featureToggleService: UnleashService) {}

  @Get(':flag')
  async getHello(@Param('flag') flag: string): Promise<any> {
    return {
        enabled: await this.featureToggleService.isEnabled(flag)
    }
  }
}

Depois só executar o comando

$ nest start

Vimos que todos os módulos foram iniciados corretamente e sua aplicação está pronta para gerenciar estados. Vamos testar?

Executando o comando curl abaixo:

curl --location 'localhost:3000/PAYMENT_IS_ENABLED'

Veremos o seguinte resultado:

HTTP Status Code - 200 OK
{
    "enabled": true
}

Vimos que ela realmente está ligada, vamos desligar e testar novamente:

A flag está desligada, solicitando a requisição novamente:

HTTP Status Code - 200 OK
{
    "enabled": false
}

Utilizar feature toggles é uma estratégia eficiente para mitigar riscos e garantir controle em sistemas críticos. Elas permitem ativar, desativar ou ajustar funcionalidades rapidamente sem necessidade de novos deploys, reduzindo o impacto de falhas. Isso assegura maior estabilidade, flexibilidade e uma melhor experiência para o usuário.

Chegamos ao final de mais um post. Estarei deixando alguns links de referência:

Docker Unleash
Feature Toggle
Prós e Contras

Um abraço e bons estudos! Até mais.

Como iniciar um aplicativo Spring Boot + JPA + MySQL

José Paulo Marinho — Wed, 21 Aug 2024 03:27:53 +0000

Antes de irmos para a criação do projeto, estarei explicando de forma breve o que são as tecnologias Spring Boot, JPA e MySQL.

Spring Boot: é um framework Java utilizado para simplificar o desenvolvimento de aplicações Spring, permitindo criar aplicações standalone, que podem ser executados com um simples comando, sem a necessidade de configuração complexa.
JPA: Java Persistence API é uma especificação do Java que define como os objetos Java devem ser mapeados para banco de dados relacionais(ORM).
MySQL: sistema de gerenciamento de Banco de Dados relacional (RDBMS) de código aberto mundialmente famoso. Ele é amplamente utilizado para armazenar, organizar e gerenciar grandes volumes de dados em aplicações web e empresariais.

Com essas 3 tecnologias, podemos desenvolver aplicações web robustas, escaláveis e de alto desempenho.

Criação do Projeto

Estaremos criando o projeto em uma ferramenta online chamada: Spring Initializr que facilita a criação de projetos Spring Boot.

Quando você entrar na URL, verá uma tela dessa forma:

Estaremos configurando do lado esquerdo algumas coisas, como:

Tipo do Projeto: Maven
Língua: Java
Versão do Spring Boot: 3.3.2

No Project Metadata você irá por:

Group: br.com.(ex: br.com.josemarinho)
Artifact e Name: spring-jpa-mysql
Description: Projeto utilizando Spring Boot, JPA e MySQL
Package name: gerado automaticamente com base no Group e Artifact.
Packaging: Jar
Java: 17

Ao lado direito terá as dependências do nosso projeto, precisamos adicionar 3, sendo elas:

Spring Web
Spring Data JPA
MySQL Driver

No final ficará assim:

Após a configuração é só apertar no botão Generate, onde irá começar o download de um Zip contendo todos os diretórios/arquivos do projeto. Logo após é só descomprimir e abrir na sua IDE de preferência.

Primeira execução

Assim que você abrir o projeto e tentar executar o programa, irá acusar um erro em tempo de execução dizendo o seguinte:

Description:

Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

Reason: Failed to determine a suitable driver class

Isso ocorre porque o Spring Boot não consegue configurar automaticamente um DataSource para a aplicação. Vamos configurar?

No projeto terá um diretório chamado resources, dentro desse diretório tem alguns arquivos, dentre eles um arquivo chamado application.properties que é onde fica as configurações de um projeto spring boot. Eu gosto de utilizar sua versão em YAML/YML, para isso é só deletar esse arquivo e criar outro chamado application.yml, ficando dessa forma:

Vamos definir a url em que nosso app irá conectar, driver, username e password:

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: username
    password: password
    url: jdbc:mysql://127.0.0.1:3306/seu_banco_de_dados

No application.properties ficaria da seguinte forma:

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=username
spring.datasource.password=password
spring.datasource.url=jdbc:mysql://localhost:3306/seu_banco_de_dados

Pronto, agorá é só executar novamente o projeto e você verá uma saída como essa.

Criação de Entidades

Em meu banco de dados tenho uma tabela simples chamada usuarios no qual existem 2 campos:

id: primary key integer auto increment
usuario: varchar(255)

Com ela, iremos dar o primeiro passo para mapear essa tabela em um contexto java, criando uma Entidade. Para isso crie uma classe chamada Usuario, no final ela deverá ficar assim:

@Entity
@Table(name = "usuarios")
public class Usuario {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String usuario;

    // Getters e Setters
}

@Entity: Marca a classe como uma entidade JPA. Isso indica ao JPA que a classe deve ser persistida em um banco de dados.
@Table(name = "produto"): Especifica o nome da tabela no banco de dados à qual a entidade está mapeada. Se essa anotação não for fornecida, o JPA assumirá que o nome da tabela é o mesmo que o nome da classe.
@Id: Indica que o campo é a chave primária da entidade.
@GeneratedValue: Indica a estratégia que iremos gerar os valores, no caso escolhemos que o próprio banco de dados irá gerar automaticamente para nós, o padrão é o GenerationType.AUTO.

Agora que temos nossa entidade já desenvolvida precisamos criar nossos Repositórios que implementarão o JPA para realizar manipulações no Banco de Dados.

Criação dos Repositórios utilizando JPA

Para iniciar crie uma interface chamada UsuarioRepositorio, essa interface vai herdar as características de JpaRepository<> passando dois valores genéricos, o primeiro é a entidade e o segundo é o tipo do Id. Não podemos deixar de esquecer de anotar a classe com a anotação @Repository, ficando dessa forma:

@Repository
public interface UsuarioRepositorio extends JpaRepository<Usuario, Integer> { }

O JpaRepository é uma interface do Spring Data JPA que fornece diversos métodos prontos para realizar operações de acesso a dados em uma aplicação, como por exemplo o findAll() que retorna todos os dados de uma determinada tabela de banco de dados. No final do artigo estarei deixando alguns links falando mais sobre.

Já temos o suficiente para realizar algumas consultas, vamos criar um ponto de entrada na nossa aplicação para ver esses dados.
Crie uma controller chamada: UsuariosController.
Nela vamos anotar com 2 anotações: @RestController e @RequestMapping("/v1/usuarios") para mapear a rota da nossa controller

Vamos fazer injeção de dependência da UsuarioRepository e criar um endpoint GET para obter os dados da controller.

No final ficará assim:

@RestController
@RequestMapping("/v1/usuarios")
public class UsuarioController {

    private UsuarioRepositorio usuarioRepositorio;

    public UsuarioController(UsuarioRepositorio usuarioRepositorio) {
        this.usuarioRepositorio = usuarioRepositorio;
    }

    @GetMapping()
    public ResponseEntity getUsuarios() {
        return ResponseEntity.status(HttpStatus.OK).body(usuarioRepositorio.findAll());
    }
}

Note que estou utilizando o método findAll() que mencionei mais acima existente na repository.

Em minha tabela de banco de dados, já possuo alguns dados. Fazendo uma consulta simples, virá o seguinte resultado:

Vimos que temos 3 dados na tabela.

Após salvar o conteúdo da controller e executar novamente o projeto, quando realizarmos uma requisição do tipo GET na url localhost:8080/v1/usuarios, virá o seguinte resultado:

Vemos que o resultado que foi resgatado ao realizar uma consulta no banco de dados foi exatamente o mesmo ao fazer uma requisição GET em nossa aplicação graças ao JPA e ao Spring Boot.

Chegamos ao final de mais um post. Estarei deixando alguns links de referência:

O repositório do artigo se encontra nesse link: Repositório Projeto

Um abraço e bons estudos! Até mais.

Enums em C#: Simplificando a Gestão de Constantes

José Paulo Marinho — Thu, 27 Jun 2024 21:59:23 +0000

Enumeração ou Enum é um recurso muito legal em Desenvolvimento de Software. Ele nos permite representar um conjunto fixo de valores relacionados, facilitando leitura e manutenção de código.

Em outras palavras mais técnicas:

Em programação, uma enumeração é um tipo de dado abstrato, cujos valores são atribuídos a exatamente um elemento de um conjunto finito de identificadores escolhidos pelo programador. Wikipedia

A maioria das linguagens tipadas, como Java, TypeScript, Swift, Kotlin, Rust, C++, etc. possuem Enum. Neste post, estarei explicando como a mesma funciona em C#.

Enum em `C#`

Em c#, um enum é definido usando a palavra-chave enum, seguido pelo nome do enum e uma "lista" de seus membros entre chaves:

public enum Status
{
    Active,
    Inactive,
    Pending
}

Acima estou utilizando o exemplo de estados de pedidos, como: Ativo, Inativo e Pendente. Mas pode ser outros casos, como dias da semana, tipos de documento(CPF, CNPJ, RG), etc.

Um exemplo de uso:

public class Order
{
    public int Id { get; set; }
    public Status OrderStatus { get; set; }
}

var order = new Order { Id = 1, OrderStatus = Status.Active };

if (order.OrderStatus == Status.Active)
{
    Console.WriteLine("The order is active.");
}

Há a possibilidade de você atribuir valores inteiros aos enums, com isso você pode controlar a representação dos estados ou opções:

public enum Priority
{
    Low = 1,
    Medium = 2,
    High = 3
}

Enums em C# não podem ser iniciados com valores nulos, pois Enum é um tipo de valor, o que significa que eles sempre têm um valor atribuído e não podem ser null.

Compilador

O compilador associa cada membro do enum a um valor inteiro sequencial. Por padrão, o primeiro começa com o valor 0, o segundo como 1, e assim por diante.
Durante a compilação, o compilador substitui os nomes das propriedades de um enum pelo valor inteiro correspondente. Isso significa que, internamente, o código que usa um enum como Status.Active é substituído por um valor inteiro (por exemplo, 0 se for o primeiro membro não atribuído).

Estruturas de controle como switches em C# e Java são otimizadas para enums. O compilador muitas vezes gera instruções de desvio direto (jump tables) para lidar eficientemente com enums, o que significa que o tempo de acesso é constante e independente do número de membros do enum.

Memória

Enums são tipos de valor, o que significa que eles são armazenados como valores diretos em memória(o que facilita a eficiência) geralmente como inteiros. Em sistemas que otimizam o espaço de armazenamento, enums podem ser armazenados como o menor tipo inteiro que pode acomodar todos os valores do enum.

Como enums são representados internamente como valores inteiros (ou outro tipo de valor dependendo da linguagem), o acesso a qualquer valor de enum é direto O(1). Não há necessidade de cálculos adicionais ou pesquisas, pois o valor do enum é determinado em tempo de compilação e acessado diretamente em tempo de execução.

Enum para String ou vice Versa

É possível converter um Enum para string ou string para um Enum, vamos ver alguns casos de Enum para string:

ToString()

Status statusPending = Status.Pending;
string statusPendingString = statusPending.ToString(); // saida -> "Pending"

Esse caso acima é um caso simples.

Enum.GetName()

Você pode usar Enum.GetName() para obter o nome de um membro específico de um enum. Este método retorna o nome do identificador que corresponde ao valor do enum especificado.

Status statusActive = Status.Active;
string statusActiveString = Enum.GetName(statusActive); // saída -> "Active"

nameof()

Veremos outro utilizando o nameof()

string statusActiveString = nameof(Status.Active); // saida -> "Active"

MUITO CUIDADO AO UTILIZAR nameof() ao converter enum para string

Se você reparar bem, os dois exemplos são diferentes, no primeiro exemplo, eu declaro a variável como sendo um enum acima e abaixo converto para string. No segundo exemplo eu não fiz isso, por que? Vejamos o exemplo abaixo

Status statusPending = Status.Pending;
string statusPendingString = nameof(statusPending);

A saída desse programa acima não é "Pending", mas sim o nome da variável "statusPending", curioso, né? Isso ocorre porque o nameof() é avaliado somente em tempo de compilação e retorna o nome do identificador que é passado pra ele, não o valor da expressão. Então quando passamos nameof(Status.Pending), ele funciona nesse contexto porque o argumento passado é a referência ao membro do Enum Pending.

Convertendo string para Enum

Enum.Parse()

string statusActiveString = "Active";
Status statusActive = Enum.Parse<Status>(statusActiveString);

Enum.TryParse()

string statusPendingString = "Pending";
bool tryParse = Enum.TryParse(statusPendingString, out Status status);

Chegamos ao final de mais um post. Estarei deixando alguns links de referência:

Tipos de enumeração (referência de C#)
Enums C#

Um abraço e bons estudos! Até mais.

Como funciona um Load Balance e como implementar utilizando Nginx.

José Paulo Marinho — Sun, 21 Apr 2024 04:55:59 +0000

O que é um Load Balance e para que serve?

Descrevendo de maneira mais técnica: o Load balance é uma técnica que distribui o tráfego entre servidores para otimizar o desempenho e a confiabilidade de uma rede ou sistema.

Dessa forma, é possível que, por exemplo, um site de comércio eletrônico distribua o tráfego entre vários servidores para lidar com um grande número de visitantes simultâneos, mantendo o site rápido e disponível.

O legal do Load Balance é a possibilidade de passar um "peso" para dizer qual servidor vai receber mais requisições de acordo com a configuração, vamos ver mais adiante.

Como implementar um Load Balance?

Para implementar um Load Balance, vamos utilizar um Software bem famoso estabilizado no mercado que permita que manipulemos um/o servidor HTTP, o Nginx.

Nginx é um servidor leve de HTTP, proxy reverso, proxy de e-mail IMAP/POP3, feito por Igor Sysoev em 2005, sob licença BSD-like 2-clause. O Nginx consome menos memória que o Apache, pois lida com requisições Web do tipo “event-based web server”; e o Apache é baseado no “process-based server”, podendo trabalhar juntos.

Nesse post não estarei ensinando a instalar o Nginx, apenas como configurar um Load Balance.

Arquitetura

Nosso desenho vai funcionar da seguinte forma:

Toda vez que chegar uma requisição na porta 8000 (de acordo com a configuração)
Vai ser redirecionado para o nosso servidor Nginx
Quando chegar no Nginx, ele vai fazer o redirecionamento pelo Load Balance de acordo com os servidores configurados

Implementação

Para este exemplo, estarei utilizando 2 aplicações em Spring Boot Java, mas você pode utilizar qualquer tecnologia que deseja ou framework.

Criei dois projetos no Spring Initializr só contendo a dependência do Spring Web.

Após a criação dos projetos, fiz uma controller em cada projeto bem simples:

Servidor 1:

// imports

@RestController
@RequestMapping("/")
public class Server1Controller {

    @GetMapping()
    public ResponseEntity get() {
        return ResponseEntity.status(HttpStatus.OK).body("Olá, server 1");
    }
}

Servidor 2

// imports

@RestController
@RequestMapping("/")
public class Server2Controller {

    @GetMapping()
    public ResponseEntity get() {
        return ResponseEntity.status(HttpStatus.OK).body("Olá, server 2");
    }
}

Não pode esquecer de trocar a porta da segunda ou primeira aplicação, vai da sua escolha:

server.port=8081

Após rodar as duas aplicações, vamos ter as seguintes respostas rodando o comando curl:

Boa, vemos que as duas aplicações estão rodando como desejado. Agora vamos para o Load Balance.

Para configurarmos o Load Balance, precisamos editar o arquivo de configuração do Nginx, o nginx.conf:

http {
  upstream spring-project {
    server localhost:8080;
    server localhost:8081;
  }

  server {
    listen 8000;
    server_name 127.0.0.1;

    location / {
      proxy_pass http://spring-project;
    }
  }
}

Vou explicar o arquivo acima:

O bloco http é onde a configuração do servidor HTTP do Nginx é definida. Dentro desse bloco temos a definição de um grupo de servidores, chamado spring-project usando a diretiva upstream. Com isso, definimos um grupo de servidores que será usado para o balanceamento de carga, no caso temos 2 servidores:

127.0.0.1:8080
127.0.0.1:8081

Que por acaso, são nossos dois servidores que já estão rodando nossa aplicação Spring.

Mais abaixo há um bloco de server, que é a nossa configuração do servidor que vai ouvir na porta 8000 e responder requisições que venham do host 127.0.0.1, dentro da localização padrão /. A partir disso o Nginx vai redirecionar todo o tráfego para os servidores dentro de spring-project, vamos ver?

Olha que legal! De quatro requisições realizadas, ele balanceou todas as quatro, então duas foram para o servidor 1 e duas foram para o servidor 2. Se eu quisesse modificar isso? Se eu quisesse que o servidor 1 recebesse três requisições a cada quatro?

É possível. Tem uma propriedade do nginx, chamado weight, que é o peso do balanceamento definido no servidor. Dessa forma, é possível influenciar ainda mais os algoritmos de balanceamento de carga nginx. Só alterar o arquivo nginx.conf dessa forma:

server localhost:8080 weight=3;

Obs: se o weight não é passado, o padrão é 1

Vamos ver como ficou após as alterações.

Pronto. De cada quatro requisições, três caíram no servidor 1 e uma caiu no servidor 2.

Chegamos ao final. Espero que tenham gostado, deixarei aqui alguns links de referência.

Using nginx as HTTP load balance
Simple Load Balancing
Nginx

Um abraço e bons estudos! Até mais!

Otimize seu Aplicativo com Cache de Dados usando NestJS e Redis

José Paulo Marinho — Sat, 13 Apr 2024 03:41:15 +0000

No mundo de desenvolvimento de software, construir aplicações robustas e performáticas são de suma importância.

Pense no seguinte cenário: digamos que você tenha um aplicação de consulta de usuários, e toda vez que alguém entra no perfil de determinado usuário, é preciso realizar uma consulta no banco de dados, certo? E aí vai retornar dados como:

nome, data de nascimento, estado civil, altura, peso, formação, etc.

Raramente essas informações vão mudar, certo? Como evitar que seu servidor consulte sempre o banco de dados?

A resposta é simples: CACHE!

A técnica de cache se baseia no princípio de armazenar temporariamente dados frequentemente acessados em uma área de armazenamento de acesso mais rápido, como a memória RAM, para reduzir o tempo necessário para recuperar esses dados em comparação com a obtenção dos dados diretamente da fonte original, como um banco de dados ou uma API externa.

Vamos utilizar uma ótima solução para realizar essa técnica, o Redis.

Redis é um armazenamento de estrutura de dados em memória, usado como um banco de dados em memória distribuído de chave-valor, cache e agente de mensagens, com durabilidade opcional extremamente rápido.

Desenho da arquitetura

Inicialmente sem cache, sua modelagem fica no seguinte modelo:

Após o cache, ficará assim:

Para realizar o cache é necessário realizar pelo menos uma ou mais vezes consulta no banco de dados, nunca dá pra saber quando o usuário vai querer mudar seus dados, então, quando o servidor realizar uma consulta no Banco de Dados (3), ele irá armazenar esses dados no Redis (4).

A partir desse momento você poderá consultar no Redis os dados:

Consulta do Redis, se não encontrou os dados:
- Consulta Banco de Dados
- Armazena os dados no Redis
- retorna os dados
Consulta do Redis, se encontrou os dados:
- retorna os dados

Iniciando o Projeto

Para esse exemplo, estarei utilizando uma aplicação NestJS + Redis + MongoDB, mas você pode realizar com outros frameworks, como Java utilizando Spring Data Redis + H2, ou GoLang utilizando go-redis + POSTGRES, entre muitas outras.

Para iniciar um aplicativo NestJS, é necessário ter instalado o CLI do Nest:

$ npm install -g @nestjs/cli

Para criar um projeto:

nest new cache-with-redis

Estarei utilizando o Mongoose, como TypeORM para se conectar ao Banco de dados MongoDB.

$ npm i @nestjs/mongoose mongoose

Para o redis, estarei utilizando um Redis Módulo para o Nest:

$ npm install @liaoliaots/nestjs-redis ioredis

Para configurar o projeto utilizando variáveis de ambiente, estarei instalando um módulo do Nest para configuração:

$ npm i --save @nestjs/config

Vamos iniciar configurando um módulo para o Redis, comece criando 2 arquivos:

redis-cache.module.ts
redis-repository.ts

// redis-cache.module.ts
import { RedisModule } from "@liaoliaots/nestjs-redis";
import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";
import { RedisCacheRepository } from "./redis-cache.repository";

@Module({
    imports: [
        ConfigModule.forRoot(),
        RedisModule.forRoot({
            config: {
                host: process.env.REDIS_HOST,
                port: Number(process.env.REDIS_PORT),
                password: process.env.REDIS_PASSWORD
            }
        })
    ],
    providers: [RedisCacheRepository],
    exports: [RedisCacheRepository]
})
export class CacheRedisModule {}

// redis-cache.repository.ts
import { InjectRedis } from "@liaoliaots/nestjs-redis";
import { Injectable } from "@nestjs/common";
import Redis from 'ioredis';

@Injectable()
export class RedisCacheRepository {
    constructor(@InjectRedis() private readonly redis: Redis) {}

    async saveData<T>(data: T, key: string): Promise<void> {
        // key -> chave onde o redis irá salvar os dados
        // JSON.stringify(data) -> salvar os dados em JSON
        // EX -> utilizado para indicar que o tempo será passado em segundos
        // 180 -> 180 segundos = 3 minutos de cache
        // Time Complexity -> O(1)
        await this.redis.set(key, JSON.stringify(data), "EX", 180)
    }

    async getData<T>(key: string): Promise<T> {
        // retorna o dado salvo da chave
        // Time Complexity -> O(1)
        return JSON.parse(await this.redis.get(key)) as T;
    }
}

Agora iremos cuidar da nossa entidade Usuário e seu repositório utilizando MongoDB, crie 5 arquivos:

models/user.entity.ts
user.repository.ts
user.servive.ts
user.controller.ts
user.module.ts

// user.entity.ts
import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
import { HydratedDocument } from "mongoose";

export type UserDocument = HydratedDocument<User>;

export enum GenderEnum {
    FEMALE = "Female",
    MALE = "Male"
}

export enum MaritalStatusEnum {
    SINGLE = "Single",
    MARRIED = "Married",
    Divorced = "Divorced",
    Widowed = "Widowed",
    Separated = "Separated"
}

@Schema()
export class User {

    @Prop()
    name: string;

    @Prop()
    age: number;

    @Prop({ type: String, enum: GenderEnum })
    gender: GenderEnum

    @Prop({ type: String, enum: MaritalStatusEnum })
    maritalStatus: MaritalStatusEnum;

    @Prop()
    height: number;
}

export const UserSchema = SchemaFactory.createForClass(User);

// user.repository.ts
import { Injectable } from "@nestjs/common";
import { InjectModel } from "@nestjs/mongoose";
import { User } from "./models/user.entity";
import { Model } from "mongoose";
import { CreateUserDto } from "./dto/create-user.dto";

@Injectable()
export class UserRepository {
    constructor(@InjectModel(User.name) private readonly userModel: Model<User>) {}

    async create(createUserDto: CreateUserDto): Promise<User> {
        const userCreated = new this.userModel(createUserDto);
        return userCreated.save();
    }

    async findById(userId: string): Promise<User> {
        return await this.userModel.findById(userId);
    }
}

// user.servive.ts
import { Injectable } from "@nestjs/common";
import { UserRepository } from "./user.repository";
import { RedisCacheRepository } from "src/redis-cache/redis-cache.repository";
import { CreateUserDto } from "./dto/create-user.dto";

@Injectable()
export class UserService {
    constructor(
        private readonly userRepository: UserRepository,
        private readonly redisCacheRepository: RedisCacheRepository
    ) {}

    async getUserById(userId: string) {
        const userCache = await this.redisCacheRepository.getData(userId);

        if (userCache) {
            return userCache;
        }

        const userRepository = await this.userRepository.findById(userId);

        await this.redisCacheRepository.saveData(userRepository._id, userRepository);

        return userRepository;
    }

    async saveUser(userCreateDto: CreateUserDto) {
        return await this.userRepository.create(userCreateDto);
    }
}

// user.controller.ts
import { Body, Controller, Get, HttpStatus, Param, Post, Res } from "@nestjs/common";
import { UserService } from "./user.service";
import { CreateUserDto } from "./dto/create-user.dto";
import { Response } from "express";

@Controller("user")
export class UserController {
    constructor(private readonly userService: UserService) {}

    @Post()
    async postUser(@Body() userDto: CreateUserDto, @Res() res: Response) {
        const userCreated = await this.userService.saveUser(userDto);

        res.status(HttpStatus.OK).json(userCreated);
    }

    @Get(":id")
    async get(@Param("id") id: string, @Res() res: Response) {
        const user = await this.userService.getUserById(id);

        res.status(HttpStatus.OK).json(user);
    }
}

É importante criar um arquivo .env no root do projeto:

# .env
REDIS_HOST=127.0.0.1
REDIS_PORT=6379
REDIS_PASSWORD=password
MONGODB_HOST="mongodb://127.0.0.1:27017/CACHE_WITH_REDIS"

Pronto, a aplicação está pronta para ser executada. Você pode executar executando o comando:

$ npm run start

Logo após verá um saída dessa forma:

Para salvar um usuário, podemos realizar uma requisição do tipo POST com o curl:

curl --location 'localhost:3000/user' \
--header 'Content-Type: application/json' \
--data '{
  "name": "John Doe",
  "age": 30,
  "gender": "Male",
  "maritalStatus": "Married",
  "height": 1.80
}'

Logo após retornará algo do gênero:

Redis em Ação

Agora veremos o Redis em Ação, ao realizar uma requisição do método GET para obter o usuário:

curl --location 'localhost:3000/user/6619fa598d1a2e8cb93a95f3'

Vamos obter o seguinte resultado:

Repare que a resposta volta com o seguinte tempo de resposta: 34ms. De acordo com nossa regra de negócio, ele faz uma consulta no Redis, se não achar, ele vai no Banco de Dados(MongoDB), logo após salva no redis e retorna, certo? Boa, vamos ver se salvou no redis?

# Redis CLI
> GET 6619fa598d1a2e8cb93a95f3
"{\"_id\":\"6619fa598d1a2e8cb93a95f3\",\"name\":\"John Doe\",\"age\":30,\"gender\":\"Male\",\"maritalStatus\":\"Married\",\"height\":1.8,\"__v\":0}"

Olha que legal, agora o nosso dado está salvo no Redis, vamos ver se melhorou o tempo de resposta da API?

4ms, isso é um absurdo de rápido. Você deve estar pensando: "Caramba, só 29ms de diferença, isso não faz diferença."
Em ambientes escaláveis e robustos que necessitam de sistemas rápidos, como o PIX, qualquer diferença de tempo muda. Imagine quando você precisar cachear o resultado de alguma API externa em que você utiliza que não muda muito o resultado, seria de grande utilidade, certo?

Chegamos ao final. Espero que tenham gostado, estarei deixando alguns links de referência:

Configuration NestJS
MongoDB NestJS
Redis Module NestJS
SET command Redis
GET command Redis

O link do repositório utilizado no tutorial se encontra aqui:
Projeto Repositório

Um Abraço e bons estudos! Até mais!

Como publicar uma notificação de Evento para o SQS quando algo for publicado no S3: Um guia passo a passo

José Paulo Marinho — Thu, 05 Oct 2023 00:11:06 +0000

Aqui estão os passos para criar uma política de acesso para uma fila do Amazon SQS usando a console da AWS, este tutorial parte do pressuposto que você já tem o recurso do SQS criado:

Passo 1: Crie uma política de acesso para a sua fila

1 - Acesse a console do Amazon SQS e selecione a fila que você criou.

2 - Clique na guia "Permissões" e em seguida, clique em "Adicionar política de fila".

3 - Na página "Adicionar política de fila", selecione o serviço ou usuário que você deseja conceder acesso à fila.

4 - Escolha as ações permitidas e especifique as condições, se necessário. Por exemplo, para permitir que o S3 envie mensagens para a fila, você precisará definir a condição ArnLike para corresponder ao ARN do bucket do S3 que enviará as mensagens.

5 - Cole a política de acesso diretamente na área de texto ou crie uma nova política usando o assistente. Aqui está um exemplo de política que permite que o S3 envie mensagens para a fila:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "s3.amazonaws.com"
      },
      "Action": "sqs:SendMessage",
      "Resource": "arn:aws:sqs:REGION:ACCOUNT-ID:QUEUE-NAME",
      "Condition": {
        "ArnLike": {
          "aws:SourceArn": "arn:aws:s3:::BUCKET-NAME"
        }
      }
    }
  ]
}

6 - Lembre-se de substituir 'REGION', 'ACCOUNT-ID', 'QUEUE-NAME' e 'BUCKET-NAME' pelos valores reais correspondentes às suas configurações.

6.1 - Para obter essas informações entre no console da aws (AWS CLI) e digite:

$ aws sts get-caller-identity
$ aws configure get region
$ aws s3 ls
$ aws sqs list-queues

7 - Quando terminar, clique em "Salvar alterações" para aplicar a política à fila do SQS.

Passo 2 - Obtenha as credenciais de acesso para a sua aplicação

1 - Acesse a console do IAM e crie um usuário para sua aplicação.

2 - Conceda as permissões necessárias para o usuário acessar a fila do SQS.

3 - Obtenha as credenciais de acesso para o usuário criado.

Passo 3: Use as credenciais para enviar mensagens para a fila do SQS

1 - Use as credenciais de acesso para autenticar sua aplicação e enviar mensagens para a fila do SQS.

Configurar Notificações de Eventos no S3 para enviar ao SQS

Esta parte do tutorial assume que você já tem seu recurso do S3 criado.

1 - Navegue até o S3, selecione seu bucket.

2 - Vá em propriedades e procure pelo tópico Notificações de eventos

3 - Clique em Criar Notificação de evento. Preencha algumas infomações como:

Nome do evento
Prefiro - Opcional (se não houver ele vai verificar todos os diretórios)
Sufixo - Opcional (se nçao houver ele vai verificar todos os tipos de arquivos)

4 - Tipos de Eventos - Aqui você coloca o que preferir

5 - Por fim, selecione o Destino, escolha 'Fila do SQS'

Escolher entre seus filas do SQS

E escolha sua fila. No final salve.

6 - Agora teste, assim que você inserir um arquivo deverá receber uma mensagem como essa no SQS:

{
  "Records": [
    {
      "eventVersion": "2.1",
      "eventSource": "aws:s3",
      "awsRegion": "us-east-1",
      "eventTime": "2023-05-04T02:27:25.626Z",
      "eventName": "ObjectCreated:Put",
      "userIdentity": {
        "principalId": "AWS:XXXXXXXXXXXXXXXXXXX:userXXXXXXXXXXXX"
      },
      "requestParameters": {
        "sourceIPAddress": "XXX.XXX.XXX.XXX"
      },
      "responseElements": {
        "x-amz-request-id": "XXXXXXXXXXXXXX",
        "x-amz-id-2": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
      },
      "s3": {
        "s3SchemaVersion": "1.0",
        "configurationId": "sqs-trigger",
        "bucket": {
          "name": "example-bucket",
          "ownerIdentity": {
            "principalId": "XXXXXXXXXXXX"
          },
          "arn": "arn:aws:s3:::example-bucket"
        },
        "object": {
          "key": "example/file.txt",
          "size": 1234,
          "eTag": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
          "sequencer": "XXXXXXXXXXXXXXXXXX"
        }
      }
    }
  ]
}

Você pode ver melhor aqui: https://docs.aws.amazon.com/pt_br/AmazonS3/latest/userguide/ways-to-add-notification-config-to-bucket.html#S3NotificationHowToDestinationSQS

Lib HttpClient Utils: Uma biblioteca Java para simplificar requisições HTTP

José Paulo Marinho — Sun, 25 Jun 2023 01:10:33 +0000

Com o crescente uso de aplicações web e serviços RESTful, a manipulação eficiente de requisições e respostas HTTP tornou-se crucial no desenvolvimento de software. No entanto, lidar com essas operações de forma simples e otimizada nem sempre é uma tarefa fácil. É nesse contexto que a biblioteca Lib HttpClient Utils surge como uma solução poderosa e personalizada para desenvolvedores Java.

Neste artigo, exploraremos em detalhes a biblioteca Lib HttpClient Utils, uma ferramenta desenvolvida por mim para simplificar e aprimorar a manipulação de requisições HTTP em projetos Java. Com a Lib HttpClient Utils, você poderá reduzir a complexidade do código, aumentar a produtividade e obter um desempenho excepcional nas comunicações HTTP.

Ao longo deste artigo, discutiremos os principais recursos e funcionalidades da Lib HttpClient Utils, apresentaremos exemplos práticos de uso e destacaremos os benefícios que ela oferece. Se você é um desenvolvedor Java em busca de uma solução elegante e eficiente para lidar com requisições HTTP, continue lendo e descubra como a Lib HttpClient Utils pode transformar sua experiência de desenvolvimento.

1. Importação da Biblioteca

Maven

<dependency>
    <!-- Outras dependências do seu projeto -->
    <groupId>io.github.jusebandtec</groupId>
    <artifactId>lib-httpclient-utils</artifactId>
    <version>1.1.6</version>
</dependency>

Gradle

dependencies {
    // Outras dependências do seu projeto

    implementation 'io.github.jusebandtec:lib-httpclient-utils:1.1.6'
}

2. Exemplo

Para utilizar é bem simples. A biblioteca é composto em 4 módulos principais:

HttpRepository
HttpConnection
HttpRequest
HttpResponse

Estaremos utilizando o contexto do Via Cep como exemplo. No qual fazemos a requisição:
HTTP GET - Cep 01001000

E vem a seguinte resposta:

{
  "cep": "01001-000",
  "logradouro": "Praça da Sé",
  "complemento": "lado ímpar",
  "bairro": "Sé",
  "localidade": "São Paulo",
  "uf": "SP",
  "ibge": "3550308",
  "gia": "1004",
  "ddd": "11",
  "siafi": "7107"
}

Com a Lib HttpClient Utils é bem fácil reproduzir o comportamento.

É só fazer uma classe e herdar o módulo de HttpRepository para obter as funcionalidades de doRequest().

Veja:

@Component
public class TesteHttpClientUtils extends HttpRepository {

    @Autowired
    public TesteHttpClientUtils(HttpConnection httpConnection) {
        super(httpConnection);
    }
}

Note que ela não vai funcionar de primeira, é necessário criar um Bean da classe HttpConnection, dessa forma:

@Configuration
public class HttpClientLibConfiguration {

    @Bean
    public HttpConnection httpRepository() {
        return new HttpConnectionImpl(HttpClient.newBuilder().build());
    }
}

Agora podemos prosseguir.

Precisamos construir nossos objetos de Request e Response:

public class ObterCepHttpRequest extends HttpRequest {
    public ObterCepHttpRequest(String cep) {
        this.setUriRelative(String.format("https://viacep.com.br/ws/%s/json", cep));
        this.setHttpMethod(HttpMethod.GET);
        this.setTimeout(5000);
    }
}

Aqui tem somente alguns exemplos do que o HttpRequest tem, mas tem muito mais, como:

String payload;
Map headers;
Map stringMediaTypeMap;

Dependendo da sua requisição, você pode utilizar.

E a classe de Response:

public class ObterCepHttpResponse implements HttpResponse {

    public ObterCepHttpResponseData obterCepHttpResponseData;

    @Override
    public HttpResponse handle(HttpRequest httpRequest, java.net.http.HttpResponse<?> httpResponse) {
        if (httpResponse.statusCode() != 200)
            return null;

        obterCepHttpResponseData = new JsonHelper<ObterCepHttpResponseData>().deserializeFromString(httpResponse.body().toString(), ObterCepHttpResponseData.class);
        return this;
    }

    public ObterCepHttpResponseData getObterCepHttpResponseData() {
        return obterCepHttpResponseData;
    }
}

Vou explicar como é chamado esse método handle() no próximo bloco.

A biblioteca já leva um módulo de JsonHelper no qual você pode serializar e desserializar objetos dependendo do que você deseja.

2.1 Fazendo a requisição

Vamos fazer um método para realizar a requisição e obter a resposta na classe que criamos como exemplo. Segue:

public ObterCepHttpResponseData obterCep(String cep) {
        try {
            var request = new ObterCepHttpRequest(cep);
            var response = this.doRequest(request, new ObterCepHttpResponse());
            System.out.println(response.toJson());
            return response.obterCepHttpResponseData;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

Veja que é chamado o método doRequest(request, new ObterCepHttpResponse(), assim que esse método é chamado, ele realiza a requisição passando os parametros que especificamos na classe ObterCepHttpRequest, e assim que realizar a request, ele chama a classe ObterCepHttpResponse, passando a response pra lá, e é assim que conseguimos obter a resposta.

A biblioteca foi desenvolvida por mim, eu espero muito que tenham gostado. A mesma pode ser encontrada aqui:

Lib HttpClient Utils

Até mais.

Explorando Estruturas de Dados em Java: Pilhas e Filas

José Paulo Marinho — Sat, 10 Jun 2023 22:13:42 +0000

Antes de mais nada, gostaria de dizer que há uma certa controvérsia por parte da comunidade envolvendo a linguagem Java. Alguns programadores acreditam que o Java oferece recursos poderosos e uma vasta biblioteca de estruturas de dados prontas para uso. Outros, porém, argumentam que a implementação dessas estruturas em Java pode ser limitada e menos eficiente em comparação com outras linguagens.

Neste post, vamos mergulhar nessa controvérsia e explorar as estruturas de dados em Java. Vamos analisar as principais estruturas, como pilhas e filas.
Nos seguintes exemplos estarei usando o conceito de vetores usando a classe Integer. Recomendo dar uma olhada antesa

Você não precisa ter medo de Java, é uma linguagem maravilhosa. Organize suas ideias, e no final, tudo vai dar certo.

Pilha

Vou usar o exemplo mais usado por todos: Imagine que você tem uma pilha de pratos em uma cozinha. Você coloca os pratos uns em cima dos outros, formando uma pilha vertical. Agora, se você quiser pegar um prato para usar, você deve pegar o que está no topo da pilha, certo? Você não pode pegar um prato que está no meio ou na base da pilha sem remover todos os pratos que estão acima dele primeiro.

Uma pilha de dados na programação é semelhante a essa pilha de pratos. É uma estrutura de dados em que você pode adicionar elementos ou remover elementos somente no topo da pilha. O elemento que foi adicionado mais recentemente é o primeiro a ser removido. Por causa dessa característica, chamamos essa estrutura de dados de "pilha" ou "stack" em inglês.

Podemos usar uma pilha em situações em que precisamos lembrar a ordem em que os elementos foram adicionados. Por exemplo, se você está escrevendo um editor de texto e deseja fornecer uma função "Desfazer", você pode usar uma pilha para armazenar as ações do usuário à medida que ele as realiza. Quando o usuário seleciona "Desfazer", a pilha permite que você desfaça as ações na ordem inversa em que foram feitas.

Em uma pilha, podemos adicionar um novo elemento no topo usando uma operação chamada "push" e remover o elemento do topo usando uma operação chamada "pop". Além disso, podemos verificar se a pilha está vazia e até mesmo ver o elemento no topo da pilha sem removê-lo.

Aqui está um breve código da implementação de uma Pilha. Explico mais depois do código.

public class Pilha {
    private Integer[] elementos;
    private int topo;

    public Pilha(int capacidade) {
        elementos = new Integer[capacidade];
        topo = -1; // Pilha vazia
    }

    public void push(int elemento) {
        if (isFull()) {
            throw new IllegalStateException("A pilha está cheia");
        }

        topo++;
        elementos[topo] = elemento;
    }

    public Integer pop() {
        if (isEmpty()) {
            throw new IllegalStateException("A pilha está vazia");
        }

        Integer elementoRemovido = elementos[topo];
        elementos[topo] = null; // Libera a referência do elemento removido
        topo--;

        return elementoRemovido;
    }

    public Integer peek() {
        if (isEmpty()) {
            throw new IllegalStateException("A pilha está vazia");
        }

        return elementos[topo];
    }

    public boolean isEmpty() {
        return topo == -1;
    }

    public boolean isFull() {
        return topo == elementos.length - 1;
    }
}

Nessa implementação, a classe Pilha possui um vetor chamado elementos que armazena os elementos da pilha e uma variável topo que indica a posição do elemento no topo da pilha.

A classe Pilha também possui os métodos principais:

O método push adiciona um elemento no topo da pilha. Ele verifica se a pilha está cheia utilizando o método isFull(), incrementa a variável topo e armazena o elemento no vetor elementos.
O método pop remove e retorna o elemento do topo da pilha. Ele verifica se a pilha está vazia utilizando o método isEmpty(), armazena o elemento a ser removido na variável elementoRemovido, libera a referência do elemento no vetor, decrementa a variável topo e retorna o elemento removido.
O método peek retorna o elemento do topo da pilha sem removê-lo. Ele verifica se a pilha está vazia utilizando o método isEmpty() e retorna o elemento no topo.
O método isEmpty verifica se a pilha está vazia, verificando se o topo é igual a -1¹.
O método isFull verifica se a pilha está cheia, verificando se o topo é igual ao tamanho máximo do vetor elementos menos 1².

¹. -1 é o valor de quando não tem nada em uma lista/vetor, então se não tem nada no vetor, ele está vazio.
². Imagine que você tem 5 pratos um em cima do outro, então você um vetor de 5 posições:
[0, 1, 2, 3, 4]
Todos os valores estão preenchidos, então o topo é 4 (o seu prato no topo é o último, logo: posição 4), se você quiser saber se a sua pilha está cheia, você calcula:

> topo == tamnhoMáximoVetor - 1
Seguindo a lógica, o topo é 4 (ultimo elemento) e o tamanho máximo do vetor é 5, logo:
> 4 == 5 - 1
> True

Aqui tem um breve diagrama que eu peguei da UFRJ

Que fala sobre pilhas.

Filas

Imagine uma fila de pessoas esperando para entrar em um cinema. Cada pessoa que chega se posiciona no final da fila, e a pessoa que está na frente é a próxima a entrar no cinema. Essa é a ideia básica de uma fila. Em desenvolvimento de software, uma fila é uma estrutura de dados semelhante. Ela segue o mesmo princípio da fila do cinema, onde os elementos são organizados em uma ordem específica. O elemento que chega primeiro é o primeiro a ser atendido ou processado.

Segue um breve código que implementa uma fila:

public class Fila {
    private Integer[] elementos;
    private int capacidade;
    private int inicio;
    private int fim;
    private int tamanho;

    public Fila(int capacidade) {
        this.capacidade = capacidade;
        elementos = new Integer[capacidade];
        inicio = 0;
        fim = -1;
        tamanho = 0;
    }

    public void enqueue(Integer elemento) {
        if (isFull()) {
            throw new IllegalStateException("A fila está cheia");
        }

        fim = (fim + 1) % capacidade;
        elementos[fim] = elemento;
        tamanho++;
    }

    public Integer dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("A fila está vazia");
        }

        int elementoRemovido = elementos[inicio];
        elementos[inicio] = 0; // Valor padrão para inteiros
        inicio = (inicio + 1) % capacidade;
        tamanho--;

        return elementoRemovido;
    }

    public Integer front() {
        if (isEmpty()) {
            throw new IllegalStateException("A fila está vazia");
        }

        return elementos[inicio];
    }

    public boolean isEmpty() {
        return tamanho == 0;
    }

    public boolean isFull() {
        return tamanho == capacidade;
    }
}

Nessa implementação, estamos utilizando o conceito de FIFO(Firt-In, First-Out), que em português signific: "o primeiro a entrar é o primeiro a sair". Esse conceito é usado em diversas situações do dia a dia, como quando estamos em uma fila de espera em um supermercado, banco ou parque de diversões.

A classe Fila possui um vetor chamado elementos para armazenar os elementos da fila, uma variável tamanho para controlar o número de elementos na fila, uma variável inicio para indicar o índice do primeiro elemento na fila, e uma variável fim para indicar o índice do último elemento na fila.

A classe Fila também possui os métodos principais:

O método enqueue adiciona um elemento no final da fila. Ele verifica se a fila está cheia utilizando o método isFull(), atualiza o valor de fim para apontar para o próximo índice disponível no vetor (levando em consideração a operação módulo), armazena o elemento no vetor elementos e incrementa o tamanho da fila.
O método dequeue remove e retorna o elemento no início da fila. Ele verifica se a fila está vazia utilizando o método isEmpty(), armazena o elemento a ser removido na variável elementoRemovido, libera a referência do elemento no vetor, atualiza o valor de inicio para apontar para o próximo elemento na fila (levando em consideração a operação módulo) e decrementa o tamanho da fila.
O método front retorna o elemento no início da fila sem removê-lo. Ele verifica se a fila está vazia utilizando o método isEmpty() e retorna o elemento no índice inicio.
O método isEmpty verifica se a fila está vazia, verificando se o tamanho é igual a 0.
O método isFull verifica se a fila está cheia, verificando se o tamanho é igual ao tamanho máximo do vetor elementos.

Segue um breve diagrama que eu peguei do Arquivo de Códigos, para exemplificar:

Como fazer tratamento de exceções globalmente em Java Spring Boot

José Paulo Marinho — Thu, 30 Mar 2023 13:21:58 +0000

Olá, Desenvolvedor(a), hoje estarei abordando um tema famoso:
Global Exception Handler ou Tratamento de Exceções Globais.

O que é uma Exceção?

Em Ciência da Computação, uma exceção é um evento que indica que algo inesperado ou não previsto ocorreu durante a execução de um programa. Quando uma exceção é lançada, isso indica que houve um problema em algum ponto do código e que algo precisa ser feito para lidar com essa situação de erro. O tratamento de exceções é uma técnica importante para garantir que o programa continue a funcionar de forma adequada e para fornecer feedback ao usuário ou ao sistema sobre o ocorrido. Em resumo, exceções são um mecanismo importante em programação para lidar com situações imprevistas e garantir a confiabilidade e a robustez do código.

Nesta publicação estarei trazendo formas de como tratar exceções globalmente em Java para uma API REST utilizando Spring, apesar de muitas linguagens de programação conterem suporte nativo para tratamento de exceções como Python, C++, PHP, .NET, Ruby e muitas outras.

Por que tratar exceções?

Imagine que você está utilizando uma biblioteca de terceiros, e durante a execução do seu programa, vem o seguinte erro:

ou até mesmo a chamada à uma API:

Que erro que deu aí? Será que esqueci de fazer algo ao chamar a API? Não passei alguma configuração na biblioteca?

São dúvidas que são levantadas quando vem uma exceção que não é bem tratada. Você deixa o usuário confuso, perdido. Com o passar do tempo, seu programa, que agora é legado, vai ficando difícil procurar os erros que ocorrem.

Imagine o seguinte cenário também: quando seu projeto está em produção e seu sistema "loga" o problema deste jeito, dependendo do problema, tem que resolver rápido, e agora?

Tratar exceções é de suma importância para o desenvolvimento de software, pois permite que um programa lide melhor com os erros sem dar tiro no escuro. Ajuda a identificar problemas com mais agilidade e corrigi-los.

Como funciona uma Exceção em Java?

Em Java, Exceções são representados por objetos que são criados e lançados durante a execução de um programa. Lembrando que não afeta nada no hardware, quando ocorre um erro no hardware ou no sistema operacional, geralmente é lançado um código de erro específico (um número diferente de 0) que é retornado ao sistema operacional ou à aplicação que está interagindo com o hardware. Esse código de erro pode ser usado para tomar ações apropriadas, como exibir uma mensagem de erro ao usuário, registrar o erro em um arquivo de log ou tentar corrigir o erro automaticamente.

Em Java, as exceções são usadas para sinalizar erros específicos que ocorrem durante a execução do programa, como tentar acessar uma posição inválida em um array ou chamar um método em um objeto nulo. Cada tipo de exceção tem uma classe correspondente em Java que é usada para criar e lançar a exceção.

Nós iremos fazer um pouco diferente das exceções já nativas, vamos criar as nossas.

Iniciando o tratamento

Para isso iremos definir um modelo de negócio, no qual terá um classe customizada de exceção:

code: código da nossa exceção, importante se formos querer documentar o código.
message: mensagem que vai explicar nossa exceção.

Exemplo: 001 - Token Expirado

Ficando:

public class ExceptionCustomized extends RuntimeException{
    private String code;
    private String message;

    public ExceptionCustomized(String code, String message) {
        super();
        this.code = code;
        this.message = message;
    }

    // Getters and Setters
}

Vamos definir mais algumas regras de negócio, que seriam os tipos das exceções, podendo ser:

BusinessException: exceção de regra de negócio;
TechinalException: exceção técnica.

Vou adicionar mais uma, opcional, que é a:

NotFoundException: indica que algo não foi encontrado

Cada uma delas terá uma classe que herdará da classe pai ExceptionCustomized, ficando:

public class BusinessException extends ExceptionCustomized{
    public BusinessException(String code, String message) {
        super(code, message);
    }
}

public class TechnicalException extends ExceptionCustomized{
    public TechnicalException(String code, String message) {
        super(code, message);
    }
}

public class NotFoundException extends ExceptionCustomized{
    public NotFoundException(String code, String message) {
        super(code, message);
    }
}

Certo. Agora que definimos nossa regra de negócio, podemos partir para a brincadeira de verdade. Iremos criar outra classe que será responsável por todo o tratamento de exceções na aplicação, de qualquer camada, iremos anotar ela com a anotação @ControllerAdvice.

Nesta classe vamos criar um método que vai retornar um objeto do tipo ResponseEntity chamado exceptionHandling que vai receber o objeto:
Exception, anotando ela com a anotação ExceptionHandler passando o nosso objeto de ExceptionCustomized, porque desta forma, especificamos qual método o Spring Framework precisa chamar ao lançar a exceção. Ficando assim:

@ControllerAdvice
public class GlobalExceptionHandling extends ResponseEntityExceptionHandler {

    @ExceptionHandler(ExceptionCustomized.class)
    public final ResponseEntity<Object> expectionHandling(Exception ex) {

    }
}

Agora vamos tratar os tipos de exceção, como iremos retornar um objeto do tipo ResponseEntity precisamos dizer qual status code vai retornar, sendo para:

BusinessException: 412
NotFoundException: 404
TechnicalException: 512

Ficando assim:

@ExceptionHandler(ExceptionCustomized.class)
    public final ResponseEntity<Object> expectionHandling(Exception ex) {
        int statusCode = 0;

        if (ex instanceof BusinessException)
            statusCode = HttpStatus.UNPROCESSABLE_ENTITY.value();
        else if(ex instanceof NotFoundException)
            statusCode = HttpStatus.NOT_FOUND.value();
        else if(ex instanceof TechnicalException)
            statusCode = 512;
        else {
            statusCode = HttpStatus.INTERNAL_SERVER_ERROR.value();
            return new ResponseEntity(new ErrorResponse(String.valueOf(statusCode), "An unexpected error has occurred"), HttpStatus.valueOf(statusCode));
        }

        return new ResponseEntity<>(new ErrorResponse(((ExceptionCustomized) ex).getCode(), ex.getMessage()), HttpStatus.valueOf(statusCode));
    }

Criamos um objeto de ErrorResponse para respeitar o tipo de modelagem DDD, uma das abordagens de desenvolvimento de software.

Testando

Iremos criar uma classe de domínio usuário para posteriormente simular uma base de dados de usuário:

public class Usuario {

    private String usuario;
    private Double altura;

    public Usuario(String usuario, Double altura) {
        this.usuario = usuario;
        this.altura = altura;
    }

    // Getters and Setters
}

Iremos criar um método que inicializará uma lista de Usuários para simular um banco de dados.

 public List<Usuario> inicializarLista() {
    List<Usuario> listaUsuarios = new ArrayList<>();
    listaUsuarios.add(new Usuario("José", 1.78));
    listaUsuarios.add(new Usuario("Paulo", 1.79));
    return listaUsuarios;
 }

Agora vamos criar um método para procurar pelo usuário na lista de usuários:

public Usuario procurarUsuarioPeloNome(String nomeUsuario) {
        var listaUsuarios = this.inicializarLista();
        for (Usuario usuario : listaUsuarios) {
            if (nomeUsuario.equals(usuario.getUsuario()))
                return usuario;
        }

        throw new UsuarioNaoEncontradoException(nomeUsuario);
    }

Notaram algo diferente? Existe uma linha conténdo o algoritmo:
throw new UsuarioNaoEncontradoException(nomeUsuario);
Se você perceber, no Java nativamente não existe essa exceção, então vamos criar:

public class UsuarioNaoEncontradoException extends NotFoundException {
    public UsuarioNaoEncontradoException(String usuario) {
        super("001", String.format("Usuário %s não encontrado", usuario));
    }
}

Legal, né? Todas as exceções que lançarmos do tipo UsuarioNaoEncontradoException irá conter o código 001 e uma breve descrição de qual usuário não foi encontrado.

Vamos adicionar o seguinte código a uma controller:

@GetMapping
    public ResponseEntity procurarUsuario(@RequestParam("usuario") String usuario) {
        return ResponseEntity.status(200).body(procurarUsuarioPeloNome(usuario));
    }

Pronto, agora só executar.

Uma execução passando um usuário que existe:

Uma execução passando um usuário que não existe:

Essa foi uma das muitas formas de Tratamento de exceções Globais, espero que tenham gostado!

O código fonte pode ser encontrado em:
https://github.com/jusebandtec/global-exception-handler

Até mais.

DEV Community: José Paulo Marinho

Como criar uma "busca inteligente" para seu Wiki utilizando Go e ElasticSearch

Motor de busca

Preparando o ambiente Go

Lendo arquivos Markdown

Indexando os arquivos no ElasticSearch

Realizando buscas no elasticsearch

1. Consulta simples por palavra-chave

2. Executando a busca em Go

Servidor WEB

Como implementar Feature Flags em seu Backend NestJS

Como iniciar um aplicativo Spring Boot + JPA + MySQL

Criação do Projeto

Primeira execução

Criação de Entidades

Criação dos Repositórios utilizando JPA

Enums em C#: Simplificando a Gestão de Constantes

Enum em C#

Compilador

Memória

Enum para String ou vice Versa

ToString()

Enum.GetName()

nameof()

Convertendo string para Enum

Enum.Parse()

Enum.TryParse()

Como funciona um Load Balance e como implementar utilizando Nginx.

O que é um Load Balance e para que serve?

Como implementar um Load Balance?

Arquitetura

Implementação

Servidor 1:

Servidor 2

Otimize seu Aplicativo com Cache de Dados usando NestJS e Redis

Desenho da arquitetura

Iniciando o Projeto

Redis em Ação

Como publicar uma notificação de Evento para o SQS quando algo for publicado no S3: Um guia passo a passo

Passo 1: Crie uma política de acesso para a sua fila

Passo 2 - Obtenha as credenciais de acesso para a sua aplicação

Passo 3: Use as credenciais para enviar mensagens para a fila do SQS

Configurar Notificações de Eventos no S3 para enviar ao SQS

Lib HttpClient Utils: Uma biblioteca Java para simplificar requisições HTTP

1. Importação da Biblioteca

2. Exemplo

2.1 Fazendo a requisição

Explorando Estruturas de Dados em Java: Pilhas e Filas

Pilha

Filas

Como fazer tratamento de exceções globalmente em Java Spring Boot

O que é uma Exceção?

Por que tratar exceções?

Como funciona uma Exceção em Java?

Iniciando o tratamento

Testando

Pronto, agora só executar.

Enum em `C#`