在这篇笔记中，我将描述著名的经典 CRUD 模式的基本原理，以及 Swift 语言的实现。 Swift 是一种开放的跨平台语言，适用于 Windows、Linux、macOS、iOS、Android。
有许多解决方案可以抽象数据存储和应用程序逻辑。其中一种解决方案是 CRUD 方法，它是 C# 的缩写。创建，R-读取，U –更新，D–删除。
通常，此原则是通过实现数据库接口来实现的，其中使用唯一标识符（例如 id）来操作元素。为每个字母创建一个界面 CRUD –创建（对象，id），读取（id），更新（对象，id），删除（对象，id）。
如果一个对象在其内部包含一个 id，那么 id 参数可以从方法（Create、Update、Delete）中省略，因为整个对象及其字段 – 都被传递到那里。 ID。但对于– Read需要id，因为我们想通过id从数据库中获取一个对象。
所有名字均为虚构
让我们假设一个假设的 AssistantAI 应用程序是使用免费的 EtherRelm 数据库 SDK 创建的，集成很简单，API 非常方便，因此该应用程序被发布到市场。
突然，SDK 开发者 EtherRelm 决定付费，将价格定为每个应用程序用户每年 100 美元。
什么？是的！ AssistantAI的开发者现在应该做什么，因为他们已经有100万活跃用户了！支付一亿美元？
相反，会做出评估将应用程序转移到平台本机 RootData 数据库的决定；根据程序员的说法，这样的转移将需要大约六个月的时间，这还不考虑应用程序中新功能的实现。经过深思熟虑，决定从市场上删除该应用程序，并在另一个带有内置BueMS数据库的免费跨平台框架上重写它，这将解决付费数据库的问题+将简化在其他平台上的开发。
一年后，该应用程序在 BueMS 中被重写，但突然框架开发人员决定对其进行付费。事实证明，团队已经两次陷入同一个陷阱，第二次是否能摆脱困境就完全是另外一回事了。
抽象来救援
如果开发人员在应用程序中使用接口的抽象，这些问题本来可以避免。 OOP 的三大支柱多态、封装、继承，不久前他们还添加了另一个“多态”、“封装”、“继承”。抽象。
数据抽象允许您用最少的细节以一般术语描述想法和模型，同时足够准确以实现用于解决业务问题的特定实现。
如何抽象数据库操作，使得应用逻辑不依赖于它？我们使用 CRUD 方法！
简化的 UML CRUD 图如下所示：
虚构的 EtherRelm 数据库示例：
真实 SQLite 数据库的示例：
正如您已经注意到的，当您切换数据库时，只有与应用程序交互的 CRUD 接口发生变化。 CRUD 是 GoF 模式的实现适配器，因为使用它，我们可以使应用程序接口适应任何数据库并组合不兼容的接口。
文字都是空的，给我看看代码
为了用编程语言实现抽象，使用接口/协议/抽象类。所有这些都是同一个顺序的现象，但是，在面试中你可能会被要求说出它们之间的区别，我个人认为这没有多大意义，因为使用的唯一目的是实现数据抽象，否则就是测试受访者的记忆力。
CRUD通常是在Repository模式的框架内实现的，但是，存储库可能会也可能不会实现CRUD接口，这完全取决于开发人员的聪明才智。
考虑一下 Book 结构存储库的相当典型的 Swift 代码，直接使用 UserDefaults 数据库：
struct Book: Codable {
let title: String
let author: String
}
class BookRepository {
func save(book: Book) {
let record = try! JSONEncoder().encode(book)
UserDefaults.standard.set(record, forKey: book.title)
}
func get(bookWithTitle title: String) -> Book? {
guard let data = UserDefaults.standard.data(forKey: title) else { return nil }
let book = try! JSONDecoder().decode(Book.self, from: data)
return book
}
func delete(book: Book) {
UserDefaults.standard.removeObject(forKey: book.title)
}
}
let book = Book(title: "Fear and Loathing in COBOL", author: "Sir Edsger ZX Spectrum")
let repository = BookRepository()
repository.save(book: book)
print(repository.get(bookWithTitle: book.title)!)
repository.delete(book: book)
guard repository.get(bookWithTitle: book.title) == nil else {
print("Error: can't delete Book from repository!")
exit(1)
}
上面的代码看似简单，但我们来统计一下违反 DRY（Do not Repeat Yourself）原则的次数以及代码的连贯性：
与 UserDefaults 数据库的连接
与 JSON 编码器和解码器的连接 – JSONEncoder、JSONDecoder
与 Book 结构连接，但我们需要一个抽象存储库，以免为我们将存储在数据库中的每个结构创建一个存储库类（DRY 违规）
我经常看到这种CRUD存储库代码，它可以使用，但是高耦合和重复的代码导致随着时间的推移它的支持会变得非常复杂。当尝试切换到另一个数据库时，或者当更改在应用程序中创建的所有存储库中使用数据库的内部逻辑时，这一点尤其明显。
不要重复代码，而是保持高耦合度——让我们为CRUD存储库编写一个协议，从而抽象数据库接口和应用程序业务逻辑，尊重DRY，实现低耦合：
typealias Item = Codable
typealias ItemIdentifier = String
func create<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier, item: T) async throws
func read<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier) async throws -> T
func update<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier, item: T) async throws
func delete(id: CRUDRepository.ItemIdentifier) async throws
}
CRUDRepository 协议描述了用于进一步实现特定 CRUD 存储库的接口和关联数据类型。
接下来我们将为UserDefaults数据库编写一个具体的实现：
private typealias RecordIdentifier = String
let tableName: String
let dataTransformer: DataTransformer
init(
tableName: String = "",
dataTransformer: DataTransformer = JSONDataTransformer()
) {
self.tableName = tableName
self.dataTransformer = dataTransformer
}
private func key(id: CRUDRepository.ItemIdentifier) -> RecordIdentifier {
"database_\(tableName)_item_\(id)"
}
private func isExists(id: CRUDRepository.ItemIdentifier) async throws -> Bool {
UserDefaults.standard.data(forKey: key(id: id)) != nil
}
func create<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier, item: T) async throws {
let data = try await dataTransformer.encode(item)
UserDefaults.standard.set(data, forKey: key(id: id))
UserDefaults.standard.synchronize()
}
func read<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier) async throws -> T {
guard let data = UserDefaults.standard.data(forKey: key(id: id)) else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
let item: T = try await dataTransformer.decode(data: data)
return item
}
func update<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier, item: T) async throws {
guard try await isExists(id: id) else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
let data = try await dataTransformer.encode(item)
UserDefaults.standard.set(data, forKey: key(id: id))
UserDefaults.standard.synchronize()
}
func delete(id: CRUDRepository.ItemIdentifier) async throws {
guard try await isExists(id: id) else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
UserDefaults.standard.removeObject(forKey: key(id: id))
UserDefaults.standard.synchronize()
}
}
代码看起来很长，但包含了包含松散耦合的 CRUD 存储库的完整具体实现，详细信息如下。
添加了类型别名以用于代码的自文档化。
弱耦合和强耦合
与特定结构 (struct) 的分离是使用通用 T 实现的，而通用 T 又必须实现可编码协议。 Codable 允许您使用实现 TopLevelEncoder 和 TopLevelDecoder 协议的类（例如 JSONEncoder 和 JSONDecoder）来转换结构，当使用基本类型（Int、String、Float 等）时，无需编写额外的代码来转换结构。
使用 DataTransformer 协议中的抽象来实现与特定编码器和解码器的解耦：
func encode<T: Encodable>(_ object: T) async throws -> Data
func decode<T: Decodable>(data: Data) async throws -> T
}
使用数据转换器的实现，我们实现了编码器和解码器接口的抽象，实现松散耦合以确保处理不同类型的数据格式。
以下是特定DataTransformer的代码，即JSON：
func encode<T>(_ object: T) async throws -> Data where T : Encodable {
let data = try JSONEncoder().encode(object)
return data
}
func decode<T>(data: Data) async throws -> T where T : Decodable {
let item: T = try JSONDecoder().decode(T.self, from: data)
return item
}
}
这可能吗？
发生了什么变化？现在，初始化一个特定的存储库就足以与任何实现 Codable 协议的结构一起使用，从而消除了重复代码和实现应用程序松散耦合的需要。
具有特定存储库的客户端 CRUD 示例，UserDefaults 是数据库、JSON 数据格式、客户端结构，也是写入和读取数组的示例：
print("One item access example")
do {
let clientRecordIdentifier = "client"
let clientOne = Client(name: "Chill Client")
let repository = UserDefaultsRepository(
tableName: "Clients Database",
dataTransformer: JSONDataTransformer()
)
try await repository.create(id: clientRecordIdentifier, item: clientOne)
var clientRecord: Client = try await repository.read(id: clientRecordIdentifier)
print("Client Name: \(clientRecord.name)")
clientRecord.name = "Busy Client"
try await repository.update(id: clientRecordIdentifier, item: clientRecord)
let updatedClient: Client = try await repository.read(id: clientRecordIdentifier)
print("Updated Client Name: \(updatedClient.name)")
try await repository.delete(id: clientRecordIdentifier)
let removedClientRecord: Client = try await repository.read(id: clientRecordIdentifier)
print(removedClientRecord)
}
catch {
print(error.localizedDescription)
}
print("Array access example")
let clientArrayRecordIdentifier = "clientArray"
let clientOne = Client(name: "Chill Client")
let repository = UserDefaultsRepository(
tableName: "Clients Database",
dataTransformer: JSONDataTransformer()
)
let array = [clientOne]
try await repository.create(id: clientArrayRecordIdentifier, item: array)
let savedArray: [Client] = try await repository.read(id: clientArrayRecordIdentifier)
print(savedArray.first!)
在第一次 CRUD 检查期间，已实现异常处理，其中远程项目的读取将不再可用。
切换数据库
现在我将向您展示如何将当前代码传输到另一个数据库。例如，我将采用 ChatGPT 生成的 SQLite 存储库代码：
class SQLiteRepository: CRUDRepository {
private typealias RecordIdentifier = String
let tableName: String
let dataTransformer: DataTransformer
private var db: OpaquePointer?
init(
tableName: String,
dataTransformer: DataTransformer = JSONDataTransformer()
) {
self.tableName = tableName
self.dataTransformer = dataTransformer
self.db = openDatabase()
createTableIfNeeded()
}
private func openDatabase() -> OpaquePointer? {
var db: OpaquePointer? = nil
let fileURL = try! FileManager.default
.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
.appendingPathComponent("\(tableName).sqlite")
if sqlite3_open(fileURL.path, &db) != SQLITE_OK {
print("error opening database")
return nil
}
return db
}
private func createTableIfNeeded() {
let createTableString = """
CREATE TABLE IF NOT EXISTS \(tableName) (
id TEXT PRIMARY KEY NOT NULL,
data BLOB NOT NULL
);
"""
var createTableStatement: OpaquePointer? = nil
if sqlite3_prepare_v2(db, createTableString, -1, &createTableStatement, nil) == SQLITE_OK {
if sqlite3_step(createTableStatement) == SQLITE_DONE {
print("\(tableName) table created.")
} else {
print("\(tableName) table could not be created.")
}
} else {
print("CREATE TABLE statement could not be prepared.")
}
sqlite3_finalize(createTableStatement)
}
private func isExists(id: CRUDRepository.ItemIdentifier) async throws -> Bool {
let queryStatementString = "SELECT data FROM \(tableName) WHERE id = ?;"
var queryStatement: OpaquePointer? = nil
if sqlite3_prepare_v2(db, queryStatementString, -1, &queryStatement, nil) == SQLITE_OK {
sqlite3_bind_text(queryStatement, 1, id, -1, nil)
if sqlite3_step(queryStatement) == SQLITE_ROW {
sqlite3_finalize(queryStatement)
return true
} else {
sqlite3_finalize(queryStatement)
return false
}
} else {
print("SELECT statement could not be prepared.")
throw CRUDRepositoryError.databaseError
}
}
func create<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier, item: T) async throws {
let insertStatementString = "INSERT INTO \(tableName) (id, data) VALUES (?, ?);"
var insertStatement: OpaquePointer? = nil
if sqlite3_prepare_v2(db, insertStatementString, -1, &insertStatement, nil) == SQLITE_OK {
let data = try await dataTransformer.encode(item)
sqlite3_bind_text(insertStatement, 1, id, -1, nil)
sqlite3_bind_blob(insertStatement, 2, (data as NSData).bytes, Int32(data.count), nil)
if sqlite3_step(insertStatement) == SQLITE_DONE {
print("Successfully inserted row.")
} else {
print("Could not insert row.")
throw CRUDRepositoryError.databaseError
}
} else {
print("INSERT statement could not be prepared.")
throw CRUDRepositoryError.databaseError
}
sqlite3_finalize(insertStatement)
}
func read<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier) async throws -> T {
let queryStatementString = "SELECT data FROM \(tableName) WHERE id = ?;"
var queryStatement: OpaquePointer? = nil
var item: T?
if sqlite3_prepare_v2(db, queryStatementString, -1, &queryStatement, nil) == SQLITE_OK {
sqlite3_bind_text(queryStatement, 1, id, -1, nil)
if sqlite3_step(queryStatement) == SQLITE_ROW {
let queryResultCol1 = sqlite3_column_blob(queryStatement, 0)
let queryResultCol1Length = sqlite3_column_bytes(queryStatement, 0)
let data = Data(bytes: queryResultCol1, count: Int(queryResultCol1Length))
item = try await dataTransformer.decode(data: data)
} else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
} else {
print("SELECT statement could not be prepared")
throw CRUDRepositoryError.databaseError
}
sqlite3_finalize(queryStatement)
return item!
}
func update<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier, item: T) async throws {
guard try await isExists(id: id) else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
let updateStatementString = "UPDATE \(tableName) SET data = ? WHERE id = ?;"
var updateStatement: OpaquePointer? = nil
if sqlite3_prepare_v2(db, updateStatementString, -1, &updateStatement, nil) == SQLITE_OK {
let data = try await dataTransformer.encode(item)
sqlite3_bind_blob(updateStatement, 1, (data as NSData).bytes, Int32(data.count), nil)
sqlite3_bind_text(updateStatement, 2, id, -1, nil)
if sqlite3_step(updateStatement) == SQLITE_DONE {
print("Successfully updated row.")
} else {
print("Could not update row.")
throw CRUDRepositoryError.databaseError
}
} else {
print("UPDATE statement could not be prepared.")
throw CRUDRepositoryError.databaseError
}
sqlite3_finalize(updateStatement)
}
func delete(id: CRUDRepository.ItemIdentifier) async throws {
guard try await isExists(id: id) else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
let deleteStatementString = "DELETE FROM \(tableName) WHERE id = ?;"
var deleteStatement: OpaquePointer? = nil
if sqlite3_prepare_v2(db, deleteStatementString, -1, &deleteStatement, nil) == SQLITE_OK {
sqlite3_bind_text(deleteStatement, 1, id, -1, nil)
if sqlite3_step(deleteStatement) == SQLITE_DONE {
print("Successfully deleted row.")
} else {
print("Could not delete row.")
throw CRUDRepositoryError.databaseError
}
} else {
print("DELETE statement could not be prepared.")
throw CRUDRepositoryError.databaseError
}
sqlite3_finalize(deleteStatement)
}
}
或者文件系统存储库的 CRUD 代码，它也是由 ChatGPT 生成的：
class FileSystemRepository: CRUDRepository {
private typealias RecordIdentifier = String
let directoryName: String
let dataTransformer: DataTransformer
private let fileManager = FileManager.default
private var directoryURL: URL
init(
directoryName: String = "Database",
dataTransformer: DataTransformer = JSONDataTransformer()
) {
self.directoryName = directoryName
self.dataTransformer = dataTransformer
let paths = fileManager.urls(for: .documentDirectory, in: .userDomainMask)
directoryURL = paths.first!.appendingPathComponent(directoryName)
if !fileManager.fileExists(atPath: directoryURL.path) {
try? fileManager.createDirectory(at: directoryURL, withIntermediateDirectories: true, attributes: nil)
}
}
private func fileURL(id: CRUDRepository.ItemIdentifier) -> URL {
return directoryURL.appendingPathComponent("item_\(id).json")
}
private func isExists(id: CRUDRepository.ItemIdentifier) async throws -> Bool {
return fileManager.fileExists(atPath: fileURL(id: id).path)
}
func create<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier, item: T) async throws {
let data = try await dataTransformer.encode(item)
let url = fileURL(id: id)
try data.write(to: url)
}
func read<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier) async throws -> T {
let url = fileURL(id: id)
guard let data = fileManager.contents(atPath: url.path) else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
let item: T = try await dataTransformer.decode(data: data)
return item
}
func update<T: CRUDRepository.Item>(id: CRUDRepository.ItemIdentifier, item: T) async throws {
guard try await isExists(id: id) else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
let data = try await dataTransformer.encode(item)
let url = fileURL(id: id)
try data.write(to: url)
}
func delete(id: CRUDRepository.ItemIdentifier) async throws {
guard try await isExists(id: id) else {
throw CRUDRepositoryError.recordNotFound(id: id)
}
let url = fileURL(id: id)
try fileManager.removeItem(at: url)
}
}
替换客户端代码中的存储库：
print("One item access example")
do {
let clientRecordIdentifier = "client"
let clientOne = Client(name: "Chill Client")
let repository = FileSystemRepository(
directoryName: "Clients Database",
dataTransformer: JSONDataTransformer()
)
try await repository.create(id: clientRecordIdentifier, item: clientOne)
var clientRecord: Client = try await repository.read(id: clientRecordIdentifier)
print("Client Name: \(clientRecord.name)")
clientRecord.name = "Busy Client"
try await repository.update(id: clientRecordIdentifier, item: clientRecord)
let updatedClient: Client = try await repository.read(id: clientRecordIdentifier)
print("Updated Client Name: \(updatedClient.name)")
try await repository.delete(id: clientRecordIdentifier)
let removedClientRecord: Client = try await repository.read(id: clientRecordIdentifier)
print(removedClientRecord)
}
catch {
print(error.localizedDescription)
}
print("Array access example")
let clientArrayRecordIdentifier = "clientArray"
let clientOne = Client(name: "Chill Client")
let repository = FileSystemRepository(
directoryName: "Clients Database",
dataTransformer: JSONDataTransformer()
)
let array = [clientOne]
try await repository.create(id: clientArrayRecordIdentifier, item: array)
let savedArray: [Client] = try await repository.read(id: clientArrayRecordIdentifier)
print(savedArray.first!)
UserDefaultsRepository 的初始化已替换为 FileSystemRepository，并带有适当的参数。
运行第二版客户端代码后，您将在文档文件夹中找到“Clients Database”目录，其中包含一个以 JSON 序列化的数组文件，具有一个客户端结构。
切换数据存储格式
现在让 ChatGPT 生成 XML 的编码器和解码器：
let formatExtension = "xml"
func encode<T: Encodable>(_ item: T) async throws -> Data {
let encoder = PropertyListEncoder()
encoder.outputFormat = .xml
return try encoder.encode(item)
}
func decode<T: Decodable>(data: Data) async throws -> T {
let decoder = PropertyListDecoder()
return try decoder.decode(T.self, from: data)
}
}
得益于 Swift 中的内置类型，神经网络的任务变得非常简单。
在客户端代码中将 JSON 替换为 XML：
print("One item access example")
do {
let clientRecordIdentifier = "client"
let clientOne = Client(name: "Chill Client")
let repository = FileSystemRepository(
directoryName: "Clients Database",
dataTransformer: XMLDataTransformer()
)
try await repository.create(id: clientRecordIdentifier, item: clientOne)
var clientRecord: Client = try await repository.read(id: clientRecordIdentifier)
print("Client Name: \(clientRecord.name)")
clientRecord.name = "Busy Client"
try await repository.update(id: clientRecordIdentifier, item: clientRecord)
let updatedClient: Client = try await repository.read(id: clientRecordIdentifier)
print("Updated Client Name: \(updatedClient.name)")
try await repository.delete(id: clientRecordIdentifier)
let removedClientRecord: Client = try await repository.read(id: clientRecordIdentifier)
print(removedClientRecord)
}
catch {
print(error.localizedDescription)
}
print("Array access example")
let clientArrayRecordIdentifier = "clientArray"
let clientOne = Client(name: "Chill Client")
let repository = FileSystemRepository(
directoryName: "Clients Database",
dataTransformer: XMLDataTransformer()
)
let array = [clientOne]
try await repository.create(id: clientArrayRecordIdentifier, item: array)
let savedArray: [Client] = try await repository.read(id: clientArrayRecordIdentifier)
print(savedArray.first!)
客户端代码已更改为只有一个表达式 JSONDataTransformer -> XML数据转换器
总计
CRUD 存储库是可用于实现应用程序架构组件松散耦合的设计模式之一。另一种解决方案是“使用ORM（对象关系映射），简单来说，ORM使用一种将结构完全映射到数据库的方法，然后将模型的更改显示在数据库上（映射（！））。
但这是一个完全不同的故事。
Swift 的 CRUD 存储库的完整实现位于：
https://gitlab.com/demensdeum/crud-example
顺便说一句，Swift 长期以来一直在 macOS 之外得到支持；本文中的代码完全是在 Arch Linux 上编写和测试的。
来源
https://developer.apple.com/documentation/combine/topleveldecoder
https://developer.apple.com/documentation/combine/toplevelencoder
https://en.wikipedia.org/wiki/Create,_read,_update_and_delete