RxSwift — o que é, conceitos-chave e programação reativa

O que é RxSwift?

RxSwift é uma biblioteca de programação reativa para a linguagem Swift, portada do Reactive Extensions (Rx). Ela permite descrever programas assíncronos e orientados a eventos através de Observable Sequence — uma sequência de dados disponível ao longo do tempo. Desenvolvedores iOS usam RxSwift para lidar com requisições de rede, eventos de UI e dados em streaming sem callbacks aninhados.

Observable e Observer

A base do RxSwift consiste em dois protocolos-chave: ObservableType — uma fonte de eventos que pode emitir três tipos de sinais: .next(value), .error(error) e .completed. Observer se inscreve no Observable através do método subscribe e recebe esses eventos. Esse modelo é chamado de Reactive Streams e garante que nenhum evento seja perdido com uma inscrição correta.

Operadores de transformação

RxSwift fornece mais de 300 operadores para trabalhar com fluxos: map transforma cada evento, filter passa apenas os que correspondem, flatMap desdobra Observables aninhados em um único fluxo. Operadores são encadeados, criando um pipeline declarativo de processamento de dados sem efeitos colaterais.

Traits: Single, Completable, Maybe

Além do Observable básico, RxSwift fornece tipos wrapper especializados. Single emite exatamente um valor ou um erro — ideal para requisições HTTP. Completable conclui com sucesso ou falha sem valor — para operações de gravação. Maybe combina ambos os cenários: pode concluir com valor, sem valor ou com erro. Esses Traits simplificam a semântica e tornam o código autodocumentável.

Como a programação reativa funciona no RxSwift

A programação reativa no RxSwift é construída sobre o padrão Observer. ObservableSequence é análogo ao Sequence da biblioteca padrão, mas com acesso assíncrono aos elementos. O fluxo de eventos é passado por uma cadeia de operadores, cada um retornando uma nova ObservableSequence sem mutar a original.

Cadeias de operadores

Operadores no RxSwift são funções puras que recebem uma ObservableSequence e retornam uma nova. Por exemplo, map cria uma nova sequência aplicando uma transformação a cada elemento. Combinando operadores, o desenvolvedor constrói um pipeline onde os dados passam por todas as etapas de processamento sem variáveis intermediárias.

Schedulers e threads de execução

Schedulers são uma abstração sobre threads de execução no RxSwift. Um Scheduler determina em qual thread o código será executado: MainScheduler — a thread de UI, SerialDispatchQueueScheduler — uma fila em segundo plano. Os operadores subscribeOn e observeOn especificam onde o trabalho é realizado e onde os resultados são processados, respectivamente.

Componentes principais do RxSwift

RxSwift inclui vários tipos básicos, cada um resolvendo sua própria tarefa no pipeline reativo. Single é um Observable que emite exatamente um valor ou erro, conveniente para requisições de rede. Completable conclui com sucesso ou falha sem valor. Maybe combina as propriedades de Single e Completable.

Subject e Relay

Subject é um Observable quente que também atua como Observer. PublishSubject emite apenas novos eventos para os inscritos, BehaviorSubject — o último evento mais os novos. Relay é uma variante de Subject que não emite .error ou .completed, garantindo a continuidade do fluxo. BehaviorRelay armazena o valor atual e é adequado para UI orientada a estado.

DisposeBag

DisposeBag é uma coleção de Disposables que cancela automaticamente todas as inscrições ao ser desalocada. No iOS, DisposeBag é normalmente adicionada a UIViewController ou UIView. Quando a tela é fechada, DisposeBag é limpa — isso evita vazamentos de memória e acesso a elementos de UI inexistentes.

Exemplos de código RxSwift

Abaixo está um exemplo de criação de Observable a partir de um array de dados usando o operador map para transformar strings:

let observable = Observable.of("Swift", "RxSwift", "Reactive")

observable
    .map { $0.uppercased() }
    .subscribe(onNext: { value in
        print("Received: \(value)")
    })
    .disposed(by: disposeBag)

O segundo exemplo demonstra a combinação de duas requisições de rede usando zip — o operador espera até que ambos os Observáveis emitam um valor e combina os resultados em uma tupla:

let first = fetchUser(id: "123")
let second = fetchPosts(userId: "123")

Observable
    .zip(first, second)
    .observe(on: MainScheduler.instance)
    .subscribe(onNext: { user, posts in
        updateUI(user: user, posts: posts)
    })
    .disposed(by: disposeBag)

O terceiro exemplo mostra o uso de BehaviorRelay para armazenar estado e atualizar automaticamente a UI nas mudanças: cada alteração state.accept() é imediatamente transmitida aos inscritos, o que é ideal para padrões de Estado na arquitetura MVVM.

let state = BehaviorRelay(value: "idle")

state
    .subscribe(onNext: { status in
        print("Status: \(status)")
    })
    .disposed(by: disposeBag)

state.accept("loading") // Prints: Status: loading

RxSwift vs outras abordagens

RxSwift difere dos métodos assíncronos tradicionais (Delegation, NotificationCenter, Callback) por sua natureza declarativa e capacidade de composição. Ao contrário do Combine, RxSwift suporta iOS 9+ e tem mais operadores. No entanto, Combine é integrado ao Foundation e SwiftUI no nível da linguagem, dando-lhe vantagem em novos projetos Apple.

A principal vantagem do RxSwift sobre o GCD (Grand Central Dispatch) é a capacidade de combinar e transformar fluxos de dados no nível de abstração, em vez de gerenciar filas manualmente. No entanto, RxSwift requer aprendizado de conceitos reativos, o que aumenta a barreira de entrada para a equipe.

Na prática, RxSwift é usado em grandes projetos onde cadeias reativas conectam eventos de UI, lógica de negócios e interação de rede em um único pipeline. Por exemplo, em aplicações de trading, fluxos de cotações são processados via RxSwift: ticks chegam do WebSocket, passam por filtragem, são agrupados por timeframe e exibidos em um gráfico em tempo real. Esse cenário é difícil de implementar via Delegation ou NotificationCenter sem perder legibilidade.

Alternativas ao RxSwift incluem Combine (iOS 13+), AsyncSequence do Swift Concurrency (iOS 15+), bem como bibliotecas de terceiros como ReactiveSwift sem vínculo com plataformas Apple. A escolha depende da versão mínima suportada do iOS e da experiência dos desenvolvedores. Para novos projetos iOS 15+, as equipes geralmente escolhem AsyncSequence — não requer instalação de bibliotecas e usa construções nativas da linguagem Swift.

Padrões arquiteturais com RxSwift geralmente seguem MVVM ou Clean Architecture. A ViewModel contém toda a lógica de negócios como cadeias Observable, a View se inscreve nos dados transformados. O padrão Input-Output separa eventos de entrada (toques, entrada de texto) de estados de saída (texto do botão, visibilidade do loader). Essa abordagem simplifica os testes: a ViewModel é testada sem UI através de Schedulers virtuais.

RxSwift é adequado tanto para projetos pequenos com algumas telas quanto para grandes aplicações empresariais com dezenas de módulos. Em grandes projetos, cadeias reativas permeiam toda a arquitetura: desde a observação de UserDefaults via RxProperty até requisições de rede através do Moya (um wrapper RxSwift sobre Alamofire). Cada módulo é isolado e se comunica através de interfaces reativas, o que simplifica a substituição de implementação sem alterar inscritos. Com arquitetura adequada, RxSwift reduz a quantidade de código comparado a abordagens clássicas, pois não é necessário escrever boilerplate para KVO, Target-Action ou NotificationCenter.

RxSwift é ativamente usado em projetos com RxDataSources — uma biblioteca para trabalho reativo com UITableView e UICollectionView. RxDataSources calcula automaticamente a diferença entre conjuntos antigos e novos de células e aplica mudanças animadas. Isso libera o desenvolvedor do trabalho manual com beginUpdates/endUpdates e elimina crashes devido a inconsistência de dados.

Para depuração de cadeias RxSwift, existe o operador debug() — ele registra todos os eventos: subscribe, next, error, completed, dispose. É uma ferramenta indispensável ao desenvolver pipelines reativos complexos. debug(String) recebe um identificador que aparece nos logs. Para perfilamento de memória, RxSwift.Resources.total mostra o número total de Observables e Disposables ativos na aplicação — ajuda a identificar vazamentos quando DisposeBag não é limpa ou um retain cycle mantém uma inscrição. O operador adicional takeUntil(self.rx.deallocated) cancela automaticamente a inscrição ao desalocar o objeto — esta é mais uma camada de proteção contra vazamentos.

Melhores práticas do RxSwift

Ao escrever código RxSwift, é importante seguir o princípio de único Observable por inscrição: cada ViewController não deve criar mais de uma Inscrição para o mesmo Observable — isso reduz o risco de condições de corrida. Para memoização de Observables, usa-se o operador share(), que transforma um Observable frio em quente com um buffer replay de tamanho 1. Ao trabalhar com recursos compartilhados, use connect() para controlar o início da emissão — isso garante que todos os inscritos se conectem antes do primeiro evento.

O teste de código RxSwift é feito através de TestScheduler — um Scheduler virtual que permite gerenciar o tempo. testScheduler.createHotObservable(values) cria um Observable com uma sequência predefinida de eventos por tempo virtual. testScheduler.start() inicia o processamento. TestScheduler permite verificar em que ordem e em qual timestamp virtual os eventos ocorrem, sem atrasos reais, tornando os testes rápidos e determinísticos.