使用RxSwift结合DispatchGroup后无法返回合并对象的问题

我明白你的问题了——你想用DispatchGroup协调三个API请求，等所有数据都拿到后合并成HowToInfo对象再返回Observable<HowToInfo>，但现在没法把合并后的对象正确传递给调用方。问题出在你把GCD的DispatchGroup和RxSwift结合时，没有正确适配Observable的生命周期和事件发送逻辑。下面给你两种解决方案，优先推荐更符合Rx思维的方式：

推荐方案：用RxSwift的zip操作符替代DispatchGroup #

RxSwift本身提供了专门处理多异步请求合并的操作符，zip就是最适合你场景的——它会等待所有传入的Observable都发出一个元素，然后把这些元素合并起来返回一个新的Observable。这种方式完全不需要手动管理DispatchGroup，代码更简洁，也更符合响应式编程的思想。

假设你的三个API请求分别返回如下Observable：

• getMaterialInfo(materialNo:) → Observable<MaterialInfo>
• getStepInfo(materialNo:) → Observable<StepInfo>
• getTipInfo(materialNo:) → Observable<TipInfo>

你可以这样改写函数：

func getHowToInfo(materialNo: String) -> Observable<HowToInfo> {
    // 先获取三个API的Observable流
    let materialInfo$ = self.getMaterialInfo(materialNo: materialNo)
    let stepInfo$ = self.getStepInfo(materialNo: materialNo)
    let tipInfo$ = self.getTipInfo(materialNo: materialNo)
    
    // 用zip等待所有流都发出数据，然后合并成HowToInfo
    return Observable.zip(materialInfo$, stepInfo$, tipInfo$) { material, step, tip in
        // 在这里根据三个数据源创建合并后的HowToInfo对象
        return HowToInfo(material: material, steps: step, tips: tip)
    }
}

为什么这个方案更好？ #

• 自动处理异步等待：Rx会帮你管理所有请求的异步流程，无需手动调用enter()/leave()。
• 内置错误处理：如果任何一个API请求失败，整个zip流会直接发送错误事件，符合Rx的错误传播逻辑。
• 生命周期自动管理：当外部取消订阅这个Observable时，所有内部的API请求都会自动取消，避免内存泄漏。

兼容DispatchGroup的修正方案（如果一定要用GCD） #

如果你坚持要使用DispatchGroup，需要修正几个关键问题：确保每个请求的enter()/leave()配对、在notify中正确发送Observable事件、同时管理所有子订阅的生命周期。

修正后的代码示例：

func getHowToInfo(materialNo: String) -> Observable<HowToInfo> {
    return Observable.create { observer in
        let dispatchGroup = DispatchGroup()
        // 定义变量存储每个API的结果
        var materialInfo: MaterialInfo?
        var stepInfo: StepInfo?
        var tipInfo: TipInfo?
        
        // 第一个API请求
        dispatchGroup.enter()
        let materialDisposable = self.getMaterialInfo(materialNo: materialNo)
            .subscribe(
                onNext: { info in materialInfo = info },
                onCompleted: { dispatchGroup.leave() },
                onError: { error in
                    observer.onError(error)
                    dispatchGroup.leave() // 出错也要调用leave，避免Group永久等待
                }
            )
        
        // 第二个API请求
        dispatchGroup.enter()
        let stepDisposable = self.getStepInfo(materialNo: materialNo)
            .subscribe(
                onNext: { info in stepInfo = info },
                onCompleted: { dispatchGroup.leave() },
                onError: { error in
                    observer.onError(error)
                    dispatchGroup.leave()
                }
            )
        
        // 第三个API请求
        dispatchGroup.enter()
        let tipDisposable = self.getTipInfo(materialNo: materialNo)
            .subscribe(
                onNext: { info in tipInfo = info },
                onCompleted: { dispatchGroup.leave() },
                onError: { error in
                    observer.onError(error)
                    dispatchGroup.leave()
                }
            )
        
        // 等待所有请求完成后，合并数据并发送事件
        dispatchGroup.notify(queue: .main) {
            // 检查所有数据是否都成功获取
            guard let material = materialInfo, let step = stepInfo, let tip = tipInfo else {
                let error = NSError(
                    domain: "HowToInfoError",
                    code: -1,
                    userInfo: [NSLocalizedDescriptionKey: "部分API数据获取失败"]
                )
                observer.onError(error)
                return
            }
            
            // 创建合并对象并发送给订阅者
            let howToInfo = HowToInfo(material: material, steps: step, tips: tip)
            observer.onNext(howToInfo)
            observer.onCompleted() // 必须发送completed，标志流结束
        }
        
        // 返回组合的Disposable，确保外部取消订阅时，所有子请求都被取消
        return Disposables.create(materialDisposable, stepDisposable, tipDisposable)
    }
}

关键注意事项： #

• 配对enter()和leave()：每个API请求开始前调用enter()，在请求完成（无论是成功还是失败）时必须调用leave()，否则DispatchGroup会一直等待，永远不会触发notify。
• 正确发送Observable事件：在notify中必须调用onNext()发送合并后的对象，还要调用onCompleted()标志流结束；如果任何请求出错，要及时发送onError()事件。
• 管理订阅生命周期：返回的Disposable要包含所有子订阅的Disposable，这样当外部取消订阅时，所有内部的API请求都会被取消，避免内存泄漏。

内容的提问来源于stack exchange，提问作者mars_dev