Android 呼叫观察员'；s onNext metod in Observable.defer

我是一个新的反应式程序员。我想在defer中调用observer的

onNext

方法有什么好方法吗

例如-

Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super String> observer) {
        try {
            if (!observer.isUnsubscribed()) {

                // While using create, can call observer.onNext        
                for(int i=0;i< 10 ;i++)
                    observer.onNext("");

                observer.onCompleted();
            }
        } catch (Exception e) {
            observer.onError(e);
        }
    }
});

Observable.defer( new Func0<Observable<String>>() {

    @Override
    public Observable<String> call() {

        // I want call observer.onNext("") here   

                 return Observable.just("");
    }

});

Observable.create（新建Observable.OnSubscribe（））{
@凌驾
公用无效呼叫（订户，因为您只能从一个订户呼叫onNext。我想说创建一个订户，然后从该订户呼叫onNext，如下所示：

final Subscriber<String> subscriber = new Subscriber<String>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(String s) {

        }
    };

    Observable.defer(new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {

            // I want call observer.onNext("") here

            subscriber.onNext("Test");
            return Observable.just("dasdsa");
        }

    });

Observable.defer(new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {

            // I want call observer.onNext("") here
            return Observable.just("dasdsa");
        }

    }).subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            //on Next was called after the subscribe
        }
    });

最终订户=新订户（）{
@凌驾
未完成的公共无效（）{
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
public void onNext（字符串s）{
}
};
可观察的延迟（新的Func0（）{
@凌驾
公共可观测呼叫（）{
//我想在这里调用observer.onNext（“”）
订户.onNext（“测试”）；
可观察的回报。公正（“dasdsa”）；
}
});

但是，您也可以订阅这个observate，它将在subscribe方法中调用这个“onNext”，如下所示：

final Subscriber<String> subscriber = new Subscriber<String>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(String s) {

        }
    };

    Observable.defer(new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {

            // I want call observer.onNext("") here

            subscriber.onNext("Test");
            return Observable.just("dasdsa");
        }

    });

Observable.defer(new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {

            // I want call observer.onNext("") here
            return Observable.just("dasdsa");
        }

    }).subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            //on Next was called after the subscribe
        }
    });

Observable.defer（新函数0（）{
@凌驾
公共可观测呼叫（）{
//我想在这里调用observer.onNext（“”）
可观察的回报。公正（“dasdsa”）；
}
}).订阅（新操作1（）{
@凌驾
公共无效调用（字符串s）{
//在订阅之后调用了on Next
}
});

我想由您来决定什么更有用，我希望我能提供帮助！
因为您只能从一个订阅者呼叫onNext。我会说创建一个订阅者，然后从这个订阅者呼叫onNext，如下所示：

final Subscriber<String> subscriber = new Subscriber<String>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(String s) {

        }
    };

    Observable.defer(new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {

            // I want call observer.onNext("") here

            subscriber.onNext("Test");
            return Observable.just("dasdsa");
        }

    });

Observable.defer(new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {

            // I want call observer.onNext("") here
            return Observable.just("dasdsa");
        }

    }).subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            //on Next was called after the subscribe
        }
    });

最终订户=新订户（）{
@凌驾
未完成的公共无效（）{
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
public void onNext（字符串s）{
}
};
可观察的延迟（新的Func0（）{
@凌驾
公共可观测呼叫（）{
//我想在这里调用observer.onNext（“”）
订户.onNext（“测试”）；
可观察的回报。公正（“dasdsa”）；
}
});

但是，您也可以订阅这个observate，它将在subscribe方法中调用这个“onNext”，如下所示：

final Subscriber<String> subscriber = new Subscriber<String>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(String s) {

        }
    };

    Observable.defer(new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {

            // I want call observer.onNext("") here

            subscriber.onNext("Test");
            return Observable.just("dasdsa");
        }

    });

Observable.defer(new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {

            // I want call observer.onNext("") here
            return Observable.just("dasdsa");
        }

    }).subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            //on Next was called after the subscribe
        }
    });

Observable.defer（新函数0（）{
@凌驾
公共可观测呼叫（）{
//我想在这里调用observer.onNext（“”）
可观察的回报。公正（“dasdsa”）；
}
}).订阅（新操作1（）{
@凌驾
公共无效调用（字符串s）{
//在订阅之后调用了on Next
}
});

我想由你来决定什么更有用，我希望我能帮上忙