RxSwift — o que é, recursos e programação reativa

O que é RxSwift?

RxSwift é o port Swift da biblioteca ReactiveX (Rx) criada pela Microsoft para .NET em 2012. A ideia central do Rx é representar qualquer fonte de dados assíncrona como uma sequência Observable à qual operadores funcionais podem ser aplicados. No desenvolvimento iOS, o RxSwift é usado para vincular eventos de UI (toques em botões, entrada de texto, gestos) à lógica do aplicativo sem delegates explícitos e target-action.

A biblioteca consiste em três módulos: RxSwift (núcleo — Observable, Operator, Scheduler), RxCocoa (integração com UIKit — extensões rx para UIButton, UITextField, UITableView) e RxRelay (Subject sem eventos terminais). Essa separação permite usar o núcleo em Swift do lado do servidor e em testes, conectando o wrapper de UI apenas para aplicativos iOS.

De acordo com a pesquisa Stack Overflow, 2025, o RxSwift está entre as 5 bibliotecas de terceiros mais usadas para iOS. A principal razão de sua popularidade é o tratamento uniforme de todos os padrões assíncronos: requisições de rede via URLSession, animações via UIViewPropertyAnimator, notificações via NotificationCenter e delegates via DelegateProxy — tudo se resume a um Observable com ciclo de vida previsível.

Filosofia da programação reativa

Programação reativa é um paradigma no qual o programa reage a mudanças de dados em vez de consultá-los. Em vez de escrever “obter dados → processar → atualizar UI”, o desenvolvedor descreve uma cadeia de transformações: “quando os dados mudarem, aplicar filtro, depois map, depois atualizar UI”. RxSwift implementa esse paradigma por meio de cadeias Observable com execução preguiçosa — nada acontece até que um assinante apareça.

Componentes-chave do RxSwift: Observable, Subject, Disposable

Observable é o tipo fundamental do RxSwift que representa uma sequência de eventos ao longo do tempo. Observable pode enviar três tipos de eventos: next (novo valor), error (erro que encerra o fluxo) e completed (conclusão bem-sucedida). Existem Observable finitos (concluem após enviar todos os valores) e Observable infinitos (por exemplo, eventos de UI — nunca concluem).

Observable e seu ciclo de vida

O ciclo de vida de um Observable inclui três estágios: criação (create, just, from), transformação (operadores map, filter, flatMap) e assinatura (subscribe). Sem uma assinatura, Observable não executa nenhuma ação — é uma sequência preguiçosa. Após a assinatura, Observable começa a enviar eventos ao assinante até ser concluído ou o assinante cancelar a assinatura via Disposable.

import RxSwift

// Criar Observable a partir de array
let numbers = Observable.from([1, 2, 3, 4, 5])

// Transformação por meio de operadores
let squared = numbers
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }

// Assinatura com tratamento de eventos
let disposable = squared
    .subscribe(onNext: { print($0) },
               onError: { print("Error: \($0)") },
               onCompleted: { print("Done") })

Subject é um tipo que é tanto um Observable (pode ser assinado) quanto um Observer (pode receber eventos). RxSwift fornece quatro tipos de Subject: PublishSubject (apenas novos eventos), BehaviorSubject (com um valor inicial), ReplaySubject (armazena em buffer os últimos N eventos) e AsyncSubject (apenas o último valor antes da conclusão). Subject é útil para integrar código imperativo (closures, delegates) em uma cadeia reativa.

Disposable é um token de cancelamento de assinatura. Quando o assinante não deseja mais receber eventos, ele chama disposable.dispose(). Na prática, usa-se DisposeBag: uma coleção de Disposable que cancela automaticamente todas as assinaturas ao desinicializar o proprietário (por exemplo, UIViewController). Isso evita vazamentos de memória inevitáveis com o gerenciamento manual de assinaturas.

Operadores de transformação e filtragem de fluxos

Os operadores no RxSwift são funções que recebem um Observable e retornam outro Observable, transformando o fluxo de dados. Combinando operadores, o desenvolvedor constrói cadeias de processamento declarativas sem variáveis intermediárias e condições de corrida. Todos os operadores são preguiçosos: a cadeia é construída na descrição e executada na assinatura.

Os operadores de transformação alteram cada evento no fluxo. map aplica uma função a cada elemento, flatMap desdobra Observable de cada elemento em um único fluxo plano, scan acumula resultados intermediários (similar a reduce, mas emitindo cada etapa). buffer agrupa elementos por tempo ou quantidade, window divide o fluxo em Observable aninhados por janelas.

// Exemplo de cadeia de operadores: busca com debounce
searchTextField.rx.text
    .orEmpty
    .debounce(.milliseconds(300), scheduler: MainScheduler.instance)
    .distinctUntilChanged()
    .flatMapLatest { query -> Observable<[String]> in
        return apiService.search(query)
    }
    .bind(to: tableView.rx.items(cellIdentifier: "Cell")) { _, item, cell in
        cell.textLabel?.text = item
    }
    .disposed(by: disposeBag)

Os operadores de filtragem apenas permitem a passagem de eventos que satisfaçam uma condição. filter filtra por predicado, distinctUntilChanged apenas passa valores diferentes do anterior, take e takeWhile limitam o número de eventos. skip e skipWhile pulam os primeiros N eventos ou eventos até que uma condição seja atendida. Para tratamento de erros, usam-se catchError (interceptar e substituir) e retry (repetir sequência em caso de erro).

Os operadores de combinação combinam vários Observable em um. combineLatest mescla os últimos valores de vários fluxos em uma tupla, zip emparelha elementos com os mesmos índices, merge combina vários fluxos em um na ordem de chegada dos eventos. withLatestFrom combina um evento do fluxo principal com o último valor de outro fluxo — útil para eventos de UI com estado atual.

Schedulers e gerenciamento de threads

Scheduler no RxSwift é uma abstração sobre a thread de execução (ou fila). Scheduler determina em qual thread a criação de eventos, transformação e assinatura são executadas. Ao contrário do GCD, onde o desenvolvedor especifica explicitamente DispatchQueue, o RxSwift usa dois parâmetros: subscribeOn (em qual thread o Observable executa) e observeOn (em qual thread o assinante é chamado).

MainScheduler e BackgroundScheduler

MainScheduler executa código na thread principal — obrigatório para atualizações UIKit (todas as alterações de UI devem ocorrer na thread principal). SerialDispatchQueueScheduler envolve uma fila GCD serial, ConcurrentDispatchQueueScheduler envolve uma fila concorrente. Para tarefas em segundo plano, usa-se ConcurrentDispatchQueueScheduler com qos: .background ou .utility.

// Padrão típico: trabalho em segundo plano + UI na main
apiService.fetchData()
    .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { data in
        self.tableView.reloadData()
        self.loadingIndicator.stopAnimating()
    })
    .disposed(by: disposeBag)

O uso correto de Scheduler evita o bloqueio da UI durante requisições de rede e cálculos pesados. subscribeOn afeta todo o upstream (todos os operadores antes de observeOn executam no agendador especificado). observeOn alterna o downstream — todos os operadores após observeOn executam no agendador especificado. Uma cadeia pode ter vários observeOn para alternar entre threads em diferentes estágios de transformação.

SerialDispatchQueueScheduler garante o processamento sequencial de eventos, o que é importante para a segurança de threads de recursos compartilhados. Para operações de alta carga (processamento de imagens, análise JSON) use ConcurrentDispatchQueueScheduler — RxSwift preservará a ordem dos eventos dentro de um Observable, mas diferentes Observable podem ser processados em paralelo.

Aplicação prática do RxSwift em iOS

RxSwift em projetos iOS é mais frequentemente usado para vincular a UI aos dados por meio de cadeias reativas. RxCocoa fornece extensões rx para todos os componentes UIKit padrão: rx.tap para UIButton, rx.text para UITextField, rx.selectedRow para UIPickerView. Isso permite abandonar @IBAction e delegates, substituindo-os por assinaturas declarativas.

RxSwift com MVVM

MVVM (Model-View-ViewModel) é um padrão arquitetural no qual o ViewModel gerencia o estado e a lógica de negócios, e a View assina as propriedades reativas do ViewModel. RxSwift se encaixa perfeitamente com MVVM: ViewModel publica Observable ou Driver para os dados, a View assina eles via bind. ViewModel não tem referência à View — retorna Observable que a View consome.

class LoginViewModel {
    let email = BehaviorRelay<String>(value: "")
    let password = BehaviorRelay<String>(value: "")

    var isFormValid: Observable<Bool> {
        return Observable
            .combineLatest(email, password) {
                !$0.isEmpty && $0.contains("@") && $1.count >= 6
            }
    }
}

// Em ViewController:
viewModel.isFormValid
    .bind(to: loginButton.rx.isEnabled)
    .disposed(by: disposeBag)

Requisições de rede são o segundo caso de uso mais comum do RxSwift. URLSession.rx.response envolve uma requisição HTTP em um Observable que retorna (response, data) em caso de sucesso ou error em caso de falha. Em combinação com Codable e o operador map, obtém-se uma camada de API reativa compacta: Observable<MyModel> sem callbacks e tratamento de erros em cada método. Em caso de erro de rede, o operador retry(3) tenta novamente a requisição automaticamente três vezes com backoff exponencial.

RxSwift vs Combine

Combine é o framework nativo da Apple apresentado no iOS 13. Ele resolve as mesmas tarefas que o RxSwift: trabalhar com eventos assíncronos por meio de Publisher, Subscriber e operadores. No entanto, o Combine tem diferenças-chave: tipagem estrita de erros por meio do tipo Failure, suporte nativo a Swift Concurrency (async/await) e integração com SwiftUI por meio de @Published e ObservableObject.

RxSwift vence em compatibilidade reversa — suporta iOS 8+, enquanto o Combine requer iOS 13+. RxSwift tem um ecossistema mais rico de extensões de terceiros (RxDataSources, RxGesture, RxAnimated) e documentação detalhada de operadores. Para projetos que suportam versões antigas do iOS, o RxSwift continua sendo a única escolha.

Para novos projetos com iOS 13+, a Apple recomenda o Combine. Ele é fortemente integrado com SwiftUI, tem tamanho binário menor e suporte oficial. No entanto, migrar código RxSwift existente para o Combine requer reescrever todos os Observable → Publisher, e o ecossistema RxCocoa não tem equivalente completo no Combine — UIKit não tem Publisher nativo para todos os componentes de UI.