安卓备忘录的数据库开发代码

数据库设计

备忘录应用的数据库主要用于存储和管理用户的备忘信息,常见的字段包括：

• id: 主键，自增 备忘录标题
• content: 备忘录内容
• create_time: 创建时间
• update_time: 最后修改时间
• is_completed: 是否完成（可选）
• priority: 优先级（可选）

表结构定义

实体类定义（使用 Room 框架）

import androidx.room.Entity
import androidx.room.PrimaryKey
import java.util.Date
@Entity(tableName = "memo")
data class Memo(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val title: String,
    val content: String,
    val createTime: Long = Date().time,
    val updateTime: Long = Date().time,
    val isCompleted: Int = 0, // 0: 未完成, 1: 已完成
    val priority: Int = 1 // 默认优先级为1
)

DAO 接口定义

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import androidx.room.Delete
import kotlinx.coroutines.flow.Flow
@Dao
interface MemoDao {
    // 插入数据，冲突时替换旧数据
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(memo: Memo)
    // 更新数据
    @Update
    suspend fun update(memo: Memo)
    // 删除数据
    @Delete
    suspend fun delete(memo: Memo)
    // 查询所有备忘录（按时间倒序）
    @Query("SELECT  FROM memo ORDER BY updateTime DESC")
    fun getAllMemos(): Flow<List<Memo>>
    // 根据 ID 查询单条数据
    @Query("SELECT  FROM memo WHERE id = :id")
    suspend fun getMemoById(id: Int): Memo?
}

数据库类定义

import androidx.room.Database
import androidx.room.RoomDatabase
import androidx.room.TypeConverters
@Database(entities = [Memo::class], version = 1)
@TypeConverters(Converters::class) // 自定义类型转换器
abstract class AppDatabase : RoomDatabase() {
    abstract fun memoDao(): MemoDao
}

类型转换器（处理非基础类型）

import androidx.room.TypeConverter
import java.util.Date
class Converters {
    @TypeConverter
    fun fromTimestamp(value: Long?): Date? {
        return value?.let { Date(it) }
    }
    @TypeConverter
    fun dateToTimestamp(date: Date?): Long? {
        return date?.time
    }
}

数据库初始化（单例模式）

import android.content.Context
import androidx.room.Room
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
object DatabaseProvider {
    private var database: AppDatabase? = null
    fun getDatabase(context: Context): AppDatabase {
        return database ?: synchronized(this) {
            val db = Room.databaseBuilder(
                context,
                AppDatabase::class.java,
                "memo_database"
            ).build()
            database = db
            db
        }
    }
}

示例操作（Repository 层）

import kotlinx.coroutines.flow.first
import kotlinx.coroutines.withContext
class MemoRepository(private val db: AppDatabase) {
    fun addMemo(memo: Memo) {
        CoroutineScope(Dispatchers.IO).launch {
            db.memoDao().insert(memo)
        }
    }
    fun getAllMemos(callback: (List<Memo>) -> Unit) {
        CoroutineScope(Dispatchers.IO).launch {
            val memos = db.memoDao().getAllMemos().first()
            callback(memos)
        }
    }
}

相关问题与解答

问题 1：如何升级数据库版本？

解答：
在 AppDatabase 类中重写 upgrade 方法,定义版本升级逻辑。

@Database(entities = [Memo::class], version = 2) // 新版本号
abstract class AppDatabase : RoomDatabase() {
    override fun upgrade(oldVersion: Int, newVersion: Int) {
        // 示例：添加新字段 `priority`
        if (oldVersion == 1 && newVersion == 2) {
            executionScope.execute { // 在后台线程执行迁移
                db.execSQL("ALTER TABLE memo ADD COLUMN priority INTEGER DEFAULT 1")
            }
        }
    }
}

问题 2：如何处理多线程并发访问？

解答：
Room 天然支持多线程访问，所有 @Query 方法默认返回 LiveData 或 Flow，可自动监听数据变化，若需手动管理线程，可使用 CoroutineScope 配合 Dispatchers.IO，

CoroutineScope(Dispatchers.IO).launch {
    // 在 IO 线程执行数据库操作
    val result = db.memoDao().getMemoById(1)
    withContext(Dispatchers.Main) {
        // 回到主线程更新 UI
    }
}