Programmation réactive en Go (Golang) : bibliothèques, modèles et exemples

Programmation réactive en Go (Golang)

La programmation réactive est un paradigme orienté vers les flux de données asynchrones et la propagation des changements. En langage Go (Golang), ce concept trouve une implémentation naturelle grâce aux goroutines et canaux intégrés. Cependant, pour des scénarios complexes, il existe des bibliothèques spécialisées qui fournissent des outils puissants pour travailler avec des flux réactifs.

Dans cet article, nous examinerons les principales bibliothèques de programmation réactive en Go, leurs capacités et des exemples d'utilisation. Ce contenu sera utile aussi bien aux débutants qu'aux développeurs expérimentés souhaitant intégrer des approches réactives dans leurs projets.

Concepts clés de la programmation réactive

Avant de passer aux outils, il est important de comprendre les termes clés :

• Observable — source de données pouvant générer des événements.
• Observer — abonné qui réagit aux événements.
• Opérateurs — fonctions pour transformer, filtrer et combiner des flux (map, filter, merge, flatMap).
• Backpressure — mécanisme de gestion de la vitesse de transfert des données entre le producteur et le consommateur.

Bibliothèque RxGo (Reactive Extensions for Go)

RxGo est l'implémentation la plus populaire des extensions réactives pour Go. Elle porte les concepts de RxJava/RxJS en les adaptant aux particularités du langage (goroutines, absence d'héritage).

Installation :

go get github.com/reactivex/rxgo/v2

Exemple : Observable de base

package main

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

func main() {    // Création d'un Observable à partir d'une liste    observable := rxgo.Just(1, 2, 3, 4, 5)()

    // Abonnement et affichage des éléments    ch := observable.Observe()    for item := range ch {        fmt.Println(item.V)    }}

Exemple : transformation avec opérateurs

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) // Affichage : 6, 8, 10    }}

Bibliothèque go-reactive

go-reactive est une alternative légère à RxGo, axée sur la simplicité et les performances. Elle utilise les canaux Go comme base pour les flux réactifs.

Installation :

go get github.com/teivah/go-reactive

Exemple : flux réactif avec canaux

package main

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

func main() {    // Création d'un flux de nombres    stream := reactive.FromSlice([]int{10, 20, 30, 40, 50})

    // Application des opérateurs    result := stream.        Filter(func(i int) bool { return i > 20 }).        Map(func(i int) int { return i * 3 })

    // Obtention du résultat    for v := range result.Out() {        fmt.Println(v) // Affichage : 90, 120, 150    }}

Programmation réactive avec les canaux natifs

Go permet d'implémenter des modèles réactifs sans bibliothèques tierces, en utilisant les goroutines et les canaux. Cela est particulièrement utile pour des scénarios simples.

Exemple : modèle Observer avec canaux

package main

import (    "fmt"    "time")

type Event struct {    Data string}

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

// Observer — observateurfunc Ob