MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

iOS开发：为SQLite数据库数据创建类

2024-06-224.1k 阅读

数据库 SQLite 在 iOS 开发中为数据创建类的重要性

在 iOS 开发中，SQLite 作为轻量级的嵌入式数据库，被广泛应用于需要本地数据持久化的场景。而创建与 SQLite 数据库数据对应的类，有着诸多重要意义。

首先，从代码结构角度看，为 SQLite 数据库数据创建类能够使代码结构更加清晰。假设我们开发一个简单的笔记应用，数据库中可能有“笔记”表，包含标题、内容、创建时间等字段。如果不创建类，在操作数据时，可能直接在各个视图控制器或业务逻辑模块中使用 SQL 语句，这样代码就会显得杂乱无章。而创建了对应的“笔记”类，所有与笔记数据相关的属性和操作都可以封装在这个类中，代码结构变得层次分明，易于维护和扩展。

其次，从数据一致性和安全性方面考虑，类提供了一种数据封装机制。通过设置类的属性访问控制权限，可以有效防止数据被随意修改，保证数据的一致性。比如，我们可以将某些敏感字段设置为只读属性，只有在特定的方法中才能修改，避免了数据在不恰当的地方被错误修改，提高了数据的安全性。

再者，从代码复用性上，创建类使得代码复用成为可能。当我们在不同的功能模块中需要操作相同类型的数据时，直接使用已创建的类即可，无需重复编写操作数据的代码。例如，在笔记应用的查看笔记、编辑笔记和分享笔记等功能模块中，都可以复用“笔记”类的相关代码。

创建 SQLite 数据库数据类的基本步骤

分析数据库结构

在创建类之前，我们需要对 SQLite 数据库的结构进行深入分析。以一个简单的学生信息管理应用为例，数据库可能包含“学生”表，表结构如下：

字段名数据类型说明
idINTEGER学生唯一标识，自增长主键
nameTEXT学生姓名
ageINTEGER学生年龄
gradeTEXT学生所在年级

通过对这个表结构的分析，我们可以明确需要在类中定义哪些属性来对应数据库中的字段。

定义类的属性

基于对数据库结构的分析，我们开始定义类的属性。在 Swift 语言中，定义“学生”类的属性代码如下：

class Student {
    var id: Int?
    var name: String?
    var age: Int?
    var grade: String?
}

在上述代码中，我们定义了与数据库“学生”表字段对应的属性。需要注意的是，属性的类型要与数据库字段的数据类型相对应，这里id和age为Int类型，对应数据库中的INTEGER类型，name和grade为String类型，对应数据库中的TEXT类型。同时，由于属性在初始化时可能没有值，所以我们将它们定义为可选类型。

实现数据的存取方法

  1. 数据存储方法 为了将类的实例数据存储到 SQLite 数据库中，我们需要实现数据存储方法。在 Swift 中，可以使用 SQLite.swift 库来简化 SQLite 操作。以下是实现“学生”类数据存储的代码示例：
import SQLite

let students = Table("students")
let id = Expression<Int?>("id")
let name = Expression<String>("name")
let age = Expression<Int>("age")
let grade = Expression<String>("grade")

extension Student {
    func saveToDatabase() throws {
        let db = try Connection("student.db")
        if let studentId = id {
            try db.run(students.filter(self.id == studentId).update(
                name <- self.name!,
                age <- self.age!,
                grade <- self.grade!
            ))
        } else {
            let insert = students.insert(
                name <- self.name!,
                age <- self.age!,
                grade <- self.grade!
            )
            let insertedId = try db.run(insert)
            self.id = Int(insertedId)
        }
    }
}

在上述代码中，saveToDatabase方法首先连接到 SQLite 数据库。如果id属性有值，说明该学生记录已存在于数据库中，使用update方法更新记录；如果id属性为nil，则使用insert方法插入新记录，并将插入后的自增长id值赋给self.id。

  1. 数据读取方法 接下来实现从数据库中读取数据并转换为类实例的方法：
extension Student {
    static func loadFromDatabase(id: Int) throws -> Student? {
        let db = try Connection("student.db")
        let student = try db.prepare(students.filter(self.id == id)).first
        if let student = student {
            let newStudent = Student()
            newStudent.id = student[id]
            newStudent.name = student[name]
            newStudent.age = student[age]
            newStudent.grade = student[grade]
            return newStudent
        }
        return nil
    }
}

在loadFromDatabase方法中，根据传入的id从数据库中查询记录。如果查询到记录，则创建一个新的Student实例，并将数据库中的字段值赋给实例的属性，最后返回该实例；如果未查询到记录，则返回nil。

处理复杂数据关系

一对一关系

在实际应用中，数据库中常常存在复杂的数据关系。以一个用户信息与用户详情信息的一对一关系为例，假设数据库中有“用户”表和“用户详情”表，“用户”表结构如下：

字段名数据类型说明
idINTEGER用户唯一标识，自增长主键
usernameTEXT用户名

“用户详情”表结构如下：

字段名数据类型说明
idINTEGER用户详情唯一标识，自增长主键
user_idINTEGER关联的用户 id，外键
addressTEXT用户地址
phoneTEXT用户电话

在 Swift 中，我们可以定义两个类来对应这两个表，代码如下：

class User {
    var id: Int?
    var username: String?
    var detail: UserDetail?

    func saveToDatabase() throws {
        let db = try Connection("user.db")
        if let userId = id {
            try db.run(users.filter(self.id == userId).update(
                username <- self.username!
            ))
        } else {
            let insert = users.insert(
                username <- self.username!
            )
            let insertedId = try db.run(insert)
            self.id = Int(insertedId)
        }
        if let userDetail = detail {
            userDetail.user_id = self.id
            try userDetail.saveToDatabase()
        }
    }

    static func loadFromDatabase(id: Int) throws -> User? {
        let db = try Connection("user.db")
        let user = try db.prepare(users.filter(self.id == id)).first
        if let user = user {
            let newUser = User()
            newUser.id = user[User.id]
            newUser.username = user[User.username]
            if let detail = try UserDetail.loadFromDatabase(user_id: newUser.id!) {
                newUser.detail = detail
            }
            return newUser
        }
        return nil
    }
}

class UserDetail {
    var id: Int?
    var user_id: Int?
    var address: String?
    var phone: String?

    func saveToDatabase() throws {
        let db = try Connection("user.db")
        if let detailId = id {
            try db.run(userDetails.filter(self.id == detailId).update(
                user_id <- self.user_id!,
                address <- self.address!,
                phone <- self.phone!
            ))
        } else {
            let insert = userDetails.insert(
                user_id <- self.user_id!,
                address <- self.address!,
                phone <- self.phone!
            )
            let insertedId = try db.run(insert)
            self.id = Int(insertedId)
        }
    }

    static func loadFromDatabase(user_id: Int) throws -> UserDetail? {
        let db = try Connection("user.db")
        let detail = try db.prepare(userDetails.filter(self.user_id == user_id)).first
        if let detail = detail {
            let newDetail = UserDetail()
            newDetail.id = detail[UserDetail.id]
            newDetail.user_id = detail[UserDetail.user_id]
            newDetail.address = detail[UserDetail.address]
            newDetail.phone = detail[UserDetail.phone]
            return newDetail
        }
        return nil
    }
}

在上述代码中，User类中有一个detail属性，类型为UserDetail，表示用户与用户详情的一对一关系。在saveToDatabase方法中，保存用户信息时，如果存在用户详情信息，会同时保存用户详情。在loadFromDatabase方法中，加载用户信息时，也会根据用户id加载对应的用户详情信息。

一对多关系

以一个班级与学生的一对多关系为例，假设数据库中有“班级”表和“学生”表，“班级”表结构如下：

字段名数据类型说明
idINTEGER班级唯一标识，自增长主键
nameTEXT班级名称

“学生”表结构如下：

字段名数据类型说明
idINTEGER学生唯一标识，自增长主键
nameTEXT学生姓名
ageINTEGER学生年龄
class_idINTEGER关联的班级 id，外键

在 Swift 中，定义如下类：

class Class {
    var id: Int?
    var name: String?
    var students: [Student] = []

    func saveToDatabase() throws {
        let db = try Connection("school.db")
        if let classId = id {
            try db.run(classes.filter(self.id == classId).update(
                name <- self.name!
            ))
        } else {
            let insert = classes.insert(
                name <- self.name!
            )
            let insertedId = try db.run(insert)
            self.id = Int(insertedId)
        }
        for student in students {
            student.class_id = self.id
            try student.saveToDatabase()
        }
    }

    static func loadFromDatabase(id: Int) throws -> Class? {
        let db = try Connection("school.db")
        let classInfo = try db.prepare(classes.filter(self.id == id)).first
        if let classInfo = classInfo {
            let newClass = Class()
            newClass.id = classInfo[Class.id]
            newClass.name = classInfo[Class.name]
            let studentQuery = try db.prepare(students.filter(Student.class_id == newClass.id!))
            for student in studentQuery {
                let newStudent = Student()
                newStudent.id = student[Student.id]
                newStudent.name = student[Student.name]
                newStudent.age = student[Student.age]
                newStudent.class_id = newClass.id
                newClass.students.append(newStudent)
            }
            return newClass
        }
        return nil
    }
}

class Student {
    var id: Int?
    var name: String?
    var age: Int?
    var class_id: Int?

    func saveToDatabase() throws {
        let db = try Connection("school.db")
        if let studentId = id {
            try db.run(students.filter(self.id == studentId).update(
                name <- self.name!,
                age <- self.age!,
                class_id <- self.class_id!
            ))
        } else {
            let insert = students.insert(
                name <- self.name!,
                age <- self.age!,
                class_id <- self.class_id!
            )
            let insertedId = try db.run(insert)
            self.id = Int(insertedId)
        }
    }

    static func loadFromDatabase(id: Int) throws -> Student? {
        let db = try Connection("school.db")
        let student = try db.prepare(students.filter(self.id == id)).first
        if let student = student {
            let newStudent = Student()
            newStudent.id = student[Student.id]
            newStudent.name = student[Student.name]
            newStudent.age = student[Student.age]
            newStudent.class_id = student[Student.class_id]
            return newStudent
        }
        return nil
    }
}

在Class类中，students属性是一个Student类型的数组，表示一个班级可以有多个学生。在saveToDatabase方法中，保存班级信息时，会同时保存班级下的所有学生信息。在loadFromDatabase方法中，加载班级信息时，会根据班级id查询出所有属于该班级的学生信息并添加到students数组中。

多对多关系

以教师与课程的多对多关系为例，假设数据库中有“教师”表、“课程”表和一个中间表“教师课程关系”表。“教师”表结构如下：

字段名数据类型说明
idINTEGER教师唯一标识，自增长主键
nameTEXT教师姓名

“课程”表结构如下：

字段名数据类型说明
idINTEGER课程唯一标识，自增长主键
nameTEXT课程名称

“教师课程关系”表结构如下：

字段名数据类型说明
idINTEGER关系唯一标识，自增长主键
teacher_idINTEGER关联的教师 id，外键
course_idINTEGER关联的课程 id，外键

在 Swift 中，定义如下类：

class Teacher {
    var id: Int?
    var name: String?
    var courses: [Course] = []

    func saveToDatabase() throws {
        let db = try Connection("school.db")
        if let teacherId = id {
            try db.run(teachers.filter(self.id == teacherId).update(
                name <- self.name!
            ))
        } else {
            let insert = teachers.insert(
                name <- self.name!
            )
            let insertedId = try db.run(insert)
            self.id = Int(insertedId)
        }
        for course in courses {
            try insertTeacherCourseRelation(teacher_id: self.id!, course_id: course.id!)
        }
    }

    static func loadFromDatabase(id: Int) throws -> Teacher? {
        let db = try Connection("school.db")
        let teacher = try db.prepare(teachers.filter(self.id == id)).first
        if let teacher = teacher {
            let newTeacher = Teacher()
            newTeacher.id = teacher[Teacher.id]
            newTeacher.name = teacher[Teacher.name]
            let relationQuery = try db.prepare(teacherCourseRelations.filter(TeacherCourseRelation.teacher_id == newTeacher.id!))
            for relation in relationQuery {
                let courseId = relation[TeacherCourseRelation.course_id]
                if let course = try Course.loadFromDatabase(id: courseId) {
                    newTeacher.courses.append(course)
                }
            }
            return newTeacher
        }
        return nil
    }

    private func insertTeacherCourseRelation(teacher_id: Int, course_id: Int) throws {
        let db = try Connection("school.db")
        let insert = teacherCourseRelations.insert(
            TeacherCourseRelation.teacher_id <- teacher_id,
            TeacherCourseRelation.course_id <- course_id
        )
        try db.run(insert)
    }
}

class Course {
    var id: Int?
    var name: String?
    var teachers: [Teacher] = []

    func saveToDatabase() throws {
        let db = try Connection("school.db")
        if let courseId = id {
            try db.run(courses.filter(self.id == courseId).update(
                name <- self.name!
            ))
        } else {
            let insert = courses.insert(
                name <- self.name!
            )
            let insertedId = try db.run(insert)
            self.id = Int(insertedId)
        }
        for teacher in teachers {
            try insertTeacherCourseRelation(teacher_id: teacher.id!, course_id: self.id!)
        }
    }

    static func loadFromDatabase(id: Int) throws -> Course? {
        let db = try Connection("school.db")
        let course = try db.prepare(courses.filter(self.id == id)).first
        if let course = course {
            let newCourse = Course()
            newCourse.id = course[Course.id]
            newCourse.name = course[Course.name]
            let relationQuery = try db.prepare(teacherCourseRelations.filter(TeacherCourseRelation.course_id == newCourse.id!))
            for relation in relationQuery {
                let teacherId = relation[TeacherCourseRelation.teacher_id]
                if let teacher = try Teacher.loadFromDatabase(id: teacherId) {
                    newCourse.teachers.append(teacher)
                }
            }
            return newCourse
        }
        return nil
    }

    private func insertTeacherCourseRelation(teacher_id: Int, course_id: Int) throws {
        let db = try Connection("school.db")
        let insert = teacherCourseRelations.insert(
            TeacherCourseRelation.teacher_id <- teacher_id,
            TeacherCourseRelation.course_id <- course_id
        )
        try db.run(insert)
    }
}

class TeacherCourseRelation {
    static let id = Expression<Int?>("id")
    static let teacher_id = Expression<Int>("teacher_id")
    static let course_id = Expression<Int>("course_id")
}

在Teacher类和Course类中，分别有一个数组属性来表示多对多关系。在保存数据时，除了保存自身信息外，还会在“教师课程关系”表中插入相应的关系记录。在加载数据时，通过查询关系表来获取关联的对象信息。

数据验证与错误处理

数据验证

在将数据存储到 SQLite 数据库之前，进行数据验证是非常必要的。以“学生”类为例，我们可以在saveToDatabase方法中添加数据验证逻辑。比如，学生姓名不能为空，年龄必须在合理范围内。修改后的代码如下：

extension Student {
    func saveToDatabase() throws {
        if name == nil || name!.isEmpty {
            throw NSError(domain: "StudentDataValidationError", code: 1, userInfo: [NSLocalizedDescriptionKey: "学生姓名不能为空"])
        }
        if age == nil || age! < 0 || age! > 120 {
            throw NSError(domain: "StudentDataValidationError", code: 2, userInfo: [NSLocalizedDescriptionKey: "学生年龄不在合理范围内"])
        }
        let db = try Connection("student.db")
        if let studentId = id {
            try db.run(students.filter(self.id == studentId).update(
                name <- self.name!,
                age <- self.age!,
                grade <- self.grade!
            ))
        } else {
            let insert = students.insert(
                name <- self.name!,
                age <- self.age!,
                grade <- self.grade!
            )
            let insertedId = try db.run(insert)
            self.id = Int(insertedId)
        }
    }
}

在上述代码中，首先对name和age属性进行验证，如果不符合要求，则抛出错误。这样可以保证存储到数据库中的数据是有效的。

错误处理

在进行 SQLite 操作时，可能会遇到各种错误，如数据库连接失败、SQL 语句执行错误等。我们需要对这些错误进行适当的处理。以loadFromDatabase方法为例，修改后的代码如下：

extension Student {
    static func loadFromDatabase(id: Int) throws -> Student? {
        do {
            let db = try Connection("student.db")
            let student = try db.prepare(students.filter(self.id == id)).first
            if let student = student {
                let newStudent = Student()
                newStudent.id = student[id]
                newStudent.name = student[name]
                newStudent.age = student[age]
                newStudent.grade = student[grade]
                return newStudent
            }
            return nil
        } catch {
            print("加载学生数据时出错: \(error)")
            throw error
        }
    }
}

在上述代码中，使用do - catch块捕获可能出现的错误，并在捕获到错误时打印错误信息，然后重新抛出错误，以便上层调用者可以进一步处理错误。这样可以让开发者及时发现和解决 SQLite 操作过程中出现的问题。

性能优化

批量操作

在处理大量数据时，批量操作可以显著提高性能。以向“学生”表中插入多条记录为例，我们可以将多条插入操作合并为一次执行。修改saveToDatabase方法如下：

extension Student {
    static func saveStudentsToDatabase(students: [Student]) throws {
        let db = try Connection("student.db")
        try db.transaction {
            for student in students {
                if let studentId = student.id {
                    try db.run(Student.students.filter(Student.id == studentId).update(
                        Student.name <- student.name!,
                        Student.age <- student.age!,
                        Student.grade <- student.grade!
                    ))
                } else {
                    let insert = Student.students.insert(
                        Student.name <- student.name!,
                        Student.age <- student.age!,
                        Student.grade <- student.grade!
                    )
                    let insertedId = try db.run(insert)
                    student.id = Int(insertedId)
                }
            }
        }
    }
}

在上述代码中，通过db.transaction方法将多条插入或更新操作放在一个事务中执行，减少了数据库的交互次数，提高了性能。

索引优化

合理使用索引可以加快数据的查询速度。以“学生”表为例，如果经常根据name字段进行查询，可以为name字段创建索引。在 SQLite 中创建索引的 SQL 语句如下：

CREATE INDEX idx_student_name ON students (name);

在 Swift 中，可以使用以下代码创建索引：

let db = try Connection("student.db")
try db.run("CREATE INDEX idx_student_name ON students (name)")

创建索引后，在根据name字段查询学生信息时，查询速度会得到明显提升。

缓存策略

在应用中，可以采用缓存策略来减少对 SQLite 数据库的频繁访问。以“学生”类为例，可以使用一个内存缓存来存储最近访问过的学生信息。以下是一个简单的缓存实现示例：

class StudentCache {
    private var cache: [Int: Student] = [:]

    func getStudent(id: Int) -> Student? {
        if let student = cache[id] {
            return student
        }
        do {
            if let student = try Student.loadFromDatabase(id: id) {
                cache[id] = student
                return student
            }
        } catch {
            print("从数据库加载学生数据时出错: \(error)")
        }
        return nil
    }
}

在上述代码中，StudentCache类维护了一个字典作为缓存。当调用getStudent方法获取学生信息时，首先从缓存中查找，如果缓存中不存在，则从数据库中加载，并将加载后的学生信息存入缓存。这样在下次查询相同id的学生信息时，可以直接从缓存中获取，提高了数据获取的效率。

通过以上对 SQLite 数据库数据创建类的各个方面的介绍，包括基本步骤、处理复杂数据关系、数据验证与错误处理以及性能优化等，开发者可以更加高效地在 iOS 开发中使用 SQLite 数据库，构建出更加健壮和高性能的应用程序。