Swift 从函数从不发送onNext返回的可观察

如果函数返回onNext，我就可以看到它从未发送过onNext，但是如果我在返回它的函数中订阅它，onNext就会被调用

class InfoViewModel {

    func refreshPushToken() {

        PushNotificationService.sharedInstance.pushToken!
                .flatMapLatest { (pushToken: String) -> Observable<Result<User>> in
                    return UserService.registerPushToken(pushToken)
                }
                .subscribe { (event ) in
                    print(event)
                }
                .addDisposableTo(disposeBag)

    }
}

struct UserService {
    ....
    static func registerPushToken(_ pushToken: String) -> Observable<Result<User>> {
        ...
        return self.postUser(user: user)
    }

    static fileprivate func postUser(user: User) -> Observable<Result<User>> {

        let rxProvider: RxMoyaProvider<Backend> = RxMoyaProvider<Backend>(endpointClosure: Backend.endpointClosure)

         return rxProvider.request(Backend.register(user: user))
            .mapObject(type: User.self)
            .map({ (user: User) -> Result<User> in
                LogService.log(level: .debug, action: "postUser", message: "Posted user with success", parameters: ["user": user.deviceId])
                return .success(user)
            })
            .catchError({ error -> Observable<Result<User>> in
                LogService.log(level: .error, action: "postUser", message: "Error posting user", parameters: ["user": user.deviceId, "error": error.localizedDescription])
                return Observable.just(.failure(error))
            })
    }   
}

在UserService中，我将获得下一个事件

---

我尝试在InfoViewModel中的observable上使用

debug（）

，有一个订阅，我从来没有收到任何事件。

所以我想出来了，我在方法内部创建了RxMoyaProvider，所以一旦我超出了方法的范围，它就被释放了。这意味着当用户订阅它时，它无法再创建请求。这不会失败的原因是因为可观察对象是如何创建的

open func request(_ token: Target) -> Observable<Response> {

        // Creates an observable that starts a request each time it's subscribed to.
        return Observable.create { [weak self] observer in
            let cancellableToken = self?.request(token) { result in
                switch result {
                case let .success(response):
                    observer.onNext(response)
                    observer.onCompleted()
                case let .failure(error):
                    observer.onError(error)
                }
            }

            return Disposables.create {
                cancellableToken?.cancel()
            }
        }
    }

openfunc请求（uu标记：目标）->可观察{
//创建一个可观察对象，该对象在每次订阅请求时启动请求。
返回可观察的。在中创建{[弱自我]观察者
让CancelableToken=self？.request（token）{结果
切换结果{
成功案例（回复）：
onNext观察员（答复）
observer.onCompleted（）
案例失败（错误）：
observer.onError（错误）
}
}
归还一次性物品。创建{
CancelableToken？.cancel（）
}
}
}

---

如您所见，请求在订阅时被调用，但由于

self

已被解除分配，因此请求从未被触发。我得到的只是一个空的可观察对象。

所以我找到了它，我在方法内部创建了RxMoyaProvider，所以一旦我超出了方法的范围，它就被释放了。这意味着当用户订阅它时，它无法再创建请求。这不会失败的原因是因为可观察对象是如何创建的

open func request(_ token: Target) -> Observable<Response> {

        // Creates an observable that starts a request each time it's subscribed to.
        return Observable.create { [weak self] observer in
            let cancellableToken = self?.request(token) { result in
                switch result {
                case let .success(response):
                    observer.onNext(response)
                    observer.onCompleted()
                case let .failure(error):
                    observer.onError(error)
                }
            }

            return Disposables.create {
                cancellableToken?.cancel()
            }
        }
    }

openfunc请求（uu标记：目标）->可观察{
//创建一个可观察对象，该对象在每次订阅请求时启动请求。
返回可观察的。在中创建{[弱自我]观察者
让CancelableToken=self？.request（token）{结果
切换结果{
成功案例（回复）：
onNext观察员（答复）
observer.onCompleted（）
案例失败（错误）：
observer.onError（错误）
}
}
归还一次性物品。创建{
CancelableToken？.cancel（）
}
}
}

---

如您所见，请求在订阅时被调用，但由于

self

已被解除分配，因此请求从未被触发。我得到的只是一个空的可观察对象。

加上行号，我认为图像可以更好地显示这两个文件。我只是想帮助你更快地回答你的问题。^^ c/p代码ASAPObservables不会提供值，除非你订阅它们。这就是它们的工作原理。我在InfoViewModel中就是这样做的，我知道热观测和冷观测。加上行号，我认为图像可以更好地显示这两个文件。我只是想帮助你更快地回答你的问题。^^ c/p代码ASAPObservables不会提供值，除非你订阅它们。这就是它们的工作原理。我在InfoViewModel中就是这样做的，我知道热观测和冷观测。