引言

在复杂的Android应用中，我们经常需要处理多个数据源的组合与协调。RxJava的组合操作符为我们提供了强大的工具来优雅地处理这些场景。本文将深入讲解RxJava中最实用的组合操作符，并通过典型的Android开发案例展示它们的实际应用。

一、基础组合操作符

1. merge() - 简单合并多个Observable

merge()将多个Observable发射的数据按时间线合并：

kotlin

val localData = Observable.just("Local Data")
val remoteData = Observable.just("Remote Data")

Observable.merge(localData, remoteData)
    .subscribe { data ->
        Log.d("Merge", data) 
        // 可能输出顺序："Local Data", "Remote Data"
        // 或 "Remote Data", "Local Data"
    }

Android应用场景：

• 同时从内存缓存和网络加载数据

• 合并多个传感器的数据流

• 并行执行多个独立任务

注意事项：

• 不保证原始顺序

• 任何一个Observable出错会立即终止整个流

2. concat() - 顺序连接多个Observable

concat()按顺序执行多个Observable，前一个完成后才开始下一个：

kotlin

val first = Observable.just(1, 2, 3).delay(1, TimeUnit.SECONDS)
val second = Observable.just(4, 5, 6)

Observable.concat(first, second)
    .subscribe { num ->
        Log.d("Concat", num.toString())
        // 保证输出顺序：1,2,3,4,5,6（即使second没有delay）
    }

Android应用场景：

• 多级缓存策略（先内存，后磁盘，最后网络）

• 需要严格顺序的批量操作

• 分页加载数据

二、高级组合操作符

3. zip() - 一对一组合数据

zip()将多个Observable的最新数据按函数组合：

kotlin

val names = Observable.just("Alice", "Bob", "Charlie")
val ages = Observable.just(25, 30, 35)

Observable.zip(names, ages) { name, age ->
    "$name is $age years old"
}.subscribe { info ->
    Log.d("Zip", info)
    // 输出：
    // Alice is 25 years old
    // Bob is 30 years old
    // Charlie is 35 years old
}

Android应用场景：

• 合并多个API的响应数据

• 组合用户输入（如注册表单的多字段验证）

• 并行任务的结果聚合

特点：

• 等待所有源都发射数据才组合

• 以最短的Observable为准结束

4. combineLatest() - 实时响应多数据源变化

当任何一个源Observable发射新数据时，组合最新的所有数据：

kotlin

val emailChanges = RxTextView.textChanges(emailEditText).skip(1)
val passwordChanges = RxTextView.textChanges(passwordEditText).skip(1)

Observable.combineLatest(emailChanges, passwordChanges) { email, password ->
    isValidEmail(email) && isValidPassword(password)
}.subscribe { isValid ->
    loginButton.isEnabled = isValid
}

Android应用场景：

• 实时表单验证

• 搜索过滤器组合

• 动态UI状态管理

三、条件组合操作符

5. switchOnNext() - 切换最新Observable

只处理最新订阅的Observable发射的数据：

kotlin

val searchObservable = RxTextView.textChanges(searchEditText)
    .debounce(300, TimeUnit.MILLISECONDS)
    .map { query -> 
        searchApi.search(query.toString()) // 返回Observable<List<Result>>
    }

Observable.switchOnNext(searchObservable)
    .subscribe { results ->
        updateSearchResults(results)
    }

优势：

• 自动取消前一个未完成的请求

• 确保只显示最新搜索的结果

6. amb() - 采用最先响应的Observable

在多个Observable中选择第一个发射数据的：

kotlin

val cache = loadFromCache().delay(100, TimeUnit.MILLISECONDS)
val network = loadFromNetwork()

Observable.amb(listOf(cache, network))
    .subscribe { data ->
        showData(data)
    }

Android应用场景：

• 竞速请求（缓存 vs 网络）

• 多服务器故障转移

• 传感器数据择优选择

四、Android实战案例

案例1：多源数据加载与展示

kotlin

fun loadUserData(userId: String) {
    Observable.zip(
        userApi.getUserProfile(userId).subscribeOn(Schedulers.io()),
        userApi.getUserFriends(userId).subscribeOn(Schedulers.io()),
        userApi.getUserPosts(userId).subscribeOn(Schedulers.io()),
        Function3 { profile: Profile, friends: List<Friend>, posts: List<Post> ->
            UserData(profile, friends, posts)
        }
    ).observeOn(AndroidSchedulers.mainThread())
     .subscribe(
        { userData -> updateUI(userData) },
        { error -> showError(error) }
     )
}

案例2：页面多个权限请求

kotlin

fun checkPermissions(vararg permissions: String): Observable<Boolean> {
    val permissionObservables = permissions.map { permission ->
        RxPermissions(this)
            .request(permission)
            .filter { granted -> !granted }
            .map { false }
            .defaultIfEmpty(true)
    }
    
    return Observable.combineLatest(permissionObservables) { results ->
        results.all { it as Boolean }
    }
}

// 使用示例
checkPermissions(
    Manifest.permission.CAMERA,
    Manifest.permission.READ_CONTACTS,
    Manifest.permission.ACCESS_FINE_LOCATION
).subscribe { allGranted ->
    if (allGranted) {
        startCamera()
    } else {
        showPermissionDenied()
    }
}

案例3：电商商品筛选器

kotlin

// 监听多个筛选条件变化
Observable.combineLatest(
    priceRangeObservable,
    categoryObservable,
    sortObservable,
    searchQueryObservable
) { priceRange, category, sort, query ->
    FilterParams(priceRange, category, sort, query)
}.debounce(500, TimeUnit.MILLISECONDS) // 防抖
 .switchMap { params ->
    productRepository.getProducts(params)
        .onErrorResumeNext { _: Throwable -> 
            Observable.just(emptyList())
        }
 }.observeOn(AndroidSchedulers.mainThread())
  .subscribe { products ->
    adapter.updateData(products)
  }

五、组合操作符性能对比

操作符	线程安全	背压支持	适用场景	内存开销
merge()	是	部分	并行独立任务	低
concat()	是	是	顺序依赖任务	低
zip()	是	是	精确数据组合	中等
combineLatest()	是	是	实时状态组合	高
switchOnNext()	是	是	最新请求优先	高
amb()	是	是	竞速选择	低

结语

RxJava的组合操作符为Android开发中复杂的数据流协调问题提供了优雅的解决方案。在实际项目中：

1. 简单合并使用merge()或concat()

2. 数据关联使用zip()或combineLatest()

3. 竞速场景使用amb()

4. 避免内存泄漏配合CompositeDisposable管理订阅

5. 线程控制合理使用subscribeOn/observeOn

最佳实践建议：

• 对于网络请求组合，优先考虑zip确保数据完整性

• UI事件组合使用combineLatest实现实时响应

• 长时间运行的任务使用switchOnNext避免旧数据覆盖

• 在Fragment/Activity销毁时及时清理订阅

掌握这些组合操作符，你将能够更高效地处理Android应用中的复杂异步场景，构建更健壮、响应更快的应用程序。