iOS项目中全局复用用户数据的最优设计模式咨询

嘿，这个问题我之前在做iOS项目时也纠结过，太懂你这种既要方便全局复用用户数据，又不想用粗暴全局变量的痛点了——毕竟全局状态很容易写出耦合度高、后期难维护的代码。下面几种都是iOS开发里经过实践验证的方案，你可以根据自己项目的规模和需求来选：

方案1：封装后的单例模式（谨慎使用，但可控） #

单例不是洪水猛兽，只要做好封装和边界控制，完全可以用来管理用户数据。核心是把用户数据的加载、存储逻辑都封装在一个单例类里，对外只暴露必要的接口，避免直接修改数据。

示例代码：

import Foundation

// 先定义用户数据模型
struct UserModel: Codable {
    let id: String
    let name: String
    let email: String
    // 其他字段...
}

class UserManager {
    // 线程安全的单例实例
    static let shared: UserManager = {
        let instance = UserManager()
        return instance
    }()
    
    // 私有初始化方法，防止外部创建实例
    private init() {}
    
    // 私有存储用户数据，外部只能读取不能直接修改
    private(set) var userData: UserModel?
    
    // 从服务器加载用户数据的方法
    func fetchUserData(completion: @escaping (Result<UserModel, Error>) -> Void) {
        // 这里替换成你的服务器请求逻辑
        let url = URL(string: "https://your-api.com/user")!
        URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
            DispatchQueue.main.async {
                if let error = error {
                    completion(.failure(error))
                    return
                }
                guard let data = data else {
                    completion(.failure(NSError(domain: "UserDataError", code: -1, userInfo: [NSLocalizedDescriptionKey: "No data received"])))
                    return
                }
                do {
                    let user = try JSONDecoder().decode(UserModel.self, from: data)
                    self?.userData = user
                    completion(.success(user))
                } catch {
                    completion(.failure(error))
                }
            }
        }.resume()
    }
    
    // 可选：清除用户数据（比如退出登录）
    func clearUserData() {
        userData = nil
    }
}

使用方式：在任何控制器里直接调用UserManager.shared.userData获取数据，需要刷新时调用fetchUserData。

注意点：如果要提高可测试性，可以给UserManager定义一个协议，比如UserDataProvider，让单例实现这个协议。测试时就可以用Mock类替换真实的UserManager。

方案2：依赖注入（Dependency Injection，推荐用于中大型项目） #

这是解耦的最优方案之一，核心是把用户数据提供者传递给需要它的控制器，而不是让控制器主动去获取全局实例。这样一来，控制器和数据管理类之间的依赖关系变得清晰，测试时也能轻松替换实现。

第一步：定义数据提供者协议

protocol UserDataProvider {
    var userData: UserModel? { get }
    func fetchUserData(completion: @escaping (Result<UserModel, Error>) -> Void)
    func clearUserData()
}

// 实现远程数据提供者（从服务器获取数据）
class RemoteUserDataProvider: UserDataProvider {
    private(set) var userData: UserModel?
    
    func fetchUserData(completion: @escaping (Result<UserModel, Error>) -> Void) {
        // 和上面UserManager里的请求逻辑一致
        let url = URL(string: "https://your-api.com/user")!
        URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
            DispatchQueue.main.async {
                // 处理请求结果...
            }
        }.resume()
    }
    
    func clearUserData() {
        userData = nil
    }
}

第二步：在控制器中注入提供者

class ProfileViewController: UIViewController {
    private let userProvider: UserDataProvider
    
    // 通过初始化方法注入，保证控制器创建时就拿到依赖
    init(userProvider: UserDataProvider) {
        self.userProvider = userProvider
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // 使用用户数据
        if let user = userProvider.userData {
            updateProfileUI(with: user)
        } else {
            // 如果数据还没加载，主动触发请求
            userProvider.fetchUserData { [weak self] result in
                switch result {
                case .success(let user):
                    self?.updateProfileUI(with: user)
                case .failure(let error):
                    print("加载用户数据失败：\(error.localizedDescription)")
                }
            }
        }
    }
    
    private func updateProfileUI(with user: UserModel) {
        // 更新UI逻辑
        title = user.name
    }
}

第三步：在App入口处统一创建并传递依赖

// 在SceneDelegate或者AppDelegate里
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    guard let windowScene = (scene as? UIWindowScene) else { return }
    
    let window = UIWindow(windowScene: windowScene)
    let userProvider = RemoteUserDataProvider()
    
    // 预加载用户数据（可选）
    userProvider.fetchUserData { result in
        switch result {
        case .success:
            print("用户数据加载完成")
        case .failure(let error):
            print("预加载失败：\(error)")
        }
    }
    
    // 创建控制器并注入依赖
    let profileVC = ProfileViewController(userProvider: userProvider)
    window.rootViewController = UINavigationController(rootViewController: profileVC)
    self.window = window
    window.makeKeyAndVisible()
}

优点：完全解耦，代码可测试性极强，后期扩展（比如切换到本地缓存数据）只需要实现新的UserDataProvider即可，不需要修改控制器代码。

小技巧：如果控制器层级很深，手动传递依赖太麻烦，可以自己实现一个简单的依赖容器，或者使用第三方DI框架（比如Swinject）来管理依赖。

方案3：响应式方案（Combine，适合iOS 13+） #

如果你的项目支持iOS 13及以上，用Combine的响应式编程可以让数据更新和UI同步变得更简洁。核心是用ObservableObject和@Published属性来发布数据变化，控制器订阅这个变化并自动更新UI。

示例代码：

import Combine

class UserStore: ObservableObject {
    @Published var userData: UserModel?
    private var cancellables = Set<AnyCancellable>()
    
    func fetchUserData() {
        let url = URL(string: "https://your-api.com/user")!
        URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: UserModel.self, decoder: JSONDecoder())
            .receive(on: DispatchQueue.main)
            .sink(receiveCompletion: { completion in
                if case .failure(let error) = completion {
                    print("加载失败：\(error)")
                }
            }, receiveValue: { [weak self] user in
                self?.userData = user
            })
            .store(in: &cancellables)
    }
    
    func clearUserData() {
        userData = nil
    }
}

控制器中使用：

class ProfileViewController: UIViewController {
    private let userStore: UserStore
    private var cancellables = Set<AnyCancellable>()
    
    init(userStore: UserStore) {
        self.userStore = userStore
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 订阅用户数据变化，自动更新UI
        userStore.$userData
            .receive(on: DispatchQueue.main)
            .sink { [weak self] user in
                self?.updateProfileUI(with: user)
            }
            .store(in: &cancellables)
        
        // 如果数据为空，触发加载
        if userStore.userData == nil {
            userStore.fetchUserData()
        }
    }
    
    private func updateProfileUI(with user: UserModel?) {
        title = user?.name ?? "未登录"
        // 其他UI更新...
    }
}

优点：响应式编程让数据和UI的绑定更直观，数据更新时UI自动刷新，不需要手动调用方法或发送通知。

方案4：通知中心（NotificationCenter，不推荐，仅应急使用） #

如果项目很小，或者临时需要快速实现，可以用通知中心来传递数据更新事件，但这种方式耦合度高，后期维护难度大，尽量少用。

示例代码：

// 定义通知名称
extension Notification.Name {
    static let userDataUpdated = Notification.Name("UserDataUpdated")
}

// 加载数据后发送通知
func fetchUserData() {
    let url = URL(string: "https://your-api.com/user")!
    URLSession.shared.dataTask(with: url) { data, response, error in
        DispatchQueue.main.async {
            if let data = data, let user = try? JSONDecoder().decode(UserModel.self, from: data) {
                NotificationCenter.default.post(name: .userDataUpdated, object: user)
            }
        }
    }.resume()
}

// 控制器中监听通知
class ProfileViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        NotificationCenter.default.addObserver(self, selector: #selector(onUserDataUpdated(_:)), name: .userDataUpdated, object: nil)
    }
    
    @objc private func onUserDataUpdated(_ notification: Notification) {
        if let user = notification.object as? UserModel {
            updateProfileUI(with: user)
        }
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}

缺点：通知的发送和接收分散在代码各处，难以追踪数据流向，容易出现内存泄漏，而且无法保证数据的一致性。

总结 #

• 小型项目：用封装后的单例足够，简单直接；
• 中大型项目：优先选依赖注入，解耦性和可维护性拉满；
• iOS 13+项目：可以结合Combine响应式方案，让数据更新更流畅；
• 通知中心尽量避免，除非是临时应急场景。

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