Android 将通过改装获取的在线数据缓存到离线访问空间的方法

我正在尝试设计一个可以在线和离线工作的应用程序，我需要设计一种本地缓存系统，我已经尝试过MVVM实现，并且能够使用Room Persistence library从本地数据库获取数据，但我不确定如何从服务器获取数据，并使其表现为数据库（即本地缓存数据库）中已存储的数据，任何帮助都将不胜感激

我曾尝试实施改造并从中获取数据…但我的实现会在每次打开数据库时从服务器获取数据，删除以前的数据并使用服务器上的数据库填充数据，我认为这不是一个可行的实现，因为它需要删除并重新创建数据

class Repository {
private LiveData<List<User>> allUsers;
private static final String TAG = "Repository";
private UserDao userDao;

Repository(Application application) {
    DatabaseClass database = DatabaseClass.getInstance(application);
    userDao = database.databaseDAO();
    allUsers = userDao.getAllUsers();
    Retrofit retrofit = new Retrofit.Builder().baseUrl(BASE_URL).addConverterFactory(GsonConverterFactory.create()).build();
    RetrofitApi retrofitApi = retrofit.create(RetrofitApi.class);
    Call<List<User>> userCall = retrofitApi.get();

    userCall.enqueue(new Callback<List<User>>() {
        @Override
        public void onResponse(Call<List<User>> call, Response<List<User>> response) {
            List<User> userList = response.body();
            for (User user: userList
                 ) {
                user = new User(user.title,user.title,user.userId);
                insert(user);

            }
        }

        @Override
        public void onFailure(Call<List<User>> call, Throwable t) {

        }
    });


}

public void insert(User user)
{
    new InsertIntoDatabase(userDao).execute(user);
}
public  void update(User user)
{
    new UpdateUser(userDao).execute(user);
}
public void delete(User user)
{
    new DeleteFromDatabase(userDao).execute(user);
}
public void deleteAllUser()
{
    new DeleteAllUsers(userDao).execute();
}
public LiveData<List<User>> getAllUsers()
{
    return allUsers;
}



static class InsertIntoDatabase extends AsyncTask<User,Void,Void>{
    public UserDao userDao;

    public InsertIntoDatabase(UserDao userDao) {
        this.userDao = userDao;
    }

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

static class DeleteFromDatabase extends AsyncTask<User,Void,Void>{
    public UserDao userDao;

    public DeleteFromDatabase(UserDao userDao) {
        this.userDao = userDao;
    }

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


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

    public DeleteAllUsers(UserDao userDao) {
        this.userDao = userDao;
    }

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


static class UpdateUser extends AsyncTask<User,Void,Void>{
    UserDao userDao;

    public UpdateUser(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    protected Void doInBackground(User... users) {
        userDao.updateUser(users[0]);
        return null;
    }
}

类存储库{
私有LiveData用户；
私有静态最终字符串TAG=“Repository”；
私有UserDao UserDao；
存储库（应用程序）{
DatabaseClass database=DatabaseClass.getInstance（应用程序）；
userDao=database.databaseDAO（）；
allUsers=userDao.getAllUsers（）；
改装改装=新建改装.Builder（）.baseUrl（BASE_URL）.addConverterFactory（GsonConverterFactory.create（））.build（）；
RefundationAPI RefundationAPI=Refundation.create（RefundationAPI.class）；
Call userCall=reformationAPI.get（）；
enqueue（新回调（）{
@凌驾
公共void onResponse（调用、响应）{
List userList=response.body（）；
for（用户：userList）
) {
user=新用户（user.title，user.title，user.userId）；
插入（用户）；
}
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
}
});
}
公共作废插入（用户）
{
新的InsertIntoDatabase（userDao）.execute（user）；
}
公共无效更新（用户）
{
新的UpdateUser（userDao）.execute（user）；
}
公共作废删除（用户）
{
新建DeleteFromDatabase（userDao）.execute（user）；
}
公共无效deleteAluser（）
{
新建DeleteAllUsers（userDao）.execute（）；
}
公共LiveData getAllUsers（）
{
回归诱惑；
}
静态类InsertIntoDatabase扩展了AsyncTask{
公共UserDao UserDao；
公共插入数据库（UserDao UserDao）{
this.userDao=userDao；
}
@凌驾
受保护的Void doInBackground（用户…用户）{
userDao.insert（用户[0]）；
返回null；
}
}
静态类DeleteFromDatabase扩展了AsyncTask{
公共UserDao UserDao；
公共DeleteFromDatabase（UserDao UserDao）{
this.userDao=userDao；
}
@凌驾
受保护的Void doInBackground（用户…用户）{
userDao.delete（用户[0]）；
返回null；
}
}
静态类DeleteAllUsers扩展异步任务{
UserDao UserDao；
公共删除用户（UserDao UserDao）{
this.userDao=userDao；
}
@凌驾
受保护的空位背景（空位…空位）{
userDao.deleteAllUsers（）；
返回null；
}
}
静态类UpdateUser扩展了AsyncTask{
UserDao UserDao；
公共UpdateUser（UserDao UserDao）{
this.userDao=userDao；
}
@凌驾
受保护的Void doInBackground（用户…用户）{
userDao.updateUser（用户[0]）；
返回null；
}
}

}

我的期望如下所示 1） 仅更新的数据应存储在房间中 2）一些实现，不需要删除数据库中的所有内容，然后重新创建它

考虑考虑一下我的答案。正如我告诉过很多人（我可能仍然会）的那样，当你在学习新东西时，担心做事情的最佳方式几乎是毫无意义的，你应该首先让一些东西为你工作

将房间用作缓存的典型方法如下所示：

从api获取数据

将其插入房间数据库

在我的应用程序中从房间中获取它

---

房间允许您在本地存储数据并用各种不同的线程检索这些数据，使用RxJava之类的东西，它也允许您观察到与LIFEDATA相关的任何更改，在这种情况下，Road绝对是考虑缓存的一个体面的选项。虽然这是你可以使用的几种技术之一，但我还没有尝试过。我是android新手。你认为这种方法可行吗。。。我的意思是如果我使用更新而不是插入