如何使用改型RxJava等待回调

我提出了多个改装请求，每一个请求我都需要用新的令牌生成新的客户端。问题是它没有等待它完成，因此客户端是

null

。我还尝试将回调添加到

generatePrivateToken（）

，但没有成功

public void generatePrivateToken(){
        mNewControl.obstest(GETTOKEN)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Response<ResponseBody>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }
                    @Override
                    public void onNext(Response<ResponseBody> responseBodyResponse) {
                        key = responseBodyResponse.headers().get("Token");
                        new ApiKeys().encryptToken(key, new GeneralCallback() {
                            @Override
                            public void onSuccess(String token) {
                                Log.e("Token", token);
                                client = new HttpClient(USERNAME,token, emptyTag, emptyTag).getClient();
                            }
                        });
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onComplete() {

                    }
                });
    }

public void getControlData(){
    generatePrivateToken();

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(HOST_URL)
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())
            .build();
    newControl service = retrofit.create(newControl.class);
    Call<List<GetControlData>> call = service.controlData(CONTROL);
    call.enqueue(new Callback<List<GetControlData>>() {
        @Override
        public void onResponse(Call<List<GetControlData>> call, Response<List<GetControlData>> response) {
            //do something, start new retrofit method
        }
        @Override
        public void onFailure(Call<List<GetControlData>> call, Throwable t) {
        }
    });

}

public void generatePrivateToken（）{
mNewControl.obstest（GETTOKEN）
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.订阅（新观察员）{
@凌驾
认购的公共无效（一次性d）{
}
@凌驾
public void onNext（Response-responseBodyResponse）{
key=responseBodyResponse.headers（）.get（“令牌”）；
新的ApiKeys（）.encryptToken（密钥，新的GeneralCallback（））{
@凌驾
成功时公共无效（字符串标记）{
Log.e（“令牌”，令牌）；
client=新的HttpClient（用户名、令牌、emptyTag、emptyTag）.getClient（）；
}
});
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
未完成的公共空间（）{
}
});
}
public void getControlData（）{
generatePrivateToken（）；
改装改装=新改装.Builder（）
.baseUrl（主机URL）
.客户（客户）
.addConverterFactory（GsonConverterFactory.create（））
.build（）；
newControl服务=改装.create（newControl.class）；
Call Call=service.controlData（控制）；
call.enqueue（新回调（）{
@凌驾
公共void onResponse（调用、响应）{
//做点什么，开始新的改造方法
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
}
});
}

您的问题是众所周知的，这就是为什么我们在改装时需要比正常回调更能观察到rx的原因。看这个

假设您不想发出多个改装请求并等待所有请求完成，您可以使用

让我们首先定义改装对象

Retrofit repo = new Retrofit.Builder()
        .baseUrl("https://api.github.com")
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .build();

Observable<JsonObject> userObservable = repo
        .create(GitHubUser.class)
        .getUser(loginName)
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread());

Observable<JsonArray> eventsObservable = repo
        .create(GitHubEvents.class)
        .listEvents(loginName)
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread());

然后使用RxJava的zip方法组合我们的两个观察对象，并等待它们完成，然后再创建一个新的观察对象

Observable<UserAndEvents> combined = Observable.zip(userObservable, eventsObservable, new Func2<JsonObject, JsonArray, UserAndEvents>() {
  @Override
  public UserAndEvents call(JsonObject jsonObject, JsonArray jsonElements) {
    return new UserAndEvents(jsonObject, jsonElements);
  }
});

Observable combined=Observable.zip（userObservable，eventsObservable，new Func2（）{
@凌驾
公共用户和事件调用（JsonObject JsonObject、JsonArray jsonElements）{
返回新用户和事件（jsonObject、jsonElements）；
}
});

有关更多详细信息，请访问上面给出的答案a，它很好，并进行了充分解释

Observable<UserAndEvents> combined = Observable.zip(userObservable, eventsObservable, new Func2<JsonObject, JsonArray, UserAndEvents>() {
  @Override
  public UserAndEvents call(JsonObject jsonObject, JsonArray jsonElements) {
    return new UserAndEvents(jsonObject, jsonElements);
  }
});