Programação Reativa em Kotlin: RxKotlin e Corrotinas |…

Programação Reativa em Kotlin: do RxKotlin às Corrotinas

Programação reativa é um paradigma focado no processamento assíncrono de fluxos de dados e na propagação de mudanças. No ecossistema Kotlin, esse conceito é implementado de duas formas principais: através da biblioteca RxKotlin (extensões reativas para Kotlin baseadas no RxJava) e através do mecanismo nativo de corrotinas com Flow. Neste artigo, analisaremos detalhadamente ambas as abordagens, suas características e exemplos de uso.

O que é Programação Reativa?

A ideia central da programação reativa é trabalhar com dados como fluxos contínuos (streams). Em vez de solicitar dados e aguardar uma resposta, você se inscreve em um fluxo e reage a cada novo evento. Isso é especialmente útil para aplicações de UI, processamento de entrada do usuário, requisições de rede e trabalho com bancos de dados.

Biblioteca RxKotlin

RxKotlin é um wrapper sobre o RxJava que adiciona extensões convenientes para Kotlin, como lambdas, funções de extensão e suporte a null-safety. Os principais tipos são:

Observable<T> — um fluxo que pode emitir de 0 a N elementos e terminar com erro ou sucesso.
Single<T> — um fluxo que emite exatamente um elemento ou um erro.
Flowable<T> — um fluxo com suporte a backpressure (controle de velocidade de consumo).
Completable — um fluxo que apenas termina (sucesso/erro) sem dados.

Exemplo com RxKotlin

import io.reactivex.rxjava3.core.Observableimport io.reactivex.rxjava3.schedulers.Schedulers

fun main() {    val observable = Observable.create<String> { emitter ->        emitter.onNext("Olá")        emitter.onNext("do")        emitter.onNext("RxKotlin")        emitter.onComplete()    }

    observable        .subscribeOn(Schedulers.io())        .observeOn(Schedulers.single())        .subscribe(            { value -> println("Recebido: $value") },            { error -> println("Erro: ${error.message}") },            { println("Fluxo concluído") }        )

    Thread.sleep(1000) // Aguarda a conclusão das operações assíncronas}

Neste exemplo, é criado um Observable que emite três strings e é concluído. Os operadores subscribeOn e observeOn gerenciam as threads de execução.

Corrotinas e Flow em Kotlin

A partir do Kotlin 1.3, as corrotinas tornaram-se parte da linguagem, e o Flow (introduzido na versão 1.3.70) é um fluxo reativo totalmente integrado com corrotinas. Vantagens sobre o RxKotlin:

Menos overhead (corrotinas leves vs threads Java).
Integração natural com funções suspend.
Suporte a structured concurrency (cancelamento automático ao finalizar o escopo).
Sintaxe mais limpa, sem callbacks.

Exemplo com Flow

import kotlinx.coroutines.*import kotlinx.coroutines.flow.*

fun main() = runBlocking {    val flow = flow {        for (i in 1..5) {            delay(100) // Simula trabalho assíncrono            emit(i)    // Emite um elemento        }    }

    flow        .map { it * it } // Transformação        .catch { e -> println("Erro: $e") }        .collect { value -> println("Quadrado: $value") }}

O Flow é preguiçoso: os dados começam a ser gerados apenas quando collect é chamado. Operadores como map, filter, flatMapConcat funcionam da mesma forma que no Rx.