RxSwift 框架解析

RxSwift 提供的是一种统一处理"异步+事件驱动"的编程范式，而不仅仅是一个库。它是一种思维方式。RxSwift的体验demo在文末。

一、RxSwift 核心架构图

graph TD A[RxSwift] --> B[Observable 可观察序列] A --> C[Observer 观察者] A --> D[Operator 操作符] A --> E[Subject 主体] A --> F[Scheduler 调度器] B --> B1[创建操作] B1 --> B11(create) B1 --> B12(deferred) B1 --> B13(just) B1 --> B14(from) B1 --> B15(interval) B --> B2[特征序列] B2 --> B21(Single) B2 --> B22(Completable) B2 --> B23(Maybe) E --> E1[PublishSubject] E --> E2[BehaviorSubject] E --> E3[ReplaySubject] E --> E4[AsyncSubject] F --> F1[MainScheduler] F --> F2[SerialDispatchQueueScheduler] F --> F3[ConcurrentDispatchQueueScheduler] F --> F4[OperationQueueScheduler] D --> D1[变换操作符] D1 --> D11(map) D1 --> D12(flatMap) D1 --> D13(scan) D --> D2[过滤操作符] D2 --> D21(filter) D2 --> D22(take) D2 --> D23(distinctUntilChanged) D --> D3[组合操作符] D3 --> D31(combineLatest) D3 --> D32(merge) D3 --> D33(zip) D --> D4[错误处理] D4 --> D41(catchError) D4 --> D42(retry)

二、Observable：异步流的抽象

作用：

RxSwift 中一切皆 Observable，它是异步事件流的载体，负责发出元素或错误/完成事件。

特性：

惰性执行，只有被订阅时才会触发
可被多个 Observer 订阅
可组合、链式操作

创建方式：

Swift 复制代码

let observable = Observable<Int>.create { observer in
    observer.onNext(1)
    observer.onCompleted()
    return Disposables.create()
}

let justValue = Observable.just("hello")
let fromArray = Observable.from([1, 2, 3])
let timer = Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)

三、特征序列：语义更清晰的 Observable

1.Single

表示一次性返回一个元素或一个错误，常用于网络请求、文件读取等。

Swift 复制代码

func fetchUser() -> Single<User> {
    return Single.create { single in
        API.getUser { result in
            switch result {
            case .success(let user): single(.success(user))
            case .failure(let error): single(.failure(error))
            }
        }
        return Disposables.create()
    }
}

2.Completable

只关心是否成功完成或失败，不发出任何元素。例如保存数据、写入文件等。

Swift 复制代码

func save(user: User) -> Completable {
    return Completable.create { completable in
        let success = DB.save(user)
        success ? completable(.completed) : completable(.error(MyError()))
        return Disposables.create()
    }
}

3.Maybe

可能发出一个元素，也可能什么都不发，只完成或失败。用在"可选"任务中。

scss 复制代码

func loadCache() -> Maybe<Data> {
    return Maybe.create { maybe in
        if let cached = getCache() {
            maybe(.success(cached))
        } else {
            maybe(.completed)
        }
        return Disposables.create()
    }
}

四、Observer：消费 Observable 的响应者

响应事件：

onNext(_:)：每个新值
onError(_:)：错误终止
onCompleted()：正常完成

示例：

Swift 复制代码

observable.subscribe(
    onNext: { print("收到: ($0)") },
    onError: { print("错误: ($0)") },
    onCompleted: { print("完成") }
)

在实际工程中，用 bind() 替代 subscribe()，配合 disposeBag 自动内存管理。

五、Subject：Observable 与 Observer 的桥梁

类型	新订阅者收到	缓存行为	常用场景
PublishSubject	订阅后新事件	无缓存	事件广播
BehaviorSubject	最近一个事件	单个缓存	状态管理
ReplaySubject	所有缓存事件	自定义容量	数据重放
AsyncSubject	完成时最后一个事件	延迟发射	最终结果

示例：

Swift 复制代码

let subject = BehaviorSubject(value: "初始值")

subject.onNext("新值")
subject.subscribe(onNext: { print("收到: ($0)") })

六、Operator：响应式的函数式构建块

RxSwift 提供数十种操作符，常见分类如下：

1. 变换类

Swift 复制代码

observable.map { $0 * 2 }

textField.rx.text.orEmpty
    .flatMapLatest { query in searchAPI(query) }

2. 过滤类

Swift 复制代码

observable.filter { $0 > 10 }

searchBar.rx.text.orEmpty
    .debounce(.milliseconds(300), scheduler: MainScheduler.instance)

3. 组合类

Swift 复制代码

Observable.combineLatest(email.rx.text.orEmpty, password.rx.text.orEmpty)
    .map { !$0.isEmpty && !$1.isEmpty }

Observable.zip(userRequest, orderRequest) { user, orders in
    return Profile(user: user, orders: orders)
}

4. 错误处理

Swift 复制代码

networkObservable
    .retry(3)
    .catchError { error in
        showAlert(error.localizedDescription)
        return .empty()
    }

七、Scheduler：线程控制器

用于指定事件在哪个线程产生和处理。

常用类型：

MainScheduler：主线程，UI 更新必用
SerialDispatchQueueScheduler：串行后台任务
ConcurrentDispatchQueueScheduler：并发执行
OperationQueueScheduler：基于 NSOperationQueue

使用示例：

Swift 复制代码

apiObservable
    .subscribe(on: ConcurrentDispatchQueueScheduler(qos: .background))
    .observe(on: MainScheduler.instance)
    .subscribe(onNext: { updateUI($0) })

⚠️ observeOn 已废弃，使用 observe(on:)。

八、DisposeBag：内存管理利器

RxSwift 使用 DisposeBag 自动管理资源释放，避免内存泄漏。

Swift 复制代码

class MyVC: UIViewController {
    let disposeBag = DisposeBag()

    override func viewDidLoad() {
        super.viewDidLoad()
        observable
            .subscribe(onNext: { ... })
            .disposed(by: disposeBag)
    }
}

也可以使用 takeUntil(self.rx.deallocated) 自动在控制器销毁时取消订阅。

九、最佳实践

1. 表单 UI 绑定

Swift 复制代码

Observable.combineLatest(
    firstNameField.rx.text.orEmpty,
    lastNameField.rx.text.orEmpty
)
.map { $0 + " " + $1 }
.bind(to: fullNameLabel.rx.text)
.disposed(by: disposeBag)

2. 网络链式调用

Swift 复制代码

loginService.login()
    .flatMapLatest { token in userService.fetchUser(token: token) }
    .observe(on: MainScheduler.instance)
    .subscribe(onNext: { user in
        self.updateUI(with: user)
    })
    .disposed(by: disposeBag)

3. 性能优化技巧

使用 share(replay:scope:) 共享副作用序列
CPU密集操作切换线程：

Swift 复制代码

computationObservable
    .subscribe(on: ConcurrentDispatchQueueScheduler(qos: .userInitiated))

十、结语：响应式的真正价值

RxSwift 将异步事件处理高度统一化，用 Observable 表达数据流，用操作符构建业务逻辑，用 Scheduler 控制线程，最终实现：

声明式编程：清晰表达需求
响应式系统：数据变化自动驱动 UI
统一抽象：替代回调、代理、通知
高可组合性：灵活构建复杂逻辑

📦 RxSwift体验demo