Swift与CoreData中是否存在Kotlin Flow的等效实现？

CoreData里确实有两种主流方式，能实现和你Kotlin中Room+Flow一样的数据库变更实时同步UI的效果，下面分别说明：

1. 使用Combine框架的NSFetchRequest Publisher（最接近Flow的用法） #

Combine是Swift的响应式编程框架，和Kotlin Flow理念一致，你可以把CoreData的查询转换成Publisher，订阅后自动接收数据库变更通知，同步更新UI。

步骤示例： #

1.1 给上下文扩展查询Publisher

先给NSManagedObjectContext加个扩展，方便生成带监听的查询Publisher：

import CoreData
import Combine

extension NSManagedObjectContext {
    func fetchPublisher<T: NSManagedObject>(for request: NSFetchRequest<T>) -> AnyPublisher<[T], Error> {
        return Future { [weak self] promise in
            guard let self = self else { return }
            do {
                // 首次查询
                let results = try self.fetch(request)
                promise(.success(results))
                
                // 监听上下文变更，触发重新查询
                let subscription = NotificationCenter.default.addObserver(
                    forName: NSNotification.Name.NSManagedObjectContextObjectsDidChange,
                    object: self,
                    queue: .main
                ) { [weak self] _ in
                    guard let self = self else { return }
                    do {
                        let updatedResults = try self.fetch(request)
                        promise(.success(updatedResults))
                    } catch {
                        promise(.failure(error))
                    }
                }
                // 可根据业务需求管理订阅生命周期，比如用Cancellable存储
            } catch {
                promise(.failure(error))
            }
        }
        .eraseToAnyPublisher()
    }
}

1.2 ViewModel中订阅并更新UI状态

以SwiftUI场景为例，用@Published属性绑定UI，对应Kotlin的mutableStateOf：

import SwiftUI
import Combine
import CoreData

class ProductAuditViewModel: ObservableObject {
    @Published var audits: [ProductAudit] = []
    private var cancellables = Set<AnyCancellable>()
    
    func loadAudits(headerId: Int64) {
        let fetchRequest: NSFetchRequest<ProductAudit> = ProductAudit.fetchRequest()
        // 添加查询条件，匹配你的headerId
        fetchRequest.predicate = NSPredicate(format: "headerId == %lld", headerId)
        
        // 获取CoreData上下文（假设你已通过PersistentContainer初始化好上下文）
        let context = PersistenceController.shared.container.viewContext
        
        context.fetchPublisher(for: fetchRequest)
            .receive(on: DispatchQueue.main) // 切换到主线程更新UI
            .sink(
                receiveCompletion: { completion in
                    if case .failure(let error) = completion {
                        print("查询失败: \(error)")
                    }
                },
                receiveValue: { [weak self] results in
                    self?.audits = results
                }
            )
            .store(in: &cancellables)
    }
}

1.3 SwiftUI中绑定ViewModel

struct AuditListView: View {
    @StateObject private var viewModel = ProductAuditViewModel()
    
    var body: some View {
        List(viewModel.audits) { audit in
            Text(audit.name ?? "Unnamed")
        }
        .onAppear {
            viewModel.loadAudits(headerId: 1)
        }
    }
}

当CoreData中的ProductAudit数据发生增删改时，Publisher会自动推送新的查询结果，@Published属性更新后，SwiftUI会自动刷新UI。

2. 使用传统的NSFetchedResultsController #

这是CoreData经典的监听数据变更方式，适合UIKit场景或需要精细控制变更的需求，它会监听数据的增删改操作，通过代理方法通知你针对性更新UI。

示例代码（UIKit场景）： #

import UIKit
import CoreData

class AuditListViewController: UITableViewController, NSFetchedResultsControllerDelegate {
    private var fetchedResultsController: NSFetchedResultsController<ProductAudit>!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupFetchedResultsController()
    }
    
    private func setupFetchedResultsController() {
        let fetchRequest: NSFetchRequest<ProductAudit> = ProductAudit.fetchRequest()
        fetchRequest.predicate = NSPredicate(format: "headerId == %lld", 1)
        // NSFetchedResultsController必须设置排序规则
        fetchRequest.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
        
        let context = PersistenceController.shared.container.viewContext
        fetchedResultsController = NSFetchedResultsController(
            fetchRequest: fetchRequest,
            managedObjectContext: context,
            sectionNameKeyPath: nil,
            cacheName: nil
        )
        fetchedResultsController.delegate = self
        
        do {
            try fetchedResultsController.performFetch()
            tableView.reloadData()
        } catch {
            print("查询失败: \(error)")
        }
    }
    
    // MARK: - NSFetchedResultsControllerDelegate
    func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
        tableView.beginUpdates()
    }
    
    func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange anObject: Any, at indexPath: IndexPath?, for type: NSFetchedResultsChangeType, newIndexPath: IndexPath?) {
        switch type {
        case .insert:
            if let newIndexPath = newIndexPath {
                tableView.insertRows(at: [newIndexPath], with: .automatic)
            }
        case .delete:
            if let indexPath = indexPath {
                tableView.deleteRows(at: [indexPath], with: .automatic)
            }
        case .update:
            if let indexPath = indexPath {
                let cell = tableView.cellForRow(at: indexPath) as! AuditCell
                let audit = fetchedResultsController.object(at: indexPath)
                cell.configure(with: audit)
            }
        case .move:
            if let indexPath = indexPath, let newIndexPath = newIndexPath {
                tableView.moveRow(at: indexPath, to: newIndexPath)
            }
        @unknown default:
            break
        }
    }
    
    func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
        tableView.endUpdates()
    }
    
    // MARK: - UITableViewDataSource
    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return fetchedResultsController.fetchedObjects?.count ?? 0
    }
    
    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "AuditCell", for: indexPath) as! AuditCell
        let audit = fetchedResultsController.object(at: indexPath)
        cell.configure(with: audit)
        return cell
    }
}

这种方式会自动监听CoreData的变更，通过代理方法告知具体的变更类型（增删改移），你可以针对性地更新UITableView，避免全量刷新。

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