将变量“放入”RxJava链以供以后使用

Question

我正在Android上使用RxJava来执行登录操作。

我需要传入用户名、密码和布尔标志。用户名和密码并发送到服务器进行验证，一旦返回响应，我需要使用该标志来确定下一步要做什么。

由于登录操作是异步的，所以我希望确保当响应返回时，我仍然可以访问我在开始时传入的用户名、密码和标志。

以下是我认为存在问题的最初编码方式：

    public Observable<Result> execute1(final String username, final String password, final boolean shouldSaveUsername) {
    return mLoginNetwork
            .loginWithCredentials(username, password)
            .map(new Func1<Response<Void>, LoginObject>() {
                @Override
                public LoginObject call(Response<Void> response) {
                    if (!response.isSuccessful()) {
                        Exceptions.propagate(new HttpException(response));
                    }

                    return new LoginObject(username, password, shouldSaveUsername);
                }
            })
            .doOnNext(new Action1<LoginObject>() {
                @Override
                public void call(LoginObject loginObject) {
                    if (loginObject.shouldSaveUsername) {
                        saveUsername(username);
                    }
                }
            })
            .flatMap(new Func1<Entitlement, Observable<Result>>() {
                @Override
                public Observable<Result> call(LoginObject loginObject) {
                    return mNetwork
                            .fetchSomething();
                }
            });
}

当我调用ecute1（）时，它会返回一个可观察的，我将其缓存然后订阅。如果发生Android配置更改，我会取消订阅可观察的，但将其保存在缓存中。配置更改完成后，我会将可观察的从缓存中取出并重新订阅它。当我重新订阅时，需要再次进行loginSus凭据调用，但当它返回时，用户名、密码和布尔标志将不再存在，因此我将无法在我的链中使用它们，这是一个问题。

那么，如何解决这个问题呢？

我需要一种方法，使可观察对象的输入数据成为可观察对象的一部分，以便在缓存可观察对象时，也会缓存输入数据。

以下是建议的解决方案：

    public Observable<Result> execute2(String username, String password, boolean shouldSaveUsername) {
    return Observable
            .just(new LoginData(username, password, shouldSaveUsername))
            .flatMap(new Func1<LoginData, Observable<LoginData>>() {
                @Override
                public Observable<?> call(final LoginData loginData) {
                    return mLoginNetwork
                            .loginWithCredentials(loginData.getUsername(), loginData.getPassword())
                            .map(new Func1<Response<Void>, LoginData>() {
                                @Override
                                public LoginData call(Response<Void> response) {
                                    if (!response.isSuccessful()) {
                                        Exceptions.propagate(new HttpException(response));
                                    }
                                    return loginData;
                                }
                            });
                }
            })
            .doOnNext(new Action1<LoginData>() {
                @Override
                public void call(LoginData loginData) {
                    if (loginData.shouldSaveUsername) {
                        saveUsername(username);
                    }
                }
            })
            .flatMap(new Func1<LoginData, Observable<Result>>() {
                @Override
                public Observable<Result> call(LoginData loginData) {
                    return mNetwork
                            .fetchSomething();
                }
            });
}

我试图做的是通过使用Observable立即将输入数据作为流的一部分。just（）将输入数据转换为可观察数据，然后让其他下游操作将其作为输入接收。我假设，如果我现在缓存可观察对象并稍后重新订阅，那么输入数据现在嵌入到我的可观察对象中，并且以后可以在任何操作符中访问。

我是否以“正常”的RxJava/功能性方式解决了我提出的解决方案中的问题？有没有更好的方法来解决这个问题？

Answer 1

用户名/密码/保存标志作为参数传递给刽子手1（），标记为最终。然后，在您的匿名嵌套类中，您显式引用这些值，“关闭”它们。生成的可观察链具有操作所需的所有绑定。

再次订阅可观察将使用原始用户名/密码/保存标志。