Rx java 无法建立此可观察的

要构建完整的

用户

实体，我需要执行以下任务：

从

userId

从

userId

从

UserResponse.addressId

从

用户响应

和

列表

以及

地址

构建

用户

我试过这个：

public Observable<User> getUserById(String userId) {    
    return Observable.zip(getUserResponse(userId), getRoles(userId), new Func2<UserResponse, List<Role>, User>() {
        @Override
        public User call(UserResponse response, List<Role> roles) {
            //I need the address here!
        }
});

用户

构造函数如下所示：

public User(String userId, Address address, List<Role> roles) { ... }

public User（字符串userId、地址地址、列表角色）{…}

我希望你能理解。很难解释这个问题。

我找到了一个解决方案：

public Observable<User> getUserById(String userId) {  
    return Observable.zip(
        getUserResponse(userId),
        getUserResponse(userId).flatMap(new Func1<UserResponse, Observable<Address>>() {
            @Override
            public Observable<Address> call(UserResponse resp) {
                return addressRepository.getAddress(resp.addressId);
            }
        }),
        getRoles(userId), new Func3<UserResponse, Address, List<Role>, User>() {
            @Override
            public User call(UserResponse resp, Address ad, List<Role> roles) {
                //Now, I have all I need to build the User =)
            }
        }
});

public可观察的getUserById（stringuserid）{
return-Observable.zip(
getUserResponse（用户ID），
getUserResponse（userId）.flatMap（新的Func1（）{
@凌驾
公共可观察呼叫（用户响应响应）{
返回addressRepository.getAddress（分别为addressId）；
}
}),
getRoles（userId），新Func3（）{
@凌驾
公共用户呼叫（用户响应响应、地址广告、列表角色）{
//现在，我有了构建User=）所需的一切
}
}
});

如有任何意见，将不胜感激。“重复”调用

getUserResponse（userId）

是否是一种好的做法？我没有找到其他方法来解决这个问题。

我找到了一个解决方案：

public Observable<User> getUserById(String userId) {  
    return Observable.zip(
        getUserResponse(userId),
        getUserResponse(userId).flatMap(new Func1<UserResponse, Observable<Address>>() {
            @Override
            public Observable<Address> call(UserResponse resp) {
                return addressRepository.getAddress(resp.addressId);
            }
        }),
        getRoles(userId), new Func3<UserResponse, Address, List<Role>, User>() {
            @Override
            public User call(UserResponse resp, Address ad, List<Role> roles) {
                //Now, I have all I need to build the User =)
            }
        }
});

public可观察的getUserById（stringuserid）{
return-Observable.zip(
getUserResponse（用户ID），
getUserResponse（userId）.flatMap（新的Func1（）{
@凌驾
公共可观察呼叫（用户响应响应）{
返回addressRepository.getAddress（分别为addressId）；
}
}),
getRoles（userId），新Func3（）{
@凌驾
公共用户呼叫（用户响应响应、地址广告、列表角色）{
//现在，我有了构建User=）所需的一切
}
}
});

如有任何意见，将不胜感激。“重复”调用

getUserResponse（userId）

是否是一种好的做法？我没有找到其他方法来解决此问题。

使用

cache（）

操作符：

public Observable<User> getUserById(String userId) {  
  Observable<UserResponse> response = getUserResponse(userId).cache();
  return Observable.zip(
    response,
    response.flatMap(new Func1<UserResponse, Observable<Address>>() {
        @Override
        public Observable<Address> call(UserResponse resp) {
            return addressRepository.getAddress(resp.addressId);
        }
    }),
    getRoles(userId), new Func3<UserResponse, Address, List<Role>, User>() {
        @Override
        public User call(UserResponse resp, Address ad, List<Role> roles) {
            //Now, I have all I need to build the User =)
        }
    }
  });
}

public可观察的getUserById（stringuserid）{
可观测响应=getUserResponse（userId）.cache（）；
return-Observable.zip(
答复,，
response.flatMap（新的Func1（）{
@凌驾
公共可观察呼叫（用户响应响应）{
返回addressRepository.getAddress（分别为addressId）；
}
}),
getRoles（userId），新Func3（）{
@凌驾
公共用户呼叫（用户响应响应、地址广告、列表角色）{
//现在，我有了构建User=）所需的一切
}
}
});
}

使用

缓存（）

操作符：

public Observable<User> getUserById(String userId) {  
  Observable<UserResponse> response = getUserResponse(userId).cache();
  return Observable.zip(
    response,
    response.flatMap(new Func1<UserResponse, Observable<Address>>() {
        @Override
        public Observable<Address> call(UserResponse resp) {
            return addressRepository.getAddress(resp.addressId);
        }
    }),
    getRoles(userId), new Func3<UserResponse, Address, List<Role>, User>() {
        @Override
        public User call(UserResponse resp, Address ad, List<Role> roles) {
            //Now, I have all I need to build the User =)
        }
    }
  });
}

public可观察的getUserById（stringuserid）{
可观测响应=getUserResponse（userId）.cache（）；
return-Observable.zip(
答复,，
response.flatMap（新的Func1（）{
@凌驾
公共可观察呼叫（用户响应响应）{
返回addressRepository.getAddress（分别为addressId）；
}
}),
getRoles（userId），新Func3（）{
@凌驾
公共用户呼叫（用户响应响应、地址广告、列表角色）{
//现在，我有了构建User=）所需的一切
}
}
});
}

将使其成为可连接的可观察的，并且只在有2个订阅者的地方开始发布，这样您将只调用后端一次

getUserAddress（）将调用getUserResponse并从中获取地址

现在将getUserResponse、getUserAddress和getRoles（userId）压缩到一起：）

将使其成为可连接的可观察的，并且只在有2个订阅者的地方开始发布，这样您将只调用后端一次

getUserAddress（）将调用getUserResponse并从中获取地址

---

现在，将getUserResponse、getUserAddress和getRoles（userId）压缩到一起：）

您可以使用

flatMap的一个变体

public Observable<User> getUserById(String userId) {  
    return Observable.zip(
          getUserResponse(userId).flatMap(new Func1<UserResponse, Observable<Address>>() {
            @Override
            public Observable<Address> call(UserResponse resp) {
                return addressRepository.getAddress(resp.addressId);
            }
          },
          new Func2<UserResponse, Address, Pair<UserResponse,Address>>() {
            @Override
            public Pair<UserResponse,Address> call(UserResponse resp, Address addr) {
                return new Pair<UserResponse,Address>(resp,addressRepository.getAddress(resp.addressId));
            }       
          }),
          getRoles(userId),
          new Func2<Pair<UserResponse, Address>, List<Role>, User>(){
            @Override
            public User call(UserResponse resp, Address ad, List<Role> roles) {
            //Now, I have all I need to build the User
            }             
          }
        );
}

public可观察的getUserById（stringuserid）{
return-Observable.zip(
getUserResponse（userId）.flatMap（新的Func1（）{
@凌驾
公共可观察呼叫（用户响应响应）{
返回addressRepository.getAddress（分别为addressId）；
}
},
新功能2（）{
@凌驾
公共对呼叫（UserResponse resp，addr地址）{
返回新的对（resp，addressRepository.getAddress（resp.addressId））；
}       
}),
getRoles（用户ID），
新功能2（）{
@凌驾
公共用户呼叫（用户响应响应、地址广告、列表角色）{
//现在，我已经具备了构建用户所需的一切
}             
}
);
}
您可以使用
平面地图的变体

public Observable<User> getUserById(String userId) {  
    return Observable.zip(
          getUserResponse(userId).flatMap(new Func1<UserResponse, Observable<Address>>() {
            @Override
            public Observable<Address> call(UserResponse resp) {
                return addressRepository.getAddress(resp.addressId);
            }
          },
          new Func2<UserResponse, Address, Pair<UserResponse,Address>>() {
            @Override
            public Pair<UserResponse,Address> call(UserResponse resp, Address addr) {
                return new Pair<UserResponse,Address>(resp,addressRepository.getAddress(resp.addressId));
            }       
          }),
          getRoles(userId),
          new Func2<Pair<UserResponse, Address>, List<Role>, User>(){
            @Override
            public User call(UserResponse resp, Address ad, List<Role> roles) {
            //Now, I have all I need to build the User
            }             
          }
        );
}

public可观察的getUserById（stringuserid）{
return-Observable.zip(
getUserResponse（userId）.flatMap（新的Func1（）{
@凌驾
公共可观察呼叫（用户响应响应）{
返回addressRepository.getAddress（分别为addressId）；
}
},
新功能2（）{
@凌驾
公共对呼叫（UserResponse resp，addr地址）{
返回新的对（resp，addressRepository.getAddress（resp.addressId））；
}       
}),
getRoles（用户ID），
新功能2（）{
@凌驾
公共用户呼叫（用户响应响应、地址广告、列表角色）{
//现在，我已经具备了构建用户所需的一切
}             
}
);
}
getUserResponse（userId）.publish.autoConnect（2）；将使其成为可连接的可观察的，并且只在有2个订阅者的地方开始发布，这样您将调用