Swift Composable Architecture数据库集成：CoreData和Realm支持-优快云博客

Swift Composable Architecture数据库集成：CoreData和Realm支持

【免费下载链接】swift-composable-architecture pointfreeco/swift-composable-architecture: Swift Composable Architecture (SCA) 是一个基于Swift编写的函数式编程架构框架，旨在简化iOS、macOS、watchOS和tvOS应用中的业务逻辑管理和UI状态管理。项目地址: https://gitcode.com/GitHub_Trending/sw/swift-composable-architecture

痛点：移动应用数据持久化的挑战

在iOS/macOS应用开发中，数据持久化是每个开发者必须面对的核心问题。你是否曾经遇到过：

状态管理混乱，业务逻辑与数据存储耦合严重
数据库操作代码分散在各个ViewController中
难以进行单元测试和集成测试
数据同步和状态一致性维护困难

Swift Composable Architecture（TCA）通过其强大的状态管理和副作用处理能力，为数据库集成提供了优雅的解决方案。本文将深入探讨如何在TCA中集成CoreData和Realm，构建可测试、可维护的数据持久化层。

TCA数据持久化架构设计

核心架构模式

mermaid

依赖管理的关键作用

TCA的依赖管理系统是数据库集成的核心，它允许我们：

环境隔离：测试环境使用内存数据库，生产环境使用真实数据库
接口统一：为不同数据库提供统一的客户端接口
可替换性：轻松切换数据库实现而不影响业务逻辑

CoreData集成实战

CoreData客户端设计

import CoreData
import ComposableArchitecture

struct CoreDataClient {
    var fetchEntities: (NSFetchRequest<Entity>) throws -> [Entity]
    var saveEntity: (Entity) throws -> Void
    var deleteEntity: (Entity) throws -> Void
    var performBackgroundTask: (@escaping (NSManagedObjectContext) -> Void) -> Void
}

extension CoreDataClient: DependencyKey {
    static let liveValue: Self {
        let container = NSPersistentContainer(name: "AppModel")
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("CoreData加载失败: \(error)")
            }
        }
        
        return Self(
            fetchEntities: { request in
                try container.viewContext.fetch(request)
            },
            saveEntity: { entity in
                if container.viewContext.hasChanges {
                    try container.viewContext.save()
                }
            },
            deleteEntity: { entity in
                container.viewContext.delete(entity)
                try container.viewContext.save()
            },
            performBackgroundTask: { block in
                container.performBackgroundTask(block)
            }
        )
    }
    
    static let testValue: Self {
        let container = NSPersistentContainer.inMemory(name: "TestModel")
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("测试CoreData加载失败: \(error)")
            }
        }
        
        return Self(
            fetchEntities: { request in
                try container.viewContext.fetch(request)
            },
            saveEntity: { entity in
                if container.viewContext.hasChanges {
                    try container.viewContext.save()
                }
            },
            deleteEntity: { entity in
                container.viewContext.delete(entity)
                try container.viewContext.save()
            },
            performBackgroundTask: { block in
                container.performBackgroundTask(block)
            }
        )
    }
}

extension DependencyValues {
    var coreData: CoreDataClient {
        get { self[CoreDataClient.self] }
        set { self[CoreDataClient.self] = newValue }
    }
}

TCA Reducer集成示例

@Reducer
struct TodoFeature {
    @ObservableState
    struct State: Equatable {
        var todos: IdentifiedArrayOf<Todo> = []
        var isLoading = false
        var error: String?
    }
    
    enum Action {
        case loadTodos
        case todosLoaded(Result<[Todo], Error>)
        case addTodo(Todo)
        case deleteTodo(Identified<Todo.ID, Todo>)
        case todoAdded(Result<Todo, Error>)
        case todoDeleted(Result<Void, Error>)
    }
    
    @Dependency(\.coreData) var coreData
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .loadTodos:
                state.isLoading = true
                return .run { send in
                    let request = NSFetchRequest<TodoEntity>(entityName: "TodoEntity")
                    request.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
                    
                    do {
                        let entities = try coreData.fetchEntities(request)
                        let todos = entities.map { Todo(from: $0) }
                        await send(.todosLoaded(.success(todos)))
                    } catch {
                        await send(.todosLoaded(.failure(error)))
                    }
                }
                
            case .todosLoaded(.success(let todos)):
                state.isLoading = false
                state.todos = IdentifiedArray(uniqueElements: todos)
                return .none
                
            case .todosLoaded(.failure(let error)):
                state.isLoading = false
                state.error = error.localizedDescription
                return .none
                
            case .addTodo(let todo):
                return .run { send in
                    let entity = TodoEntity(context: coreData.viewContext)
                    entity.id = todo.id
                    entity.title = todo.title
                    entity.isCompleted = todo.isCompleted
                    entity.createdAt = todo.createdAt
                    
                    do {
                        try coreData.saveEntity(entity)
                        await send(.todoAdded(.success(todo)))
                    } catch {
                        await send(.todoAdded(.failure(error)))
                    }
                }
                
            case .deleteTodo(let todo):
                return .run { send in
                    let request = NSFetchRequest<TodoEntity>(entityName: "TodoEntity")
                    request.predicate = NSPredicate(format: "id == %@", todo.id as CVarArg)
                    
                    do {
                        let entities = try coreData.fetchEntities(request)
                        if let entity = entities.first {
                            try coreData.deleteEntity(entity)
                            await send(.todoDeleted(.success(())))
                        }
                    } catch {
                        await send(.todoDeleted(.failure(error)))
                    }
                }
                
            case .todoAdded, .todoDeleted:
                return .none
            }
        }
    }
}

Realm集成方案

Realm客户端实现

import RealmSwift
import ComposableArchitecture

struct RealmClient {
    var fetchObjects: <T: Object>(_ type: T.Type) throws -> Results<T>
    var addObject: <T: Object>(_ object: T, update: Realm.UpdatePolicy) throws -> Void
    var deleteObject: <T: Object>(_ object: T) throws -> Void
    var write: (_ block: (Realm) throws -> Void) throws -> Void
}

extension RealmClient: DependencyKey {
    static let liveValue: Self {
        do {
            let realm = try Realm()
            return Self(
                fetchObjects: { type in
                    try realm.objects(type)
                },
                addObject: { object, update in
                    try realm.write {
                        realm.add(object, update: update)
                    }
                },
                deleteObject: { object in
                    try realm.write {
                        realm.delete(object)
                    }
                },
                write: { block in
                    try realm.write {
                        try block(realm)
                    }
                }
            )
        } catch {
            fatalError("Realm初始化失败: \(error)")
        }
    }
    
    static let testValue: Self {
        var configuration = Realm.Configuration()
        configuration.inMemoryIdentifier = "TestRealm"
        
        do {
            let realm = try Realm(configuration: configuration)
            return Self(
                fetchObjects: { type in
                    try realm.objects(type)
                },
                addObject: { object, update in
                    try realm.write {
                        realm.add(object, update: update)
                    }
                },
                deleteObject: { object in
                    try realm.write {
                        realm.delete(object)
                    }
                },
                write: { block in
                    try realm.write {
                        try block(realm)
                    }
                }
            )
        } catch {
            fatalError("测试Realm初始化失败: \(error)")
        }
    }
}

extension DependencyValues {
    var realm: RealmClient {
        get { self[RealmClient.self] }
        set { self[RealmClient.self] = newValue }
    }
}

Realm与TCA的完美结合

@Reducer
struct TaskFeature {
    @ObservableState
    struct State: Equatable {
        var tasks: IdentifiedArrayOf<Task> = []
        var filter: TaskFilter = .all
    }
    
    enum Action {
        case loadTasks
        case tasksLoaded(Results<TaskObject>)
        case addTask(String)
        case toggleTask(Task.ID)
        case setFilter(TaskFilter)
    }
    
    @Dependency(\.realm) var realm
    @Dependency(\.mainQueue) var mainQueue
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .loadTasks:
                return .run { send in
                    let tasks = try realm.fetchObjects(TaskObject.self)
                    await send(.tasksLoaded(tasks))
                }
                
            case .tasksLoaded(let results):
                state.tasks = IdentifiedArray(
                    uniqueElements: results.map { Task(from: $0) }
                )
                return .none
                
            case .addTask(let title):
                return .run { send in
                    let task = TaskObject()
                    task.id = UUID().uuidString
                    task.title = title
                    task.isCompleted = false
                    task.createdAt = Date()
                    
                    try realm.addObject(task, update: .modified)
                    // 重新加载任务列表
                    await send(.loadTasks)
                }
                
            case .toggleTask(let id):
                return .run { send in
                    if let task = try realm.fetchObjects(TaskObject.self)
                        .filter("id == %@", id).first {
                        try realm.write { realm in
                            task.isCompleted.toggle()
                        }
                        await send(.loadTasks)
                    }
                }
                
            case .setFilter(let filter):
                state.filter = filter
                return .none
            }
        }
    }
}

性能优化与最佳实践

数据库操作性能对比

操作类型	CoreData性能	Realm性能	推荐场景
批量插入	⭐⭐⭐	⭐⭐⭐⭐⭐	大量数据导入
单条查询	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	实时搜索
复杂关联查询	⭐⭐⭐⭐⭐	⭐⭐⭐	复杂业务逻辑
内存使用	⭐⭐⭐	⭐⭐⭐⭐⭐	移动设备优化
线程安全	⭐⭐	⭐⭐⭐⭐⭐	多线程操作

内存管理策略

// 使用@Shared管理数据库连接
extension SharedKey where Self == AppStorageKey<Data> {
    static var databaseConfig: Self {
        appStorage("database_config")
    }
}

// 数据库连接池管理
class DatabaseConnectionPool {
    private var connections: [String: Any] = [:]
    private let lock = NSLock()
    
    func connection<T>(for key: String, create: () throws -> T) rethrows -> T {
        lock.lock()
        defer { lock.unlock() }
        
        if let connection = connections[key] as? T {
            return connection
        }
        
        let newConnection = try create()
        connections[key] = newConnection
        return newConnection
    }
}

测试策略与实现

单元测试示例

import XCTest
@testable import YourApp

final class DatabaseTests: XCTestCase {
    func testTodoCRUDOperations() async {
        let store = TestStore(initialState: TodoFeature.State()) {
            TodoFeature()
        } withDependencies: {
            $0.coreData = .testValue
        }
        
        // 测试添加待办事项
        let newTodo = Todo(id: UUID(), title: "测试待办", isCompleted: false)
        await store.send(.addTodo(newTodo)) {
            $0.isLoading = true
        }
        
        await store.receive(.todoAdded(.success(newTodo))) {
            $0.isLoading = false
        }
        
        // 测试加载待办事项
        await store.send(.loadTodos) {
            $0.isLoading = true
        }
        
        await store.receive(.todosLoaded(.success([newTodo]))) {
            $0.isLoading = false
            $0.todos = [newTodo]
        }
    }
}

集成测试策略

mermaid

实战：构建完整的待办应用

数据模型设计

// CoreData实体
class TodoEntity: NSManagedObject {
    @NSManaged var id: UUID
    @NSManaged var title: String
    @NSManaged var isCompleted: Bool
    @NSManaged var createdAt: Date
    @NSManaged var category: String?
}

// Realm对象
class TaskObject: Object {
    @Persisted(primaryKey: true) var id: String
    @Persisted var title: String
    @Persisted var isCompleted: Bool
    @Persisted var createdAt: Date
    @Persisted var priority: Int
}

// 领域模型
struct Todo: Equatable, Identifiable {
    let id: UUID
    var title: String
    var isCompleted: Bool
    let createdAt: Date
    var category: String?
}

完整的Feature实现

@Reducer
struct AppFeature {
    @ObservableState
    struct State: Equatable {
        var todos = TodoList.State()
        var statistics = Statistics.State()
        var selectedTab: Tab = .list
    }
    
    enum Action {
        case todos(TodoList.Action)
        case statistics(Statistics.Action)
        case selectTab(Tab)
        case loadInitialData
    }
    
    enum Tab: String, CaseIterable {
        case list, stats
    }
    
    var body: some Reducer<State, Action> {
        Scope(state: \.todos, action: \.todos) {
            TodoList()
        }
        
        Scope(state: \.statistics, action: \.statistics) {
            Statistics()
        }
        
        Reduce { state, action in
            switch action {
            case .selectTab(let tab):
                state.selectedTab = tab
                return .none
                
            case .loadInitialData:
                return .merge(
                    .send(.todos(.loadTodos)),
                    .send(.statistics(.loadStats))
                )
                
            case .todos, .statistics:
                return .none
            }
        }
    }
}

总结与展望

通过本文的深入探讨，我们了解了如何在Swift Composable Architecture中优雅地集成CoreData和Realm数据库。关键收获包括：

架构清晰：TCA的Reducer模式使数据库操作逻辑集中且可测试
依赖注入：通过DependencyKey实现数据库客户端的灵活替换
性能优化：利用@Shared和适当的线程策略优化数据库性能
测试完备：完整的单元测试和集成测试保障代码质量

未来，随着Swift 6和Swift Concurrency的进一步发展，TCA与数据库的集成将更加简洁高效。建议开发者：

根据项目需求选择合适的数据库方案
充分利用TCA的测试能力保障数据一致性
关注SwiftData等新技术与TCA的整合可能性

通过合理的架构设计和持续的最佳实践，你可以在TCA中构建出既强大又灵活的数据持久化解决方案。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考