Java 根据其他排放量订阅

我有一个可以观察到的东西，它能发出值。基于这些值，我需要订阅/取消订阅另一个可观察对象

有没有简便的方法？一种方便的方法，而不是为订阅创建一个字段并手动处理它

例如：

---

可观察A

发出

布尔值

s。如果发出

true

，则应订阅

Observable B

——如果

false

，则应取消订阅

我不确定我们是否100%在同一页上，但我认为你遗漏了一点。也许你会认为我在吹毛求疵，但我认为把我们的条件弄清楚会很好

Observable

在订户订阅时开始发出值。因此，除非您考虑两个独立的

订阅者

，否则您无法使用订阅对发出的值作出反应，因为

观察者

不会发出任何东西

也就是说。。。（我认为）你想做的事情可以这样做：

Observable<Boolean> observableA = /* observable A initialization */;
final Observable<SomeObject> observableB = /* observable B initialization */;

observableA
        .flatMap(new Func1<Boolean, Observable<SomeObject>>() {
            @Override
            public Observable<SomeObject> call(Boolean aBoolean) {
                if (!aBoolean) {
                    throw new IllegalStateException("A dummy exception that is here just to cause the subscription to finish with error.");
                }
                return observableB;
            }
        })
       .subscribe(
                new Action1<SomeObject>() {
                    @Override
                    public void call(SomeObject someObject) {
                        // THIS IS A PART OF THE SUBSCRIBER TO OBSERVABLE B.
                        // THIS METHOD WILL BE CALLED ONLY IF THE OBSERVABLE A RETURNED TRUE
                    }
                },
                new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        // A dummy Action1 so the subscription does not crash on the Exception
                    }
                });

可观测A=/*可观测A初始化*/；
最终可观测B=/*可观测B初始化*/；
可观察的
.flatMap（新函数1（）{
@凌驾
公共可观测呼叫（布尔aBoolean）{
如果（！aBoolean）{
抛出新的IllegalStateException（“一个虚拟异常，在这里只是为了导致订阅以错误的方式完成”）；
}
返回b；
}
})
.订阅(
新行动1（）{
@凌驾
公共无效调用（SomeObject SomeObject）{
//这是可观测B的订户的一部分。
//只有当可观察对象返回TRUE时，才会调用此方法
}
},
新行动1（）{
@凌驾
公共无效呼叫（可丢弃可丢弃）{
//虚拟操作1，以便订阅不会因异常而崩溃
}
});

我不确定我们是否100%在同一页上，但我认为你遗漏了一点。也许你会认为我在吹毛求疵，但我认为把我们的条件弄清楚会很好

Observable

在订户订阅时开始发出值。因此，除非您考虑两个独立的

订阅者

，否则您无法使用订阅对发出的值作出反应，因为

观察者

不会发出任何东西

也就是说。。。（我认为）你想做的事情可以这样做：

Observable<Boolean> observableA = /* observable A initialization */;
final Observable<SomeObject> observableB = /* observable B initialization */;

observableA
        .flatMap(new Func1<Boolean, Observable<SomeObject>>() {
            @Override
            public Observable<SomeObject> call(Boolean aBoolean) {
                if (!aBoolean) {
                    throw new IllegalStateException("A dummy exception that is here just to cause the subscription to finish with error.");
                }
                return observableB;
            }
        })
       .subscribe(
                new Action1<SomeObject>() {
                    @Override
                    public void call(SomeObject someObject) {
                        // THIS IS A PART OF THE SUBSCRIBER TO OBSERVABLE B.
                        // THIS METHOD WILL BE CALLED ONLY IF THE OBSERVABLE A RETURNED TRUE
                    }
                },
                new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        // A dummy Action1 so the subscription does not crash on the Exception
                    }
                });

可观测A=/*可观测A初始化*/；
最终可观测B=/*可观测B初始化*/；
可观察的
.flatMap（新函数1（）{
@凌驾
公共可观测呼叫（布尔aBoolean）{
如果（！aBoolean）{
抛出新的IllegalStateException（“一个虚拟异常，在这里只是为了导致订阅以错误的方式完成”）；
}
返回b；
}
})
.订阅(
新行动1（）{
@凌驾
公共无效调用（SomeObject SomeObject）{
//这是可观测B的订户的一部分。
//只有当可观察对象返回TRUE时，才会调用此方法
}
},
新行动1（）{
@凌驾
公共无效呼叫（可丢弃可丢弃）{
//虚拟操作1，以便订阅不会因异常而崩溃
}
});

如果所有可观察对象都具有相同的类型，或者您可以根据值组合任何您想要的内容

Observable.from(new int[]{1,2,3,4,5})
    .filter(i -> i < 5) // filter out something
    .flatMap(i -> {
        if (i < 2) { // subscribe on some observable, based on item value
           return Observable.just(i);
        } else {
           return Observable.just(3);
        }
    })

Observable.from（新int[]{1,2,3,4,5}）
.filter（i->i<5）//过滤掉某些内容
.flatMap（i->{
如果（i<2）{//订阅某个可观察项，则基于项值
可观察的返回。仅（i）；
}否则{
可观察到的回报。仅（3）；
}
})

如果所有可观察对象都具有相同的类型，或者您可以根据值组合任何您想要的内容

Observable.from(new int[]{1,2,3,4,5})
    .filter(i -> i < 5) // filter out something
    .flatMap(i -> {
        if (i < 2) { // subscribe on some observable, based on item value
           return Observable.just(i);
        } else {
           return Observable.just(3);
        }
    })

Observable.from（新int[]{1,2,3,4,5}）
.filter（i->i<5）//过滤掉某些内容
.flatMap（i->{
如果（i<2）{//订阅某个可观察项，则基于项值
可观察的返回。仅（i）；
}否则{
可观察到的回报。仅（3）；
}
})

也许我想的解决方案不存在。是的，我想订两份。尽管我更喜欢为订阅创建一个字段，并将订阅存储在其中/取消订阅，而不是使用隐式的onError unsubscription。也许我所考虑的解决方案不存在。是的，我想订两份。尽管我更喜欢为订阅创建一个字段，并将订阅存储在其中/取消订阅，而不是使用隐式的onError unsubscription。