Android Room-获取新插入行表单@Insert的id

在下面的代码中，我得到了

rowId

。我已经了解到，还可以直接从

@Insert

获取最后插入的行id。在我的代码中，我将void insert改为long，并尝试了许多其他方法，就像我在互联网上找到的示例一样，但每次我都会出错。是否要为我提供代码/解决方案以从@Insert获取行/用户ID

@Dao
public interface UserDao {

    @Insert
    void insert(UserEntity userEntity);

    @Update
    void update(UserEntity userEntity);

    @Delete
    void delete(UserEntity userEntity);

    @Query("DELETE FROM user_table")
    void deleteAllUsers();

    @Query("SELECT * FROM user_table")
    LiveData<List<UserEntity>> getAllUsers();

//    ====== from here ======

    @Query("SELECT * FROM user_table")
    LiveData<UserEntity> getRowId();

//    ====== till here ======

}

存储库

public class UserRepository {
    private UserDao userDao;
    private LiveData<List<UserEntity>> allUsers;

    public UserRepository(Application application) {
        HandymanDatabase handymanDatabase = HandymanDatabase.getInstance(application);
        userDao = handymanDatabase.userDao();
        allUsers = userDao.getAllUsers();
    }

    public void insert(UserEntity userEntity) {
        new InsertUserAsyncTask(userDao).execute(userEntity);
    }

    public void update(UserEntity userEntity) {
        new UpdateUserAsyncTask(userDao).execute(userEntity);
    }

    public void delete(UserEntity userEntity) {
        new DeleteUserAsyncTask(userDao).execute(userEntity);
    }

    public void deleteAllUsers() {
        new DeleteAllUsersAsyncTask(userDao).execute();
    }

    public LiveData<List<UserEntity>> getAllUsers() {
        return allUsers;
    }

//    ====== from here ======

    public LiveData<UserEntity> getRowId() {
        return userDao.getRowId();
    }

//    ====== till here ======


    private static class InsertUserAsyncTask extends AsyncTask<UserEntity, Void, Void> {
        private UserDao userDao;

        private InsertUserAsyncTask(UserDao userDao) {
            this.userDao = userDao;
        }

        @Override
        protected Void doInBackground(UserEntity... userEntities) {
            userDao.insert(userEntities[0]);
            return null;
        }
    }

    private static class UpdateUserAsyncTask extends AsyncTask<UserEntity, Void, Void> {
        private UserDao userDao;

        private UpdateUserAsyncTask(UserDao userDao) {
            this.userDao = userDao;
        }

        @Override
        protected Void doInBackground(UserEntity... userEntities) {
            userDao.update(userEntities[0]);
            return null;
        }
    }

    private static class DeleteUserAsyncTask extends AsyncTask<UserEntity, Void, Void> {
        private UserDao userDao;

        private DeleteUserAsyncTask(UserDao userDao) {
            this.userDao = userDao;
        }

        @Override
        protected Void doInBackground(UserEntity... userEntities) {
            userDao.delete(userEntities[0]);
            return null;
        }
    }

    private static class DeleteAllUsersAsyncTask extends AsyncTask<Void, Void, Void> {
        private UserDao userDao;

        private DeleteAllUsersAsyncTask(UserDao userDao) {
            this.userDao = userDao;
        }

        @Override
        protected Void doInBackground(Void... voids) {
            userDao.deleteAllUsers();
            return null;
        }
    }
}

公共类用户存储库{
私有UserDao UserDao；
私有LiveData用户；
公共用户存储库（应用程序）{
handymandabase handymandabase=handymandabase.getInstance（应用程序）；
userDao=handymandabase.userDao（）；
allUsers=userDao.getAllUsers（）；
}
公共作废插入（用户实体用户实体）{
新建InsertUserAsyncTask（userDao）.execute（userEntity）；
}
公共无效更新（用户实体用户实体）{
新的UpdateUserSyncTask（userDao）.execute（userEntity）；
}
公共作废删除（UserEntity UserEntity）{
新建DeleteUserAsyncTask（userDao）.execute（userEntity）；
}
公共图书馆{
新建DeleteAllUsersAsyncTask（userDao）.execute（）；
}
公共LiveData getAllUsers（）{
回归诱惑；
}
//======从这里开始======
公共LiveData getRowId（）{
返回userDao.getRowId（）；
}
//直到这里======
私有静态类InsertUserAsyncTask扩展了AsyncTask{
私有UserDao UserDao；
专用InsertUserAsyncTask（UserDao UserDao）{
this.userDao=userDao；
}
@凌驾
受保护的Void doInBackground（UserEntity…userEntities）{
insert（userEntities[0]）；
返回null；
}
}
私有静态类UpdateUserAsyncTask扩展了AsyncTask{
私有UserDao UserDao；
私有UpdateUserAsyncTask（UserDao UserDao）{
this.userDao=userDao；
}
@凌驾
受保护的Void doInBackground（UserEntity…userEntities）{
update（userEntities[0]）；
返回null；
}
}
私有静态类DeleteUserAsyncTask扩展了AsyncTask{
私有UserDao UserDao；
私有DeleteUserAsyncTask（UserDao UserDao）{
this.userDao=userDao；
}
@凌驾
受保护的Void doInBackground（UserEntity…userEntities）{
userDao.delete（userEntities[0]）；
返回null；
}
}
私有静态类deleteAllusAsynctask扩展异步任务{
私有UserDao UserDao；
私有deleteAllusAsynctask（UserDao UserDao）{
this.userDao=userDao；
}
@凌驾
受保护的空位背景（空位…空位）{
userDao.deleteAllUsers（）；
返回null；
}
}
}

视图模型

public UserViewModel(@NonNull Application application) {
        super(application);
        userRepository = new UserRepository(application);
        allUsers = userRepository.getAllUsers();
    }

    public void insert(UserEntity userEntity) {
        userRepository.insert(userEntity);
    }

    public void update(UserEntity userEntity) {
        userRepository.update(userEntity);
    }

    public void delete(UserEntity userEntity) {
        userRepository.delete(userEntity);
    }

    public void deleteAllUsers() {
        userRepository.deleteAllUsers();
    }

    public LiveData<List<UserEntity>> getAllUsers() {
        return allUsers;
    }

//    ====== from here ======

    public LiveData<UserEntity> getRowId() {
        return userRepository.getRowId();
    }

//    ====== till here ======

}

public void insertUserEntity(UserEntity entity, NewIdListener listener) {
    userRepository.insertUserEntity(entity, listener);
}       

public UserViewModel（@NonNull应用程序）{
超级（应用）；
userRepository=新的userRepository（应用程序）；
allUsers=userRepository.getAllUsers（）；
}
公共作废插入（用户实体用户实体）{
userRepository.insert（userEntity）；
}
公共无效更新（用户实体用户实体）{
userRepository.update（userEntity）；
}
公共作废删除（UserEntity UserEntity）{
userRepository.delete（userEntity）；
}
公共图书馆{
userRepository.deleteAllUsers（）；
}
公共LiveData getAllUsers（）{
回归诱惑；
}
//======从这里开始======
公共LiveData getRowId（）{
返回userRepository.getRowId（）；
}
//直到这里======
}

片段/活动

public class UserFavoritesFragment extends Fragment {

    private static final String TAG = "UserFavoritesFragment";

    private UserViewModel userViewModel;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {

        View view = getLayoutInflater().inflate(R.layout.fragment_user_favorites, container, false);

        final TextView textViewUserName = view.findViewById(R.id.textViewUserName);
        TextView textViewUserPhone = view.findViewById(R.id.textViewUserPhone);

        userViewModel = new ViewModelProvider(this).get(UserViewModel.class);

//    ====== from here ======

        userViewModel.getRowId().observe(getViewLifecycleOwner(), new Observer<UserEntity>() {
            @Override
            public void onChanged(UserEntity userEntity) {

                long rowId = userEntity.getId();

                Log.d(TAG, "onChanged: " + rowId);

            }
        });

//    ====== till here ======

        return view;
    }
}

public类UserFavoritesFragment扩展片段{
私有静态最终字符串TAG=“UserFavoritesFragment”；
私有用户视图模型用户视图模型；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
}
@凌驾
创建视图上的公共视图（布局、充气机、视图组容器、，
Bundle savedInstanceState）{
视图=GetLayoutFlater（）。充气（R.layout.fragment\u user\u收藏夹，容器，false）；
最终TextView textViewUserName=view.findViewById（R.id.textViewUserName）；
TextView textViewUserPhone=view.findViewById（R.id.textViewUserPhone）；
userViewModel=newviewmodelprovider（this.get）（userViewModel.class）；
//======从这里开始======
userViewModel.getRowId（）.observe（getViewLifecycleOwner（），new Observer（））{
@凌驾
更改后的公共void（UserEntity UserEntity）{
long rowId=userEntity.getId（）；
Log.d（标记“onChanged:+rowId”）；
}
});
//直到这里======
返回视图；
}
}

您可以使用一个侦听器接口来实现这一点，该接口具有一个回调函数，该回调函数接受数据库中插入的行id的长值

侦听器界面

public interface NewIdListener {
    void onInsert(long id);
}

Dao

@Dao
public interface UserDao {

    @Insert
    long insert(UserEntity userEntity); // return id of the inserted userEntity
    
}

存储库

public class UserRepository {
    private Executor mExecutor = Executors.newSingleThreadExecutor();
    private UserDao userDao;
    ...
    
    public void insertUserEntity(final UserEntity entity, final NewIdListener listener) {
        mExecutor.execute(new Runnable() {
            @Override
            public void run() {
                listener.onInsert(userDao.insert(entity));
            }
        });
}
    

userViewModel.insertUserEntity(new UserEntity("User Name", "12345678"), new NewIdListener() {
    @Override
    public void onInsert(final long id) {
        requireActivity().runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(requireActivity(), "Id: " + id, Toast.LENGTH_SHORT).show();
            }
        });
    }
});

视图模型

public UserViewModel(@NonNull Application application) {
        super(application);
        userRepository = new UserRepository(application);
        allUsers = userRepository.getAllUsers();
    }

    public void insert(UserEntity userEntity) {
        userRepository.insert(userEntity);
    }

    public void update(UserEntity userEntity) {
        userRepository.update(userEntity);
    }

    public void delete(UserEntity userEntity) {
        userRepository.delete(userEntity);
    }

    public void deleteAllUsers() {
        userRepository.deleteAllUsers();
    }

    public LiveData<List<UserEntity>> getAllUsers() {
        return allUsers;
    }

//    ====== from here ======

    public LiveData<UserEntity> getRowId() {
        return userRepository.getRowId();
    }

//    ====== till here ======

}

public void insertUserEntity(UserEntity entity, NewIdListener listener) {
    userRepository.insertUserEntity(entity, listener);
}       

活动

public class UserRepository {
    private Executor mExecutor = Executors.newSingleThreadExecutor();
    private UserDao userDao;
    ...
    
    public void insertUserEntity(final UserEntity entity, final NewIdListener listener) {
        mExecutor.execute(new Runnable() {
            @Override
            public void run() {
                listener.onInsert(userDao.insert(entity));
            }
        });
}
    

userViewModel.insertUserEntity(new UserEntity("User Name", "12345678"), new NewIdListener() {
    @Override
    public void onInsert(final long id) {
        requireActivity().runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(requireActivity(), "Id: " + id, Toast.LENGTH_SHORT).show();
            }
        });
    }
});

---

注意：对于后台线程，我使用了

Executor

而不是

AsyncTask

，因为

AsyncTask

现在已被弃用。

感谢您的回复。但我仍然有两个错误。存储库中的一个-变量“listener”是从内部类中访问的，需要声明为final，而活动中的第二个-无法解析符号“entity”。你知道我做错了什么吗？@AJW我在活动中使用匿名侦听器，而不是在ViewModel中，它只是作为方法参数传递给ViewModel，但没有保存在其上；每当上下文被销毁和重新创建并最终重新传递给ViewModel时，该侦听器都将被销毁和重新创建，因此它独立于ViewModel。@Zain Ok我理解。干杯@Zain今晚添加了你的代码