Swift中如何对ObservableObject的@Published属性实现跨层双向绑定

问题背景 #

常规开发中，我们通过@ObservedObject可以轻松实现View与ObservableObject的双向绑定，示例代码如下：

struct MyView {
    @ObservedObject var stuff = MyObject()
    var body: some View { TextField(text: $stuff.value) }
}

class MyObject : ObservableObject {
    @Published var value: String = "some value"
}

但现在需要构建一个支持UserDefaults存储、Apple Watch同步、带日志功能的通用持久化层，要求实现持久化层到MyObject的双向绑定：当手表端修改值时，持久化层能同步更新MyObject的属性，进而自动刷新UI。

尝试过在MyObject的初始化方法中绑定存储层，但遇到瓶颈：

class MyObject : ObservableObject {
    @Published var value: String = "some value"

    init() {
        Storage.shared.bind("value", $value );
    }
}

• 如果bind方法接收Published<String>.Publisher，只能订阅属性变化，无法从存储层反向设置属性；
• 如果传入Binding，又不知道如何在非UI场景下实现双向同步；
• 由于有大量对象和属性，需要通用方案来减少重复代码。

通用解决方案 #

1. 封装通用Storage绑定工具类 #

基于Combine框架实现双向同步逻辑，同时处理属性到存储、存储到属性的双向流程：

import Combine
import Foundation

class Storage {
    static let shared = Storage()
    
    private let userDefaults = UserDefaults.standard
    private var cancellables = Set<AnyCancellable>()
    
    // 通用双向绑定方法
    func bind<T: Codable & Equatable>(_ key: String, to published: Published<T>.Publisher, setValue: @escaping (T) -> Void) {
        // 初始化：从存储层加载初始值到属性
        if let data = userDefaults.data(forKey: key),
           let storedValue = try? JSONDecoder().decode(T.self, from: data) {
            setValue(storedValue)
        }
        
        // 订阅属性变化，同步到存储层
        published
            .removeDuplicates()
            .sink { [weak self] newValue in
                guard let self = self else { return }
                if let data = try? JSONEncoder().encode(newValue) {
                    self.userDefaults.set(data, forKey: key)
                    // 添加日志逻辑
                    print("[Storage] Updated key: \(key) to value: \(newValue)")
                    // 这里可以扩展Apple Watch同步逻辑
                    // self.syncToWatch(key: key, value: newValue)
                }
            }
            .store(in: &cancellables)
        
        // 监听存储层变更（如Watch端同步的修改），同步到属性
        NotificationCenter.default.publisher(for: UserDefaults.didChangeNotification)
            .map { [weak self] _ in
                self?.userDefaults.data(forKey: key)
            }
            .compactMap { $0 }
            .compactMap { try? JSONDecoder().decode(T.self, from: $0) }
            .removeDuplicates()
            .sink { newValue in
                setValue(newValue)
            }
            .store(in: &cancellables)
    }
    
    // 可选：Apple Watch同步实现示例
    private func syncToWatch<T: Codable>(key: String, value: T) {
        // 这里添加WatchConnectivity的同步代码，比如sendMessage或updateApplicationContext
    }
}

2. 在ObservableObject中简化绑定调用 #

通过闭包传递属性设置逻辑，减少重复代码：

class MyObject : ObservableObject {
    @Published var value: String = "some value"
    @Published var count: Int = 0
    
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        // 绑定字符串属性
        Storage.shared.bind("myObject_value", to: $value) { [weak self] newValue in
            self?.value = newValue
        }
        
        // 绑定整数属性
        Storage.shared.bind("myObject_count", to: $count) { [weak self] newValue in
            self?.count = newValue
        }
    }
}

3. 进阶：自定义属性包装器彻底消除重复代码 #

用属性包装器封装所有绑定逻辑，使用时只需标记属性即可：

@propertyWrapper
struct Stored<T: Codable & Equatable> {
    private let key: String
    private let defaultValue: T
    private var cancellables = Set<AnyCancellable>()
    
    init(key: String, defaultValue: T) {
        self.key = key
        self.defaultValue = defaultValue
        // 初始化加载存储值
        self.wrappedValue = Self.loadValue(forKey: key, defaultValue: defaultValue)
        
        // 监听存储层变更
        NotificationCenter.default.publisher(for: UserDefaults.didChangeNotification)
            .map { Self.loadValue(forKey: key, defaultValue: defaultValue) }
            .removeDuplicates()
            .sink { [weak self] newValue in
                self?.wrappedValue = newValue
            }
            .store(in: &cancellables)
    }
    
    var wrappedValue: T {
        willSet {
            // 同步到存储层
            if let data = try? JSONEncoder().encode(newValue) {
                UserDefaults.standard.set(data, forKey: key)
                print("[Stored] Updated key: \(key) to value: \(newValue)")
                // 可在这里添加Watch同步逻辑
            }
        }
    }
    
    private static func loadValue(forKey key: String, defaultValue: T) -> T {
        guard let data = UserDefaults.standard.data(forKey: key),
              let value = try? JSONDecoder().decode(T.self, from: data) else {
            return defaultValue
        }
        return value
    }
}

使用方式极度简化：

class MyObject : ObservableObject {
    @Stored(key: "myObject_value", defaultValue: "some value")
    var value: String
    
    @Stored(key: "myObject_count", defaultValue: 0)
    var count: Int
}

方案优势 #

• 通用性：支持所有Codable & Equatable类型，无需为每个类型单独编写逻辑；
• 低侵入性：不修改原有ObservableObject核心逻辑，仅通过工具类或属性包装器实现绑定；
• 自动同步：同时处理属性→存储、存储→属性的双向同步，包括Watch端的跨设备修改；
• 可扩展性：可轻松添加日志、Watch同步、Keychain存储等扩展功能。

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