一个优雅的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(...)

错误信息，

不能访问主线程上的数据库，因为它可能会锁定UI很长一段时间。

描述的很准确。问题是如何避免在主线程上访问数据库。这是一个巨大的主题，但要开始，请阅读AsyncTask(点击这里)

——编辑 ----------

我看到你在运行单元测试时遇到了问题。你有几个选择来解决这个问题:

直接在开发机器上运行测试，而不是在Android设备(或模拟器)上运行。这适用于以数据库为中心且并不真正关心它们是否在设备上运行的测试。 使用注释 @RunWith (AndroidJUnit4.class) 在android设备上运行测试，而不是在带有UI的活动中。 更多的细节可以在本教程中找到

由于asyncTask已弃用，我们可以使用executor服务。或者你也可以在LiveData中使用ViewModel，正如在其他答案中解释的那样。

对于使用执行者服务，您可以使用如下内容。

public class DbHelper {

    private final Executor executor = Executors.newSingleThreadExecutor();

    public void fetchData(DataFetchListener dataListener){
        executor.execute(() -> {
                Object object = retrieveAgent(agentId);
                new Handler(Looper.getMainLooper()).post(() -> {
                        dataListener.onFetchDataSuccess(object);
                });
        });
    }
}

使用Main Looper，这样你就可以从onfetchdatasuccsuccess回调中访问UI元素。

如果你更喜欢异步任务:

  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();

数据库访问在主线程锁定UI是错误的，如Dale所说。

——编辑2

因为很多人可能会遇到这个答案…… 一般来说，现在最好的选择是Kotlin协程。Room现在直接支持它(目前处于测试阶段)。 https://kotlinlang.org/docs/reference/coroutines-overview.html https://developer.android.com/jetpack/androidx/releases/room#2.1.0-beta01

——编辑1

对于想知道……你还有其他选择。 我建议查看一下新的ViewModel和LiveData组件。LiveData与Room合作得很好。 https://developer.android.com/topic/libraries/architecture/livedata.html

另一个选择是RxJava/RxAndroid。比LiveData更强大但更复杂。 https://github.com/ReactiveX/RxJava

——原来的答案

在您的活动扩展AsyncTask中创建一个静态嵌套类(以防止内存泄漏)。

private static class AgentAsyncTask extends AsyncTask<Void, Void, Integer> {

    //Prevent leak
    private WeakReference<Activity> weakActivity;
    private String email;
    private String phone;
    private String license;

    public AgentAsyncTask(Activity activity, String email, String phone, String license) {
        weakActivity = new WeakReference<>(activity);
        this.email = email;
        this.phone = phone;
        this.license = license;
    }

    @Override
    protected Integer doInBackground(Void... params) {
        AgentDao agentDao = MyApp.DatabaseSetup.getDatabase().agentDao();
        return agentDao.agentsCount(email, phone, license);
    }

    @Override
    protected void onPostExecute(Integer agentsCount) {
        Activity activity = weakActivity.get();
        if(activity == null) {
            return;
        }

        if (agentsCount > 0) {
            //2: If it already exists then prompt user
            Toast.makeText(activity, "Agent already exists!", Toast.LENGTH_LONG).show();
        } else {
            Toast.makeText(activity, "Agent does not exist! Hurray :)", Toast.LENGTH_LONG).show();
            activity.onBackPressed();
        }
    }
}

或者你可以在final类自己的文件上创建一个final类。

然后在signUpAction(View视图)方法中执行它:

new AgentAsyncTask(this, email, phone, license).execute();

在某些情况下，你可能还想在你的活动中保留一个对AgentAsyncTask的引用，这样你就可以在活动被销毁时取消它。但是你必须自己中断任何交易。

另外，你关于谷歌的测试示例的问题… 他们在那个网页上说:

测试数据库实现的推荐方法是 编写在Android设备上运行的JUnit测试。因为这些 测试不需要创建活动，它们应该更快 执行你的UI测试。

没有活动，就没有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。