Question

我知道你应该不惜一切代价避免这种情况，但是如果我在RxJava中有一个有效的Observable用例呢？可能吗？我怎么能这样做？

在这种特定情况下，我有一个“repository”类，它当前返回Requests：

class Request<T> {
    public abstract Object key();
    public abstract Observable<T> asObservable();

    [...]

    public Request<T> transform(Func1<Request<T>, Observable<T>> transformation) {
        Request<T> self = this;
        return new Request<T>() {
             @Override public Object key() { return self.key; }
             @Override public Observable<T> asObservable() { return transformation.call(self); }
        }
    }
}

然后我使用transform方法在需要请求键的上下文中修改响应observable（asObservable）：

 service.getItemList() // <- returns a Request<List<Item>>
     .transform(r -> r.asObservable()
             // The activity is the current Activity in Android
             .compose(Operators.ensureThereIsAnAccount(activity))
             // The cache comes last because we don't need auth for cached responses
             .compose(cache.cacheTransformation(r.key())))
     .asObservable()
     [...  your common RxJava code ...]

现在，如果我的Request类是一个Observable子类，那将非常方便，因为我可以消除所有.asObservable（）调用，客户端甚至不需要知道我的Request类。

Answer 1

可以将Observable子类化（我们对Subject和ConnectableObservable s执行此操作），但需要额外考虑，因为您需要传入OnSubscribe回调来处理你传入的Subscriber。我不清楚你的请求应该做什么，以防有人订阅它，所以我会给你两个扩展Observable的例子：

没有共享可变状态的Observable

如果您没有订阅者之间共享的可变状态，您可以扩展Observable并将您的操作传递给super

public final class MyObservable extends Observable<Long> {
    public MyObservable() {
        super(new OnSubscribe<Long>() {
            @Override public void call(Subscriber<? super Long> child) {
                child.onNext(System.currentTimeMillis());
                child.onCompleted();
            }
        });
    }
}

可观察共享可变状态

这个通常比较棘手，因为你需要从OnSubscribe方法和Observable的方法访问共享状态，但Java不会让你触及OnSubscribe内部类的实例字段super已完成。解决方案是从构造函数中分解出这样的共享状态和OnSubscribe，并使用静态工厂方法来设置两者：

public final class MySharedObservable extends Observable<Long> {
    public static MySharedObservable create() {
        final AtomicLong counter = new AtomicLong();
        OnSubscribe<Long> onSubscribe = new OnSubscribe<Long>() {
            @Override
            public void call(Subscriber<? super Long> t1) {
                t1.onNext(counter.incrementAndGet());
                t1.onCompleted();
            }
        };
        return new MySharedObservable(onSubscribe, counter);
    }
    private AtomicLong counter;

    private MySharedObservable(OnSubscribe<Long> onSubscribe, AtomicLong counter) {
        super(onSubscribe);
        this.counter = counter;
    }
    public long getCounter() {
        return counter.get();
    }
}

如何在RxJava中继承Observable？

1 个答案:

没有共享可变状态的Observable

可观察共享可变状态