Programação Reativa em Go (Golang): bibliotecas, padrões e exemplos

Programação Reativa em Go (Golang)

Programação reativa é um paradigma orientado a fluxos de dados assíncronos e propagação de mudanças. Na linguagem Go (Golang), este conceito encontra uma implementação natural graças às goroutines e canais integrados. No entanto, para cenários complexos, existem bibliotecas especializadas que fornecem ferramentas poderosas para trabalhar com fluxos reativos.

Neste artigo, exploraremos as principais bibliotecas para programação reativa em Go, suas capacidades e exemplos de uso. O material será útil tanto para iniciantes quanto para desenvolvedores experientes que desejam incorporar abordagens reativas em seus projetos.

Conceitos fundamentais da programação reativa

Antes de passar às ferramentas, é importante entender os termos-chave:

• Observable — fonte de dados que pode gerar eventos.
• Observer — assinante que reage aos eventos.
• Operadores — funções para transformar, filtrar e combinar fluxos (map, filter, merge, flatMap).
• Backpressure — mecanismo para controlar a velocidade de transferência de dados entre produtor e consumidor.

Biblioteca RxGo (Reactive Extensions for Go)

RxGo é a implementação mais popular de extensões reativas para Go. Ela porta conceitos do RxJava/RxJS, adaptando-os às particularidades da linguagem (goroutines, ausência de herança).

Instalação:

go get github.com/reactivex/rxgo/v2

Exemplo: Observable básico

package main

import (    "fmt"    "github.com/reactivex/rxgo/v2")

func main() {    // Criando um Observable a partir de uma lista    observable := rxgo.Just(1, 2, 3, 4, 5)()

    // Inscrevendo-se e exibindo os elementos    ch := observable.Observe()    for item := range ch {        fmt.Println(item.V)    }}

Exemplo: transformação com operadores

package main

import (    "fmt"    "github.com/reactivex/rxgo/v2")

func main() {    observable := rxgo.Just(1, 2, 3, 4, 5)().        Map(func(item rxgo.Item) rxgo.Item {            val := item.V.(int)            return rxgo.Of(val * 2)        }).        Filter(func(item rxgo.Item) bool {            return item.V.(int) > 5        })

    for item := range observable.Observe() {        fmt.Println(item.V) // Saída: 6, 8, 10    }}

Biblioteca go-reactive

go-reactive é uma alternativa leve ao RxGo, focada em simplicidade e desempenho. Ela usa canais Go como base para fluxos reativos.

Instalação:

go get github.com/teivah/go-reactive

Exemplo: fluxo reativo com canais

package main

import (    "fmt"    "github.com/teivah/go-reactive")

func main() {    // Criando um fluxo de números    stream := reactive.FromSlice([]int{10, 20, 30, 40, 50})

    // Aplicando operadores    result := stream.        Filter(func(i int) bool { return i > 20 }).        Map(func(i int) int { return i * 3 })

    // Obtendo o resultado    for v := range result.Out() {        fmt.Println(v) // Saída: 90, 120, 150    }}

Programação reativa com canais nativos

Go permite implementar padrões reativos sem bibliotecas de terceiros, usando goroutines e canais. Isso é especialmente útil para cenários simples.

Exemplo: padrão Observer com canais

package main

import (    "fmt"    "time")

type Event struct {    Data string}

// Subject — objeto observávelfunc Subject(out chan<- Event) {    for i := 0; i < 5; i++ {        out <- Event{Data: fmt.Sprintf("Evento #%d", i)}        time.Sleep(100 * time.Millisecond)    }    close(out)}

// Observer — observadorfunc Ob