Programación reactiva en Go (Golang): bibliotecas, patrones y ejemplos

Programación reactiva en Go (Golang)

La programación reactiva es un paradigma orientado a flujos de datos asíncronos y la propagación de cambios. En el lenguaje Go (Golang), este concepto encuentra una implementación natural gracias a las gorutinas y canales integrados. Sin embargo, para escenarios complejos, existen bibliotecas especializadas que proporcionan potentes herramientas para trabajar con flujos reactivos.

En este artículo, exploraremos las principales bibliotecas para programación reactiva en Go, sus capacidades y ejemplos de uso. El material será útil tanto para principiantes como para desarrolladores experimentados que deseen incorporar enfoques reactivos en sus proyectos.

Conceptos clave de la programación reactiva

Antes de pasar a las herramientas, es importante comprender los términos clave:

• Observable — fuente de datos que puede generar eventos.
• Observer — suscriptor que reacciona a los eventos.
• Operadores — funciones para transformar, filtrar y combinar flujos (map, filter, merge, flatMap).
• Backpressure — mecanismo para controlar la velocidad de transferencia de datos entre productor y consumidor.

Biblioteca RxGo (Reactive Extensions for Go)

RxGo es la implementación más popular de extensiones reactivas para Go. Porta los conceptos de RxJava/RxJS, adaptándolos a las particularidades del lenguaje (gorutinas, ausencia de herencia).

Instalación:

go get github.com/reactivex/rxgo/v2

Ejemplo: Observable básico

package main

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

func main() {    // Creamos un Observable a partir de una lista    observable := rxgo.Just(1, 2, 3, 4, 5)()

    // Nos suscribimos e imprimimos los elementos    ch := observable.Observe()    for item := range ch {        fmt.Println(item.V)    }}

Ejemplo: transformación con 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) // Salida: 6, 8, 10    }}

Biblioteca go-reactive

go-reactive es una alternativa ligera a RxGo, enfocada en la simplicidad y el rendimiento. Utiliza los canales de Go como base para flujos reactivos.

Instalación:

go get github.com/teivah/go-reactive

Ejemplo: flujo reactivo con canales

package main

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

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

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

    // Obtenemos el resultado    for v := range result.Out() {        fmt.Println(v) // Salida: 90, 120, 150    }}

Programación reactiva con canales nativos

Go permite implementar patrones reactivos sin bibliotecas externas, utilizando gorutinas y canales. Esto es especialmente útil para escenarios simples.

Ejemplo: patrón Observer con canales

package main

import (    "fmt"    "time")

type Event struct {    Data string}

// Subject — objeto observablefunc 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