深入 RxJava 插件化开发：打造自定义操作符与监控体系

最新推荐文章于 2025-09-15 17:30:53 发布

移动端开发者

最新推荐文章于 2025-09-15 17:30:53 发布

阅读量1.5k

点赞数 38

CC 4.0 BY-SA版权

分类专栏： Rxjava 文章标签： rxjava echarts android

本文链接：https://blog.csdn.net/feathersong/article/details/150535130

Rxjava 专栏收录该内容

16 篇文章

订阅专栏

RxJava 的强大不仅在于其丰富的内置操作符，更在于其高度可扩展的架构。通过插件化机制，我们可以深入其内部，实现自定义操作符、全局行为拦截和深度性能监控，从而解决特定业务难题、增强可观测性并提升应用质量。本文将深入探讨如何构建 RxJava 插件，实现自定义操作符、全局拦截器并开发一个功能强大的性能监控插件。

一、RxJava 的插件化架构：`RxJavaPlugins`

所有扩展的入口都是 RxJavaPlugins 类。它是一个全局的注册中心，允许你覆盖 RxJava 默认的行为处理逻辑（错误处理、调度器）甚至替换其核心实现。

核心 Hook 点：

setErrorHandler: 设置全局的、未处理的 UndeliverableException 处理器。
setScheduleHandler: 拦截所有通过 Schedulers.* 执行的 Runnable。
setOn**Assembly / setOn**Subscribe: 最强大的 Hook，允许在 Observable/Flowable/Single 等被组装(assembly)或订阅(subscription)时进行拦截。这是我们开发插件的关键。

重要概念：

Assembly Time (组装时): 操作符被组合成链的时候。此时可以装饰整个链。
Subscription Time (订阅时): 当调用 subscribe() 时。此时可以装饰实际的订阅逻辑。
Runtime (运行时): 数据流开始流动之后。

二、自定义操作符实现

虽然 RxJava 操作符库已经非常丰富，但有时我们需要针对特定领域创建更简洁、更具表达力的操作符。

1. 实现 ObservableOperator 接口
这是最正式、最推荐的方式。它遵循 RxJava 的契约。

场景：实现一个 retryWithDelay 操作符，在重试之间增加延迟。

kotlin

/**
 * 一个自定义操作符，在重试失败的操作前等待一段延迟。
 * @param maxRetries 最大重试次数
 * @param delayMillis 延迟毫秒数
 * @param shouldRetry 一个谓词，决定是否对某种错误进行重试
 */
fun <T> retryWithDelay(
    maxRetries: Long,
    delayMillis: Long,
    shouldRetry: (Throwable) -> Boolean = { true }
): ObservableOperator<T, T> { // ObservableOperator<下游数据类型, 上游数据类型>

    return ObservableOperator { downstreamObserver, upstreamObserver ->
        // upstreamObserver 是下游操作符的观察者
        // 我们需要返回一个给上游的观察者

        object : Observer<T> {
            private var retryCount = 0L

            override fun onSubscribe(d: Disposable) {
                upstreamObserver.onSubscribe(d)
            }

            override fun onNext(t: T) {
                retryCount = 0 // 成功收到数据，重置重试计数
                downstreamObserver.onNext(t)
            }

            override fun onError(e: Throwable) {
                // 1. 检查是否应该重试
                if (retryCount++ < maxRetries && shouldRetry(e)) {
                    // 2. 安排延迟重试
                    Observable.timer(delayMillis, TimeUnit.MILLISECONDS)
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(
                            { 
                                // 3. 延迟时间到，重新订阅上游（这里无法直接重新订阅，需要更复杂的逻辑）
                                // 这个示例说明了概念，但实际实现需要用 defer 和 retryWhen 来包装
                             },
                            { downstreamObserver.onError(it) }
                        )
                } else {
                    // 4. 不再重试，将错误传递给下游
                    downstreamObserver.onError(e)
                }
            }

            override fun onComplete() {
                downstreamObserver.onComplete()
            }
        }
    }
}

// 实际实现中，我们通常利用现有的 retryWhen 来更优雅地实现。
// 但这个例子展示了 Operator 的基本结构。

2. 使用 lift 方法应用操作符

kotlin

// 用户使用方式
apiService.getData()
    .lift(retryWithDelay(maxRetries = 3, delayMillis = 1000)) // 像使用内置操作符一样
    .subscribe({ data -> ... }, { error -> ... })

3. (更实用的方法) 使用 compose 和现有操作符
对于大多数场景，组合现有操作符比实现 Operator 接口更简单安全。

kotlin

fun <T> retryWithDelayComposable(
    maxRetries: Long,
    delayMillis: Long,
    shouldRetry: (Throwable) -> Boolean = { true }
): ObservableTransformer<T, T> { // 返回一个 Transformer
    return ObservableTransformer { upstream ->
        upstream.retryWhen { errors ->
            errors.zipWith(Observable.range(1, maxRetries.toInt() + 1)) { error, retryCount ->
                if (retryCount <= maxRetries && shouldRetry(error)) {
                    // 发射一个值（内容不重要）来触发重试，但先延迟
                    Observable.timer(delayMillis * retryCount, TimeUnit.MILLISECONDS)
                } else {
                    // 不再重试，抛出错误
                    throw error
                }
            }.flatMap { it }
        }
    }
}

// 使用
apiService.getData()
    .compose(retryWithDelayComposable(3, 1000))
    .subscribe(...)

三、拦截器与全局监控

通过 RxJavaPlugins.setOnObservableAssembly，我们可以在每个 Observable 被创建时对其进行包装，实现全局的 AOP（面向切面编程）功能。

场景：开发一个全局日志插件，记录所有 Observable 的生命周期。

kotlin

class GlobalTracingPlugin {

    fun init() {
        // 为所有 Observable 安装装配拦截器
        RxJavaPlugins.setOnObservableAssembly { originalObservable ->
            // 这个函数会对每一个新创建的 Observable 调用
            wrapWithTracing(originalObservable, "Observable")
        }

        // 同样可以拦截 Flowable, Single, Maybe, Completable
        RxJavaPlugins.setOnFlowableAssembly { wrapWithTracing(it, "Flowable") }
        RxJavaPlugins.setOnSingleAssembly { wrapWithTracing(it, "Single") }
        // ... Maybe, Completable
    }

    private fun <T> wrapWithTracing(upstream: T, type: String): T {
        // 根据不同类型进行包装
        return when (upstream) {
            is Observable<*> -> {
                Observable.defer {
                    val tag = getTag(upstream) // 获取一个标识符（如基于栈trace）
                    log("$type [$tag] Assembled")
                    upstream.doOnSubscribe {
                        log("$type [$tag] Subscribed")
                    }.doOnNext { data ->
                        log("$type [$tag] OnNext: $data")
                    }.doOnError { error ->
                        log("$type [$tag] OnError: ${error.message}")
                    }.doOnComplete {
                        log("$type [$tag] OnComplete")
                    }.doFinally {
                        log("$type [$tag] Finally")
                    }
                } as T // 强制转换
            }
            is Flowable<*> -> { ... } // 类似包装 Flowable
            is Single<*> -> { ... }   // 类似包装 Single
            else -> upstream          // 如果不是目标类型，原样返回
        }
    }

    private fun getTag(observable: Any): String {
        // 创建一个有意义的标签，例如包含创建点的栈信息（需要过滤RxJava内部类）
        return Throwable().stackTrace
            .firstOrNull { !it.className.contains("rx.internal") }
            ?.let { "${it.fileName}:${it.lineNumber}" }
            ?: "Unknown"
    }

    private fun log(message: String) {
        if (BuildConfig.DEBUG) {
            Log.d("RxTracing", message)
        }
    }
}

// 在 Application 中初始化
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        GlobalTracingPlugin().init()
    }
}

效果： 现在，应用中每一个被创建的 RxJava 类型都会被自动注入日志逻辑，无需修改任何业务代码。这对于调试复杂的数据流和订阅泄漏非常有用。

四、性能监控插件的开发

我们可以扩展上面的概念，构建一个更复杂的插件，用于监控操作符的执行时间和线程调度。

场景：开发一个性能监控插件，检测每个操作符的执行耗时并上报。

kotlin

class RxPerformanceMonitorPlugin {

    fun init() {
        RxJavaPlugins.setOnObservableAssembly { original ->
            wrapWithPerformanceMonitoring(original, "Observable")
        }
        // ... 同样拦截其他类型
    }

    private fun <T> wrapWithPerformanceMonitoring(upstream: T, sourceType: String): T {
        return when (upstream) {
            is Observable<*> -> {
                val assemblyTime = System.nanoTime()
                val tag = getOperatorTag(upstream)

                Observable.defer {
                    val subscribeTime = System.nanoTime()
                    logPerformanceEvent("AssemblyTime", tag, sourceType, subscribeTime - assemblyTime)

                    upstream.doOnSubscribe {
                        val actualSubscribeTime = System.nanoTime()
                        logPerformanceEvent("TimeToSubscribe", tag, sourceType, actualSubscribeTime - subscribeTime)
                    }.doOnNext { data ->
                        // 可以在这里记录 onNext 的处理时间
                    }.doOnError { error ->
                        // 记录错误
                    }.doOnComplete {
                        // 记录完成
                    }
                } as T
            }
            else -> upstream
        }
    }

    // 高级功能：监控调度器切换耗时
    fun monitorSchedulerSwitches() {
        RxJavaPlugins.setScheduleHandler { originalRunnable ->
            // 拦截所有被调度的 Runnable
            val threadName = Thread.currentThread().name
            val scheduledTime = System.nanoTime()
            Runnable {
                val startTime = System.nanoTime()
                val timeInQueue = startTime - scheduledTime
                if (timeInQueue > 16_000_000) { // 如果排队时间超过 16ms（一帧）
                    reportSchedulerDelay(threadName, timeInQueue)
                }
                originalRunnable.run()
                val executionTime = System.nanoTime() - startTime
                if (executionTime > 8_000_000) { // 如果执行时间超过 8ms
                    reportLongRunningTask(threadName, executionTime, originalRunnable)
                }
            }
        }
    }

    private fun logPerformanceEvent(metricName: String, tag: String, type: String, durationNanos: Long) {
        val durationMs = TimeUnit.NANOSECONDS.toMillis(durationNanos)
        if (durationMs > 100) { // 只记录耗时超过100ms的事件，避免数据泛滥
            val event = PerformanceEvent(
                metric = metricName,
                tag = tag,
                sourceType = type,
                durationMs = durationMs,
                timestamp = System.currentTimeMillis()
            )
            // 上报到监控系统（如 Firebase Perf, Sentry, 或自定义后端）
            PerformanceReporter.report(event)
        }
    }

    data class PerformanceEvent(
        val metric: String,
        val tag: String,
        val sourceType: String,
        val durationMs: Long,
        val timestamp: Long
    )
}

// 使用
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        val monitor = RxPerformanceMonitorPlugin()
        monitor.init()
        if (isPerformanceMonitoringEnabled) {
            monitor.monitorSchedulerSwitches()
        }
    }
}