Android RxJava2结合Room插入实体并获取RowId的通用实现方案

我来给你分享一个简洁优雅的封装方案，完美解决你在多个地方重复编写RxJava+Room插入逻辑的问题，核心思路是把同步的Room插入操作统一包装成RxJava Single，并抽象出通用逻辑，避免重复代码。

1. 先封装通用的Room操作处理类 #

首先创建一个基础处理类，统一管理线程调度和Single的包装逻辑，这样所有实体的插入操作都能复用这部分代码：

import io.reactivex.Single;
import java.util.List;
import java.util.concurrent.Callable;

public class RxRoomHandler {
    private final SchedulerProvider schedulerProvider;

    // 构造方法传入你的线程调度器（比如项目里已有的SchedulerProvider）
    public RxRoomHandler(SchedulerProvider schedulerProvider) {
        this.schedulerProvider = schedulerProvider;
    }

    // 通用单实体插入方法：接收一个Callable<Long>，代表具体的DAO插入动作
    public Single<Long> insertEntity(Callable<Long> insertAction) {
        return Single.fromCallable(insertAction)
                .subscribeOn(schedulerProvider.io()) // 切换到IO线程执行数据库操作
                .observeOn(schedulerProvider.ui());   // 切换回UI线程处理结果
    }

    // 扩展：支持批量插入（返回多个RowId）
    public Single<List<Long>> insertEntities(Callable<List<Long>> batchInsertAction) {
        return Single.fromCallable(batchInsertAction)
                .subscribeOn(schedulerProvider.io())
                .observeOn(schedulerProvider.ui());
    }
}

2. 在ViewModel中直接复用通用方法 #

有了这个通用处理类之后，不管你要插入Body还是其他实体，都可以一行代码搞定：

示例：插入Body实体 #

// 在你的ViewModel中
Body body = new Body(contactId, msgText);

// 直接调用通用方法，传入DAO的插入动作
getCompositeDisposable().add(
        rxRoomHandler.insertEntity(() -> getDataSource().insertBody(body))
                .subscribe(bodyId -> {
                    // 拿到RowId后执行后续业务逻辑
                    onContinueNewMessage(msgId, conversationId, bodyId, forwardBodyId, replyMsgId, createdTimestamp);
                }, Timber::e) // 统一处理错误
);

扩展：插入其他实体（比如User） #

假设你有User实体和对应的UserDao.insertUser(User user)方法，同样可以复用通用逻辑：

User user = new User("张三", "zhangsan@example.com");

getCompositeDisposable().add(
        rxRoomHandler.insertEntity(() -> userDao.insertUser(user))
                .subscribe(userId -> {
                    Timber.d("插入User成功，RowId: %d", userId);
                    // 处理User的后续逻辑
                }, Timber::e)
);

3. 进阶：在Repository层进一步封装（可选） #

如果你的项目有Repository层统一管理数据操作，可以把通用逻辑再封装一层，让ViewModel调用更简洁：

public class AppRepository {
    private final BodyDao bodyDao;
    private final UserDao userDao;
    private final RxRoomHandler rxRoomHandler;

    public AppRepository(BodyDao bodyDao, UserDao userDao, RxRoomHandler rxRoomHandler) {
        this.bodyDao = bodyDao;
        this.userDao = userDao;
        this.rxRoomHandler = rxRoomHandler;
    }

    // 针对Body的具体插入方法，内部调用通用逻辑
    public Single<Long> insertBody(Body body) {
        return rxRoomHandler.insertEntity(() -> bodyDao.insertBody(body));
    }

    // 针对User的具体插入方法
    public Single<Long> insertUser(User user) {
        return rxRoomHandler.insertEntity(() -> userDao.insertUser(user));
    }

    // 批量插入Body
    public Single<List<Long>> insertBodies(List<Body> bodies) {
        return rxRoomHandler.insertEntities(() -> bodyDao.insertBodies(bodies));
    }
}

此时ViewModel中的调用会更清爽：

getCompositeDisposable().add(
        appRepository.insertBody(body)
                .subscribe(bodyId -> {
                    onContinueNewMessage(msgId, conversationId, bodyId, forwardBodyId, replyMsgId, createdTimestamp);
                }, Timber::e)
);

关键注意点 #

• 确保你的Room DAO方法是同步的（比如long insertBody(Body body)），Room不允许在主线程执行同步数据库操作，所以我们通过RxJava的subscribeOn切换到IO线程，这是符合Room最佳实践的。
• 别忘了在ViewModel的onCleared()方法中调用compositeDisposable.dispose()，避免内存泄漏：

  @Override
  protected void onCleared() {
      super.onCleared();
      getCompositeDisposable().dispose();
  }
  

内容的提问来源于stack exchange，提问作者nAkhmedov