Android Room - 简单的查询 - 无法在主线程访问数据库

您需要在后台执行请求。 一种简单的方式是使用Executors：

Executors.newSingleThreadExecutor().execute { 
   yourDb.yourDao.yourRequest() //Replace this by your request
}

Room 数据库不允许您在主线程中执行数据库 IO 操作（后台操作），除非您在数据库构建器中使用 allowMainThreadQueries()。但这是一种不好的方法。

---

推荐的方法:
在这里，我将使用我当前项目中的一些代码。

在 Repository 的方法前添加 suspend 关键字。

class FavRepository @Inject constructor(private val dao: WallpaperDao) {
    suspend fun getWallpapers(): List<Wallpaper> =  dao.getWallpapers()
}

在你的viewmodel类中，首先需要使用协程分发器IO执行数据库操作，以从room数据库中获取数据。然后使用协程分发器MAIN更新你的值。

@HiltViewModel
class FavViewModel @Inject constructor(repo: FavRepository, @ApplicationContext context: Context) : ViewModel() {
    var favData = MutableLiveData<List<Wallpaper>>()
    init {
        viewModelScope.launch(Dispatchers.IO){
            val favTmpData: List<Wallpaper> = repo.getWallpapers()
            withContext(Dispatchers.Main){
                favData.value = favTmpData
            }
        }
    }
}

现在，您可以通过从Activity/Fragment中观察ViewModel的数据来使用它的数据。

希望这对您有所帮助 :)。

一种优雅的 RxJava/Kotlin 解决方案是使用 Completable.fromCallable，它会给你一个不返回值但可以在不同线程上被观察和订阅的 Observable。

public Completable insert(Event event) {
    return Completable.fromCallable(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            return database.eventDao().insert(event)
        }
    }
}

或者用 Kotlin 写成：

fun insert(event: Event) : Completable = Completable.fromCallable {
    database.eventDao().insert(event)
}

您可以像平常一样观察和订阅：

dataManager.insert(event)
    .subscribeOn(scheduler)
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(...)

你可以在主线程上允许数据库访问，但只限于调试目的，不应在生产环境中这样做。 原因在此。 注意：除非您在构建器上调用了allowMainThreadQueries()，否则Room不支持在主线程上访问数据库，因为它可能会锁定UI很长时间。异步查询——返回LiveData或Flowable实例的查询——不受此规则的限制，因为它们会在需要时在后台线程上异步运行查询。

对于快速查询，您可以允许在UI线程上执行它。

AppDatabase db = Room.databaseBuilder(context.getApplicationContext(),
        AppDatabase.class, DATABASE_NAME).allowMainThreadQueries().build();

在我的情况下，我需要确定列表中被点击的用户是否存在于数据库中。如果不存在，则创建该用户并启动另一个活动。

       @Override
        public void onClick(View view) {



            int position = getAdapterPosition();

            User user = new User();
            String name = getName(position);
            user.setName(name);

            AppDatabase appDatabase = DatabaseCreator.getInstance(mContext).getDatabase();
            UserDao userDao = appDatabase.getUserDao();
            ArrayList<User> users = new ArrayList<User>();
            users.add(user);
            List<Long> ids = userDao.insertAll(users);

            Long id = ids.get(0);
            if(id == -1)
            {
                user = userDao.getUser(name);
                user.setId(user.getId());
            }
            else
            {
                user.setId(id);
            }

            Intent intent = new Intent(mContext, ChatActivity.class);
            intent.putExtra(ChatActivity.EXTRAS_USER, Parcels.wrap(user));
            mContext.startActivity(intent);
        }
    }

如果您更喜欢使用 异步任务 ：

  new AsyncTask<Void, Void, Integer>() {
                @Override
                protected Integer doInBackground(Void... voids) {
                    return Room.databaseBuilder(getApplicationContext(),
                            AppDatabase.class, DATABASE_NAME)
                            .fallbackToDestructiveMigration()
                            .build()
                            .getRecordingDAO()
                            .getAll()
                            .size();
                }

                @Override
                protected void onPostExecute(Integer integer) {
                    super.onPostExecute(integer);
                    Toast.makeText(HomeActivity.this, "Found " + integer, Toast.LENGTH_LONG).show();
                }
            }.execute();

您可以使用Future和Callable。因此，您不需要编写长时间的异步任务，并且可以执行查询而不添加allowMainThreadQueries()。
我的dao查询：

@Query("SELECT * from user_data_table where SNO = 1")
UserData getDefaultData();

我的存储库方法：

public UserData getDefaultData() throws ExecutionException, InterruptedException {

    Callable<UserData> callable = new Callable<UserData>() {
        @Override
        public UserData call() throws Exception {
            return userDao.getDefaultData();
        }
    };

    Future<UserData> future = Executors.newSingleThreadExecutor().submit(callable);

    return future.get();
}

这个错误信息是非常具体和准确的，它告诉你不要在主线程上访问数据库，因为这可能会长时间锁定用户界面。如果想避免在主线程上访问数据库，可以阅读AsyncTask来开始学习相关知识。

-----编辑----------

看起来你在运行单元测试时遇到了问题，你有几种选择来解决：

1. 直接在开发机上运行测试，而不是在 Android 设备（或模拟器）上运行。这对于那些以数据库为中心的测试非常有效，因为它们不关心是否在设备上运行。

2. 使用注释@RunWith(AndroidJUnit4.class)在 Android 设备上运行测试，但不在带有 UI 的活动中运行。更多详情，请参考此教程。

更新：当我尝试在DAO中使用@RawQuery和SupportSQLiteQuery构建查询时，我也收到了这条消息。

@Transaction
public LiveData<List<MyEntity>> getList(MySettings mySettings) {
    //return getMyList(); -->this is ok

    return getMyList(new SimpleSQLiteQuery("select * from mytable")); --> this is an error

解决方案：在ViewModel中构建查询并将其传递给DAO。

public MyViewModel(Application application) {
...
        list = Transformations.switchMap(searchParams, params -> {

            StringBuilder sql;
            sql = new StringBuilder("select  ... ");

            return appDatabase.rawDao().getList(new SimpleSQLiteQuery(sql.toString()));

        });
    }

或者...

您不应该直接在主线程上访问数据库，例如：

 public void add(MyEntity item) {
     appDatabase.myDao().add(item); 
 }

你应该使用AsyncTask来进行更新、添加和删除操作。
示例：

public class MyViewModel extends AndroidViewModel {

    private LiveData<List<MyEntity>> list;

    private AppDatabase appDatabase;

    public MyViewModel(Application application) {
        super(application);

        appDatabase = AppDatabase.getDatabase(this.getApplication());
        list = appDatabase.myDao().getItems();
    }

    public LiveData<List<MyEntity>> getItems() {
        return list;
    }

    public void delete(Obj item) {
        new deleteAsyncTask(appDatabase).execute(item);
    }

    private static class deleteAsyncTask extends AsyncTask<MyEntity, Void, Void> {

        private AppDatabase db;

        deleteAsyncTask(AppDatabase appDatabase) {
            db = appDatabase;
        }

        @Override
        protected Void doInBackground(final MyEntity... params) {
            db.myDao().delete((params[0]));
            return null;
        }
    }

    public void add(final MyEntity item) {
        new addAsyncTask(appDatabase).execute(item);
    }

    private static class addAsyncTask extends AsyncTask<MyEntity, Void, Void> {

        private AppDatabase db;

        addAsyncTask(AppDatabase appDatabase) {
            db = appDatabase;
        }

        @Override
        protected Void doInBackground(final MyEntity... params) {
            db.myDao().add((params[0]));
            return null;
        }

    }
}

如果您使用LiveData进行查询操作，就不需要AsyncTask。

在流的末尾添加 Dispatchers.IO，如下所示：

flow { ... }.flowOn(Dispatchers.IO)