RxSwift — ano ito, mga pangunahing konsepto at reaktibong programming

Ano ang RxSwift?

RxSwift ay isang reaktibong programming library para sa wikang Swift, na na-port mula sa Reactive Extensions (Rx). Pinapayagan nito ang paglalarawan ng mga asynchronous at event-driven na programa sa pamamagitan ng Observable Sequence — isang pagkakasunod-sunod ng data na magagamit sa paglipas ng panahon. Ginagamit ng mga iOS developer ang RxSwift para sa paghawak ng mga network request, UI event, at streaming data nang walang nested callback.

Observable at Observer

Ang batayan ng RxSwift ay binubuo ng dalawang pangunahing protocol: ObservableType — ang pinagmumulan ng kaganapan na maaaring maglabas ng tatlong uri ng signal: .next(value), .error(error) at .completed. Ang Observer ay nag-a-subscribe sa Observable sa pamamagitan ng subscribe method at natatanggap ang mga kaganapang ito. Ang modelong ito ay tinatawag na Reactive Streams at ginagarantiyang walang kaganapang mawawala sa tamang subscription.

Mga operator ng pagbabago

Ang RxSwift ay nagbibigay ng higit sa 300 operator para sa pagtatrabaho sa mga stream: ang map ay nagbabago ng bawat kaganapan, ang filter ay nagpapadaan lamang ng mga angkop, ang flatMap ay nagbubukas ng mga nested Observable sa iisang stream. Ang mga operator ay pinagsasama sa mga chain, na lumilikha ng deklaratibong pipeline ng pagproseso ng data nang walang side effects.

Traits: Single, Completable, Maybe

Bukod sa pangunahing Observable, ang RxSwift ay nagbibigay ng mga espesyalisadong wrapper type. Ang Single ay naglalabas ng eksaktong isang halaga o error — perpekto para sa HTTP request. Ang Completable ay nagtatapos sa tagumpay o error nang walang halaga — para sa write operations. Ang Maybe ay pinagsasama ang parehong senaryo: maaaring magtapos na may halaga, walang halaga, o may error. Ang mga Traits na ito ay nagpapasimple sa semantika at ginagawang self-documenting ang code.

Paano gumagana ang reaktibong programming sa RxSwift

Ang reaktibong programming sa RxSwift ay binuo sa Observer pattern. Ang ObservableSequence ay ang analog ng Sequence mula sa standard library, ngunit may asynchronous na access sa mga elemento. Ang stream ng kaganapan ay ipinapadala sa pamamagitan ng chain ng mga operator, na ang bawat isa ay nagbabalik ng bagong ObservableSequence nang hindi binabago ang orihinal.

Mga chain ng operator

Ang mga operator sa RxSwift ay purong function na tumatanggap ng isang ObservableSequence at nagbabalik ng bago. Halimbawa, ang map ay lumilikha ng bagong sequence sa pamamagitan ng paglalapat ng pagbabago sa bawat elemento. Sa pamamagitan ng pagsasama-sama ng mga operator, ang developer ay bumubuo ng pipeline kung saan ang data ay dumadaan sa lahat ng yugto ng pagproseso nang walang intermediate variables.

Schedulers at mga thread ng pagpapatupad

Ang Schedulers ay isang abstraksyon sa mga thread ng pagpapatupad sa RxSwift. Tinutukoy ng Scheduler kung saang thread isasagawa ang code: MainScheduler — UI thread, SerialDispatchQueueScheduler — background queue. Ang mga operator na subscribeOn at observeOn ay tumutukoy kung saan ginagawa ang trabaho at kung saan pinoproseso ang mga resulta.

Mga pangunahing bahagi ng RxSwift

Ang RxSwift ay may kasamang ilang pangunahing uri, bawat isa ay gumaganap ng kanilang gawain sa reaktibong pipeline. Ang Single — Observable na naglalabas ng eksaktong isang halaga o error, maginhawa para sa network request. Ang Completable ay nagtatapos sa tagumpay o error nang walang halaga. Pinagsasama ng Maybe ang mga katangian ng Single at Completable.

Subject at Relay

Ang Subject ay isang mainit na Observable na sabay na kumikilos bilang Observer. Ang PublishSubject ay naglalabas lamang ng mga bagong kaganapan sa mga subscriber, ang BehaviorSubject — ang huling kaganapan at ang mga bago. Ang Relay ay isang variant ng Subject na hindi naglalabas ng .error o .completed, na ginagarantiyang tuloy-tuloy ang stream. Ang BehaviorRelay ay nag-iimbak ng kasalukuyang halaga at angkop para sa State-driven UI.

DisposeBag

Ang DisposeBag ay isang koleksyon ng Disposable na awtomatikong nag-a-unsubscribe sa lahat ng subscription sa sarili nitong dealokasyon. Sa iOS, ang DisposeBag ay karaniwang idinaragdag sa UIViewController o UIView. Kapag isinara ang screen, nililinis ang DisposeBag — pinipigilan nito ang mga memory leak at pagtukoy sa mga hindi umiiral na UI element.

Mga halimbawa ng code ng RxSwift

Sa ibaba ay ipinapakita ang halimbawa ng paggawa ng Observable mula sa array ng data gamit ang map operator para sa pagbabago ng mga string:

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

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

Ang pangalawang halimbawa ay nagpapakita ng pagsasama ng dalawang network request gamit ang zip — naghihintay ang operator hanggang sa parehong Observable ay naglabas ng halaga at pinagsasama ang mga resulta sa isang tuple:

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)

Ang ikatlong halimbawa ay nagpapakita ng paggamit ng BehaviorRelay para sa pag-iimbak ng estado at awtomatikong pag-update ng UI sa mga pagbabago: bawat pagbabago ng state.accept() ay agad na ipinapadala sa mga subscriber, na perpekto para sa State pattern sa MVVM architecture.

let state = BehaviorRelay(value: "idle")

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

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

RxSwift kumpara sa iba pang mga approach

Ang RxSwift ay naiiba sa tradisyunal na asynchronous na pamamaraan (Delegation, NotificationCenter, Callback) sa pagiging deklaratibo at composability. Hindi tulad ng Combine, sinusuportahan ng RxSwift ang iOS 9+ at may mas maraming operator. Gayunpaman, ang Combine ay isinama sa Foundation at SwiftUI sa antas ng wika, na nagbibigay dito ng kalamangan sa mga bagong proyekto ng Apple.

Ang pangunahing bentahe ng RxSwift kaysa sa GCD (Grand Central Dispatch) — ang kakayahang pagsamahin at baguhin ang mga data stream sa antas ng abstraksyon, sa halip na manu-manong pamahalaan ang mga queue. Kasabay nito, ang RxSwift ay nangangailangan ng pag-aaral ng mga konsepto ng reaktibong approach, na nagpapataas ng threshold ng pagpasok para sa team.

Sa praktika, ang RxSwift ay ginagamit sa malalaking proyekto kung saan ang reaktibong chain ay nag-uugnay sa mga UI event, business logic, at network interaction sa iisang pipeline. Halimbawa, sa trading application, ang mga stream ng quote ay pinoproseso sa pamamagitan ng RxSwift: ang mga tick ay nagmumula sa WebSocket, dumadaan sa pagsasala, pinagpangkat ayon sa timeframe, at ipinapakita sa chart sa real-time. Ang ganitong senaryo ay mahirap ipatupad sa pamamagitan ng Delegation o NotificationCenter nang hindi nawawala ang readability.

Ang mga alternatibo sa RxSwift ay kinabibilangan ng Combine (iOS 13+), AsyncSequence mula sa Swift Concurrency (iOS 15+), at ang library na ReactiveSwift na walang pagkakatali sa mga platform ng Apple. Ang pagpili ay depende sa minimal na bersyon ng iOS na sinusuportahan at sa karanasan ng mga developer. Para sa mga bagong proyekto ng iOS 15+, ang mga team ay madalas na pumipili ng AsyncSequence — hindi ito nangangailangan ng pag-install ng library at gumagamit ng native na konstruksyon ng wikang Swift.

Ang mga pattern ng arkitektura na may RxSwift ay karaniwang sumusunod sa MVVM o Clean Architecture. Ang ViewModel ay naglalaman ng lahat ng business logic sa anyo ng mga Observable chain, ang View ay nag-a-subscribe sa transformed data. Ang Input-Output pattern ay naghihiwalay ng mga input event (tap, text input) at output state (teksto ng button, visibility ng loader). Ang approach na ito ay nagpapasimple sa pag-test: ang ViewModel ay sinusuri nang walang UI sa pamamagitan ng virtual Scheduler.

Ang RxSwift ay angkop para sa parehong maliliit na proyekto na may ilang screen at malalaking enterprise application na may dose-dosenang module. Sa malalaking proyekto, ang reaktibong chain ay tumatagos sa buong arkitektura: mula sa pagmamasid ng UserDefaults sa pamamagitan ng RxProperty hanggang sa network request sa pamamagitan ng Moya (RxSwift wrapper sa ibabaw ng Alamofire). Ang bawat module ay nakahiwalay at nakikipag-ugnayan sa pamamagitan ng reaktibong interface, na nagpapasimple sa pagpapalit ng implementasyon nang hindi binabago ang mga subscriber. Sa tamang arkitektura, binabawasan ng RxSwift ang dami ng code kumpara sa mga klasikong approach, dahil hindi na kailangang magsulat ng boilerplate para sa KVO, Target-Action o NotificationCenter.

Ang RxSwift ay aktibong ginagamit sa mga proyekto na may RxDataSources — isang library para sa reaktibong pagtatrabaho sa UITableView at UICollectionView. Ang RxDataSources ay awtomatikong nagkalkula ng pagkakaiba sa pagitan ng luma at bagong set ng mga cell at nag-aplay ng mga animated na pagbabago. Ito ay nagpapalaya sa developer mula sa manu-manong trabaho sa beginUpdates/endUpdates at nag-aalis ng crash sa hindi pagkakatugma ng data.

Para sa pag-debug ng mga RxSwift chain, mayroong operator na debug() — nire-record nito ang lahat ng kaganapan: subscribe, next, error, completed, dispose. Ito ay isang kailangang-kailangan na kasangkapan sa pagbuo ng mga kumplikadong reaktibong pipeline. Ang debug(String) ay tumatanggap ng identifier na ipinapakita sa mga log. Para sa memory profiling, ang RxSwift.Resources.total ay nagpapakita ng kabuuang bilang ng mga aktibong Observable at Disposable sa application — tumutulong sa pag-detect ng mga leak kapag ang DisposeBag ay hindi nalinis o ang retain cycle ay may hawak na subscription. Ang karagdagang operator na takeUntil(self.rx.deallocated) ay awtomatikong nag-a-unsubscribe sa subscription sa dealokasyon ng object — ito ay isa pang layer ng proteksyon laban sa mga leak.

Pinakamahuhusay na kagawian sa RxSwift

Sa pagsulat ng RxSwift code, mahalagang sundin ang prinsipyo ng isang Observable bawat subscription: bawat ViewController ay hindi dapat gumawa ng higit sa isang subscription sa isang Observable — binabawasan nito ang panganib ng race condition. Para sa memoization ng Observable, ginagamit ang operator na share(), na nagpapalit ng malamig na Observable sa mainit na may replay buffer na sukat na 1. Kapag nagtatrabaho sa mga shared resource, gamitin ang connect() para pamahalaan ang simula ng emission — ginagarantiyang lahat ng subscriber ay kumonekta bago ang unang kaganapan.

Ang pag-test ng RxSwift code ay ginagawa sa pamamagitan ng TestScheduler — isang virtual na Scheduler na nagpapahintulot sa pamamahala ng oras. Ang testScheduler.createHotObservable(values) ay lumilikha ng Observable na may paunang natukoy na pagkakasunod-sunod ng mga kaganapan ayon sa virtual na oras. Ang testScheduler.start() ay nagpapatakbo ng pagproseso. Ang TestScheduler ay nagbibigay-daan sa pagsuri ng pagkakasunod-sunod at virtual timestamp kung kailan naganap ang mga kaganapan, nang walang totoong pagkaantala, na ginagawang mabilis at deterministiko ang mga test.