0

我必须在第一次运行时预先填充一个 Room 数据库，我看到了 Florina Muntenescu 关于它的要点。

https://gist.github.com/florina-muntenescu/697e543652b03d3d2a06703f5d6b44b5#pre-populate-a-room-database

所以，我们有...

   @Database(entities = arrayOf(Data::class), version = 1)
   abstract class DataDatabase : RoomDatabase() {

   abstract fun dataDao(): DataDao

  companion object {

    @Volatile private var INSTANCE: DataDatabase? = null

    fun getInstance(context: Context): DataDatabase =
            INSTANCE ?: synchronized(this) {
                INSTANCE ?: buildDatabase(context).also { INSTANCE = it }
            }

    private fun buildDatabase(context: Context) =
            Room.databaseBuilder(context.applicationContext,
                    DataDatabase::class.java, "Sample.db")
                    // prepopulate the database after onCreate was called
                    .addCallback(object : Callback() {
                        override fun onCreate(db: SupportSQLiteDatabase) {
                            super.onCreate(db)
                            // insert the data on the IO Thread
                            ioThread {
                                getInstance(context).dataDao().insertData(PREPOPULATE_DATA)
                            }
                        }
                    })
                    .build()

    val PREPOPULATE_DATA = listOf(Data("1", "val"), Data("2", "val 2"))
  }

但我不明白我应该在哪里调用这个 getInstance 方法，我是否需要在我的片段、MainActivity 或其他地方进行一些虚拟 DAO 调用（只是为了填充 DB）？（假设我打算在这个项目中使用 MVVM）。

或者也许我只是疲倦和盲目地看到解决方案......

4

2 回答 2

1

对我来说，使用 ROOM 创建和访问数据库有 5 个步骤。

1）设置实体，是您的名称对象（数据库中的每个条目）。


    @Entity(tableName = "my_table")
    public class MyEntity {
         @PrimaryKey(autoGenerate = true)
         private int mId;

         private String mFirstName;
         private String mLastName;
         public MyEntity(String firstName, String lastName) {
             this.mFirstName = firstName;
             this.mLastName = lastName;
         }
        public int getId() {
            return mId;
        }

        public String getFirstName() {
            return mFirstName;
        }

        public String getLastName() {
            return mLastName;
        }

        public void setId(int mId) {
            this.mId = mId;
        }
    }

2）设置DAO，DAO是你与数据库通信的方式。

@Dao
public interface MyDao {
    @Query("SELECT * FROM my_table")
    LiveData<List<MyEntity>> getAllNames();

    @Inster
     void insert(MyEntity name);

3) 设置数据库

@DataBase(entities = {MyEntity.class}, version 1, exportschema = false}
public abastract class MyDatabase extends RoomDatabase {
    private static MyDatabase INSTANCE;
    public MyDao mMyDao;

    public static synchronized MyDatabase getInstance(Context context) {
        if(INSTANCE == null) {
            INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                MyDatabase.class "database_name")
                .fallbackToDestructiveMigration()
                .addCallback(roomCallBack)
                .build();
        }
        return INSTANCE;

    private static RoomDatabase.Callback roomCallBack = new RoomDatabase.Callback() {
        @Override
        public void onCreate(@NonNull SupportSQLiteDatabase db) {
            super.onCreate(db);
            new PopulateDbAsyncTask(INSTANCE).execute();
        }
    };
}

private static class PopulateDbAsyncTask extends AsyncTask<Void, Void, Void> {
        private MyDao mMyDao;

        public PopulateDbAsyncTask(MyDatabase db) {
            this.mMyDao = db.MyDao();
        }

        @Override
        protected Void doInBackground(Void... voids) {
            mMyDao.insert(new MyEntity("FirstName", "LastName")
            // Repeat as many times as needed.
            return null;
        }
    }

4）设置存储库，存储库调用/创建数据库

public class MyRepository {

    private MyDao mMyDao;
    private LiveData<List<MyEntity>> mMyList;

    // Constructor will call the database Class.
    public MyRepository(Application application) {
        MyDatabase db = MyDatabase.getInstance(application);
        this.mMyDao = db.mMyDao;
        mMyList = mMyDao.getAllNames();
    }

    public LiveData<List<MyEntity> getAllNames() {
        return mMyList;
    }
}

5）设置视图模型，从活动或片段访问您的视图模型。

public class MyViewModel extends ViewModel {
    private LiveData<List<MyEntity>> mMyList;
    private Repository mRepository;    

    public MyViewModel(Application application) {
        this.mApplication = application;
        mRepository = new Repository(application);
        this.mMyList = mRepository.getAllNames;
    }

    public LiveData<List<MyEntity>> getAllNames() {
        return mMyList = mRepository.getAllNames();
    }
于 2019-09-24T03:25:21.003 回答
0

我不是 100% 确定我了解您的最终目标是什么；然而，当我编写使用 SQLite 数据库的应用程序时，我喜欢有一些可以立即添加到数据库中的虚拟信息，这样我就可以看到我所有不同的活动将如何响应查询等。

在我的主屏幕上，我通常会放置一个按钮，上面写着“添加虚拟数据”。OnClick，它从我的 SQLHelper 类中调用函数 addDummyData() 来编写大约 20 个插入语句。一旦我的应用程序启动并按照我想要的方式运行，我将在分发之前删除该按钮。

如果您添加要自动调用的插入语句（即无需用户干预按下按钮、选择菜单项等），那么您的应用程序每次启动时都会冒着添加相同的 20 条插入行的风险. 您的数据库很快就会被多个重复项淹没。您需要添加一个 if{} 语句，首先检查数据是否已存在于数据库中（例如，使用返回游标运行查询以获取其中一个虚拟值，如果游标计数为零，则继续填充数据库，否则不要）。

于 2019-09-24T02:36:10.053 回答