如何在RxJava链中重新发射已发射对象？最佳实践探讨

这个问题其实在RxJava开发里挺常见的——当链式调用中某个中间值（比如你例子里的sum）后续还需要用到，但后续操作已经改变了流的类型或者超出了该值的作用域时，怎么优雅地保留并重新发射它。我来分享几种靠谱的方案和最佳实践：

方案1：用flatMap嵌套处理，保留中间值的作用域 #

这是最直接也最符合函数式编程的方式，通过flatMap把需要使用sum的操作都包裹在同一个作用域里，这样就能在完成后续操作后轻松发射sum：

Single.just(123)
    .zipWith(getConstant(), this::add)
    .flatMap(sum -> 
        // 在这里处理getObject和doSomething，同时保留sum的引用
        getObject(sum)
            .flatMapCompletable(object -> doSomething(object))
            // 完成Completable操作后，重新发射sum
            .andThen(Single.just(sum))
    );

这种方式的好处是完全没有外部状态，所有数据都在链内部传递，符合RxJava的设计理念。

方案2：封装多值对象传递 #

如果你的链更长，需要同时传递多个中间值，可以自定义一个数据类（或者用现成的Pair/SimpleEntry）来封装这些值，确保每个环节都能访问到需要的数据：

// 自定义封装类，清晰表达数据含义
static class SumWithObject {
    final int sum;
    final TargetObject object;

    SumWithObject(int sum, TargetObject object) {
        this.sum = sum;
        this.object = object;
    }
}

// 链式调用示例
Single.just(123)
    .zipWith(getConstant(), this::add)
    .flatMap(sum -> 
        getObject(sum)
            .map(object -> new SumWithObject(sum, object))
    )
    .flatMapCompletable(sumWithObj -> 
        doSomething(sumWithObj.object)
            .andThen(Observable.just(sumWithObj.sum))
    );

这种方式适合复杂场景，能让代码的可读性更高，避免作用域嵌套过深。

要避免的坑：使用外部可变变量 #

很多人一开始会想到用一个外部变量来存储sum，比如：

AtomicInteger sumHolder = new AtomicInteger();

Single.just(123)
    .zipWith(getConstant(), this::add)
    .doOnNext(sumHolder::set)
    .map(sum -> getObject(sum))
    .flatMapCompletable(object -> doSomething(object))
    .andThen(Observable.just(sumHolder.get()));

这种方式虽然能工作，但非常不推荐——它引入了可变的外部状态，违反了函数式编程的无副作用原则，在并发场景下还可能出现线程安全问题，同时也会让代码的可维护性变差。

关于函数式编程规范的疑问 #

如果采用前面两种方案（作用域嵌套或多值封装），完全符合函数式编程的规范：所有操作都是无副作用的，数据在流内部传递，没有外部可变状态。但如果用外部可变变量的方式，就不符合规范了，因为它引入了副作用，破坏了函数的纯质性。

总结最佳实践 #

• 优先通过作用域嵌套或多值封装的方式在链内部传递中间值，避免外部状态。
• 尽量保持链的连续性，不要随意断开链式调用，这样能让代码的数据流更清晰。
• 如果某个中间值需要在多个后续步骤中使用，提前考虑封装成数据类，提升代码可读性。

内容的提问来源于stack exchange，提问作者Vaios