基于ReactiveSwift+SDWebImage的多VC异步加载用户头像最优实现方案

嘿，这个场景我实际开发中刚好碰到过，结合ReactiveSwift和SDWebImage的话，最优方案绝对是把头像加载逻辑抽成一个全局单例服务——既能保证同一个头像URL只发一次请求，又能让所有需要展示的ViewController共享同一个加载信号，完美解决多页面同步监听的问题。下面给你一步步拆解具体实现：

核心逻辑就是用单例服务统一管理所有头像的加载请求，同时维护一个信号池缓存每个URL对应的加载信号。这样不管多少个VC订阅同一个头像URL，都只会触发一次网络请求，并且所有订阅者能同步收到加载完成/失败的通知，还能复用SDWebImage的本地缓存能力。

1. 封装全局头像加载服务（单例） #

这个服务会负责：检查SDWebImage本地缓存、发起网络请求、缓存加载信号、处理线程安全。代码示例如下：

import ReactiveSwift
import SDWebImage

class AvatarService {
    // 单例实例，全局唯一
    static let shared = AvatarService()
    private init() {}
    
    // 缓存已创建的加载信号，避免重复请求同一URL
    private var signalPool: [URL: SignalProducer<UIImage, Error>] = [:]
    // 线程锁，保证多线程下操作signalPool的安全性
    private let poolLock = NSLock()
    
    // 获取指定URL的头像加载信号
    func avatarProducer(for url: URL) -> SignalProducer<UIImage, Error> {
        poolLock.lock()
        defer { poolLock.unlock() }
        
        // 先检查信号池里有没有现成的信号，有就直接返回
        if let existingProducer = signalPool[url] {
            return existingProducer
        }
        
        // 没有的话创建新的加载信号
        let producer = SignalProducer<UIImage, Error> { observer, lifetime in
            // 第一步：先查SDWebImage的本地缓存
            if let cachedImage = SDImageCache.shared.imageFromCache(forKey: url.absoluteString) {
                observer.send(value: cachedImage)
                observer.sendCompleted()
                return
            }
            
            // 缓存没有，发起网络请求
            let task = SDWebImageManager.shared.loadImage(
                with: url,
                options: [],
                progress: nil
            ) { image, data, error, cacheType, finished, url in
                guard finished else { return }
                
                if let error = error {
                    observer.send(error: error)
                } else if let image = image {
                    observer.send(value: image)
                    observer.sendCompleted()
                } else {
                    observer.send(error: NSError(
                        domain: "AvatarService",
                        code: -1,
                        userInfo: [NSLocalizedDescriptionKey: "Failed to load avatar"]
                    ))
                }
            }
            
            // 订阅生命周期结束时取消请求，避免内存泄漏
            lifetime.observeEnded {
                task?.cancel()
            }
        }
        
        // 用replayLazily让多个订阅者共享同一个加载结果，take(first:1)确保信号只发送一次完成事件
        let sharedProducer = producer.take(first: 1).replayLazily(upTo: 1)
        signalPool[url] = sharedProducer
        
        return sharedProducer
    }
    
    // 可选：当用户更新头像时，调用这个方法清除旧的缓存和信号
    func invalidateAvatar(for url: URL) {
        poolLock.lock()
        defer { poolLock.unlock() }
        signalPool.removeValue(forKey: url)
        SDImageCache.shared.removeImage(forKey: url.absoluteString)
    }
}

2. 在ViewController中订阅信号 #

每个需要展示头像的VC只需要调用服务的avatarProducer方法，订阅信号并更新UI即可。这里可以同时处理加载中、加载成功、加载失败三种状态：

class ProfileViewController: UIViewController {
    @IBOutlet weak var avatarImageView: UIImageView!
    @IBOutlet weak var loadingIndicator: UIActivityIndicatorView!
    
    // 示例头像URL
    private let targetAvatarURL = URL(string: "https://example.com/user/avatar.jpg")!
    // 管理订阅生命周期，避免内存泄漏
    private let disposeBag = CompositeDisposable()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupAvatarLoading()
    }
    
    private func setupAvatarLoading() {
        // 初始化状态：显示加载指示器和占位图
        loadingIndicator.startAnimating()
        avatarImageView.image = UIImage(named: "placeholder-avatar")
        
        // 获取头像加载信号并订阅
        let avatarProducer = AvatarService.shared.avatarProducer(for: targetAvatarURL)
        let disposable = avatarProducer
            .observe(on: UIScheduler()) // 切换到主线程更新UI
            .startWithResult { [weak self] result in
                guard let self = self else { return }
                self.loadingIndicator.stopAnimating()
                
                switch result {
                case .success(let image):
                    // 加载成功：给图片加淡入动画提升体验
                    UIView.transition(
                        with: self.avatarImageView,
                        duration: 0.3,
                        options: .transitionCrossDissolve
                    ) {
                        self.avatarImageView.image = image
                    }
                case .failure(let error):
                    // 加载失败：打印错误并显示错误占位图
                    print("Avatar load failed: \(error.localizedDescription)")
                    self.avatarImageView.image = UIImage(named: "error-avatar")
                }
            }
        
        // 将订阅加入disposeBag，VC销毁时自动取消订阅
        disposeBag.insert(disposable)
    }
    
    deinit {
        disposeBag.dispose()
    }
}

• 批量加载处理：如果需要同时加载多个头像，可以用SignalProducer.zip合并多个信号，统一处理所有头像的加载状态。
• 内存优化：如果APP中有大量不同的头像URL，可以定期清理信号池里长时间未被订阅的信号，避免内存占用过高。
• 状态同步：如果某个VC需要主动刷新头像，直接调用AvatarService.shared.invalidateAvatar(for: url)，然后重新订阅信号即可。

这种实现方式的最大优势就是逻辑集中、请求复用、状态同步，所有VC只需要关注UI展示，不用重复处理加载逻辑，完美契合你的需求。

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