RxSwift 入门指南：响应式编程的核心概念与实践-CSDN博客

RxSwift 入门指南：响应式编程的核心概念与实践

什么是 RxSwift？

RxSwift 是 ReactiveX 项目在 Swift 语言中的实现，它提供了一套强大的响应式编程工具集。响应式编程是一种面向数据流和变化传播的编程范式，能够简化异步操作和事件处理。

核心概念：Observable（可观察序列）

Observable 的本质

Observable 是 RxSwift 中最基础的概念，可以理解为异步的数据序列。它与 Swift 标准库中的 Sequence 类似，但关键区别在于 Observable 可以异步接收元素。

Observable 序列有三种基本事件：

.next(Element)：序列中的下一个元素
.error(Error)：序列因错误终止
.completed：序列正常完成

序列的生命周期

所有 Observable 序列都遵循相同的生命周期模式：

next* (error | completed)?

这意味着：

序列可以有零个或多个 .next 事件
一旦发出 .error 或 .completed 事件，序列就不能再产生其他元素

可视化序列

我们可以用弹珠图来直观表示序列：

--1--2--3--4--5--6--| // 正常终止
--a--b--a--a--a---d---X // 因错误终止
---tap-tap-------tap---> // 无限序列（如按钮点击）

订阅与资源管理

订阅机制

订阅 Observable 类似于迭代 Swift 序列，但使用回调机制：

observable.subscribe(onNext: { element in
    print(element)
}, onError: { error in
    print("Error: \(error)")
}, onCompleted: {
    print("Completed")
})

资源释放

RxSwift 提供了多种方式来管理订阅资源：

DisposeBag（推荐方式）：

let disposeBag = DisposeBag()

observable
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

当 disposeBag 被释放时，会自动取消所有添加到其中的订阅。

手动取消：

let subscription = observable.subscribe(...)
// 需要时取消
subscription.dispose()

takeUntil 操作符：

observable
    .takeUntil(self.rx.deallocated)
    .subscribe(...)

创建自定义 Observable

基本创建方法

使用 Observable.create 可以创建自定义 Observable：

func myJust<E>(_ element: E) -> Observable<E> {
    return Observable.create { observer in
        observer.on(.next(element))
        observer.on(.completed)
        return Disposables.create()
    }
}

执行工作的 Observable

创建执行实际工作的 Observable（如定时器）：

func myInterval(_ interval: TimeInterval) -> Observable<Int> {
    return Observable.create { observer in
        let timer = DispatchSource.makeTimerSource()
        timer.schedule(deadline: .now() + interval, repeating: interval)
        
        var count = 0
        timer.setEventHandler {
            observer.on(.next(count))
            count += 1
        }
        timer.resume()
        
        return Disposables.create {
            timer.cancel()
        }
    }
}

共享订阅

默认情况下，每个订阅都会创建独立的序列。要共享订阅，可以使用 share(replay:)：

let sharedObservable = observable.share(replay: 1)

操作符

RxSwift 提供了丰富的操作符来处理序列：

转换类：map, flatMap, scan
过滤类：filter, take, skip
组合类：merge, zip, combineLatest
错误处理：catchError, retry

实际应用示例

网络请求封装

extension Reactive where Base: URLSession {
    func response(request: URLRequest) -> Observable<(HTTPURLResponse, Data)> {
        return Observable.create { observer in
            let task = self.base.dataTask(with: request) { data, response, error in
                // 处理响应
                if let error = error {
                    observer.on(.error(error))
                    return
                }
                
                guard let httpResponse = response as? HTTPURLResponse,
                      let data = data else {
                    observer.on(.error(RxError.unknown))
                    return
                }
                
                observer.on(.next((httpResponse, data)))
                observer.on(.completed)
            }
            
            task.resume()
            
            return Disposables.create {
                task.cancel()
            }
        }
    }
}

最佳实践

优先使用 DisposeBag 来管理订阅生命周期
避免手动调用 dispose()，除非必要
理解冷热 Observable 的区别：
- 冷 Observable：每个订阅都会重新开始序列
- 热 Observable：共享序列，新订阅者可能错过之前的事件
合理使用共享操作符 如 share(replay:)