Recyclerview中POJO和Retrieve的房间插入列表答案

【问题标题】：Room Insert List of POJO and Retrieve in RecyclerviewRecyclerview中POJO和Retrieve的房间插入列表
【发布时间】：2019-03-19 18:09:57
【问题描述】：

我将房间用作我的应用程序的数据存储。我正在尝试从 viewmodel 类中的成功网络调用中保存会话列表。我使用了一个存储库来与 dao 交互，并使用 asynctask 来使 crud 操作异步。

现在，我正在尝试在回收站视图中显示“保存的数据”，但它什么也没显示。在检查我的数据库表时，我发现没有保存任何内容。这是我的模型类：

@Entity(tableName = "sessions")
public class Sessions{

    //    @PrimaryKey(autoGenerate = true)
    //    public int id;

    @SerializedName("prg_session_image")
    public String sessionImage;

    @SerializedName("prg_session_name")
    public String session_name;

    @SerializedName("prg_session_id") // used session id as PK 
    @PrimaryKey
    @NonNull
    public String prog_sessionId;

    @SerializedName("prg_session_description")
    public String session_desc;

    @SerializedName("reference_id")
    public String reference_id;

    @SerializedName("prg_name")
    public String program_name;

    @SerializedName("batch_name")
    public String batch_name;

    @SerializedName("player_count")
    public String participants_count;

    @SerializedName("prg_session_focus_points")
    public String session_focus_points;

    @SerializedName("prg_session_equipment")
    public String equipments_reqd;

    @SerializedName("session_complete")
    public String is_complete;

    public Sessions() {
    }

     //    public int getId() {
     //        return id;
    //    }

    public String getSessionImage() {
        return sessionImage;
    }

    public void setSessionImage(String sessionImage) {
        this.sessionImage = sessionImage;
    }

    public String getSession_name() {
        return session_name;
    }

    public void setSession_name(String session_name) {
        this.session_name = session_name;
    }

    public String getProg_sessionId() {
        return prog_sessionId;
    }

    public void setProg_sessionId(String prog_sessionId) {
        this.prog_sessionId = prog_sessionId;
    }

    public String getSession_desc() {
        return session_desc;
    }

    public void setSession_desc(String session_desc) {
        this.session_desc = session_desc;
    }

    public String getReference_id() {
        return reference_id;
    }

    public void setReference_id(String reference_id) {
        this.reference_id = reference_id;
    }

    public String getProgram_name() {
        return program_name;
    }

    public void setProgram_name(String program_name) {
        this.program_name = program_name;
    }

    public String getBatch_name() {
        return batch_name;
    }

    public void setBatch_name(String batch_name) {
        this.batch_name = batch_name;
    }

    public String getParticipants_count() {
        return participants_count;
    }

    public void setParticipants_count(String participants_count) {
        this.participants_count = participants_count;
    }

    public String getSession_focus_points() {
        return session_focus_points;
    }

    public void setSession_focus_points(String session_focus_points) {
        this.session_focus_points = session_focus_points;
    }

    public String getEquipments_reqd() {
        return equipments_reqd;
    }

    public void setEquipments_reqd(String equipments_reqd) {
        this.equipments_reqd = equipments_reqd;
    }

    public String getIs_complete() {
        return is_complete;
    }

    public void setIs_complete(String is_complete) {
        this.is_complete = is_complete;
    }
    }

和道类：

    @Dao
    public interface SessionsDAO {

     //    @Insert
    //    LiveData<List<Sessions>> saveSessions(List<Sessions> sessions);

    @Insert
    void addSessions(List<Sessions> list);

    @Query("select * from sessions")
    LiveData<List<Sessions>> getAllSessions();

    @Query("select * from sessions where prog_sessionId = :id")
    Sessions getSessionById(String id);

    }

在存储库中，我使用 Dao 进行各种操作的异步任务：

    public class SessionsRepository {

    public SessionsDAO dao;
    private MutableLiveData<List<Sessions>> querySingleSession;
    private LiveData<List<Sessions>> allSessions;

    public SessionsRepository(Application application){
        SportsDatabase database = SportsDatabase.getInstance(application);
        dao = database.sessionsDAO();
        querySingleSession = new MutableLiveData<>();
        allSessions = dao.getAllSessions();
    }

    public void saveSessions(List<Sessions> sessions){
        new SaveSessionsTask(dao).execute(sessions);
    }

    public LiveData<List<Sessions>> getAllSessions() {
        return allSessions;
    }

    public void getSessionById(List<Sessions> sessions){
        querySingleSession.setValue(sessions);
    }

    public class SaveSessionsTask extends AsyncTask<List<Sessions>, Void, Void>{
        private SessionsDAO dao;

        public SaveSessionsTask(SessionsDAO dao) {
            this.dao = dao;
        }

        @Override
        protected Void doInBackground(List<Sessions>... lists) {
            dao.addSessions(lists[0]);
            return null;
        }
    }

    //    public void getSessions(){
    //        new GetSessionsTask(dao).execute();
    //    }
    //    public class GetSessionsTask extends AsyncTask<Void, >

    }

我目前正在尝试保存网络调用的所有结果并从数据库中显示它们。这是我在 viewmodel 类中的操作：

    public class HomeSessionsViewModel extends AndroidViewModel {

    private static final String TAG = HomeSessionsViewModel.class.getSimpleName();

    private MutableLiveData<SessionDetails> liveDetails;
    private SessionsRepository repository;

    public HomeSessionsViewModel(@NonNull Application application) {
        super(application);
        repository = new SessionsRepository(application);
    }

     //    public HomeSessionsViewModel (Application application){
     //        repository = new SessionsRepository(application);
     //    }

    public MutableLiveData<SessionDetails> getSessions(){
        if (liveDetails == null){
            liveDetails = new MutableLiveData<>();
            fetchSessions();
        }
        return liveDetails;
    }

    private void fetchSessions(){
        String coachId = "4086";

        Call<SessionDetails> call = RestClient.getRestInstance().getSessionsService().fetchSessions(coachId);

        call.enqueue(new Callback<SessionDetails>() {
            @Override
            public void onResponse(Call<SessionDetails> call, Response<SessionDetails> response) {
                if (response.isSuccessful()){
                    SessionDetails details = response.body();
                    List<Sessions> sessions = details.getSessions();
                    Log.d(TAG, "N/w sesh size:\t" + sessions.size());
                    liveDetails.setValue(details); // now just displaying from network
                    saveSessions(sessions);
                }
            }

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

            }
        });

    }

    private void saveSessions(List<Sessions> sessions) {
        repository.saveSessions(sessions);
    }

    public LiveData<List<Sessions>> fetchSessionsDB(){
        return repository.getAllSessions();
    }

    }

在 ui 控制器（片段）中，我调用了 viewmodel 的 fetchSessionsDB() 方法，但没有显示数据。网络请求运行良好，就像我在添加空间之前从那里显示的那样。这里有什么问题？谢谢。

API 响应：

{
             "session_details": [
                {
                    "prg_session_name": "Session-16",
                    "prg_session_id": "987",
                    "prg_session_equipment": null,
                    "prg_session_description": "",
                    "prg_session_focus_points": "",
                    "prg_session_image": "http://devsports.copycon.in/includes/uploads/Jellyfish5.jpg",
                    "session_complete": "0",
                    "prg_name": "cricket coaching",
                    "reference_id": "293",
                    "batch_id": "57",
                    "batch_name": "Batch 3",
                    "player_count": "10"
                }, .... ]}

和 SessionDetails POJO：

public class SessionDetails {

@SerializedName("session_details")
@Expose
private List<Sessions> sessions;

@SerializedName("status")
private String status;

@SerializedName("message")
private String msg;

public List<Sessions> getSessions() {
    return sessions;
}
}

应该显示db数据的片段类：

private void populateSessions() {
    sessionsRV = fragmentBinding.sessionsRV;
    sessionsRV.setHasFixedSize(false);
    LinearLayoutManager hlm = new LinearLayoutManager(getActivity(), LinearLayoutManager.HORIZONTAL, false);
    sessionsRV.setLayoutManager(hlm);

    sessionsViewModel = ViewModelProviders.of(this).get(HomeSessionsViewModel.class);
   //        sessionsViewModel.fetchSessions(""); // TODO: 3/16/2019 Use coach id from db

    // calling db from viewmodel
    sessionsViewModel.fetchSessionsDB().observe(this, new Observer<List<Sessions>>() {
        @Override
        public void onChanged(@Nullable List<Sessions> sessions) {
            sessionsAdapter = new SessionsAdapter(getActivity(), sessions);
            sessionsRV.setAdapter(sessionsAdapter);
            Log.d(TAG, "Sessions Count:\t" + sessionsAdapter.getItemCount()); // logs 0
        }
    });

    // previously from network directly displayed
    //        sessionsViewModel.getSessions().observe(this, new Observer<SessionDetails>() {
    //            @Override
    //            public void onChanged(@Nullable SessionDetails details) {
    //                List<Sessions> list = details.getSessions();
    //                sessionsAdapter = new SessionsAdapter(getActivity(), list);
   //                sessionsRV.setAdapter(sessionsAdapter);
  //                Log.d(TAG, "Sessions Count:\t" + sessionsAdapter.getItemCount());
 //            }
 //        });

}

运动数据库类：

@Database(entities = {CoachDB.class, Sessions.class}, version = 1, exportSchema = false)
public abstract class SportsDatabase extends RoomDatabase {

private static SportsDatabase instance;
public abstract CoachDAO coachDAO();
public abstract SessionsDAO sessionsDAO();

public static synchronized SportsDatabase getInstance(Context context) {
    if (instance == null){
        instance = Room.databaseBuilder(context.getApplicationContext(), SportsDatabase.class, "sports_db")
                .fallbackToDestructiveMigration()
                .build();
    }
    return instance;
}

}

【问题讨论】：

我建议你记录网络会话而不是直接尝试将它们保存到 Room，只是为了确保在任何数据库工作之前获取会话的过程是正确的。其次，单独测试您的 Room 数据库，最好通过测试放置一些虚拟会话值并执行所有会话存储库操作。这样，您将确保您的房间设置正确。测试室：developer.android.com/training/data-storage/room/testing-db
我已经从网络显示现在我想保存并从数据库显示。您在测试部分是对的，但是要填充的字段太多。再看看修改后的问题。谢谢
是的，我看到你有大量的属性和值需要处理，但是，你可以做到，我相信。如果您可以记录它们，则将它们转换为文本文件，然后将其复制为字符串以初始化测试的虚拟值。您必须测试您的房间，否则您将无法确定问题出在哪一部分，对吧？另一种方法可以是仅使用两到三个条目/行，如果需要仅使用几个属性，则仅用于测试。无论如何，我强烈建议您为 Room 构建测试，因为它对您的项目的未来维护和更改有几个好处。
好的，我会尝试预填充几行，但你能再看一下代码吗？谢谢
应该扩展 RoomDatabase 的 SportsDatabase 类在哪里？共享该类，它是使用实体构建数据库的主类。并确保它具有数据库注释，例如； @Database(entities = {Sessions.class}, 版本 = 1)

标签： android mvvm android-room android-livedata android-viewmodel

【解决方案1】：

我已经通过在 dao like 中修改 @insert 方法解决了这个问题

@Dao
public interface SessionsDAO {

@Insert
void addSessions(List<Sessions> sessions);

@Query("select * from sessions")
LiveData<List<Sessions>> getAllSessions();

@Query("select * from sessions where prog_sessionId = :id")
Sessions getSessionById(String id);

}

并使用会话列表作为输入运行我的异步任务，它成功运行。

private void saveSessions(List<Sessions> sessions) {
    new SaveSessionsTask(dao).execute(sessions);
}

public class SaveSessionsTask extends AsyncTask<List<Sessions>, Void, Void> {
    private SessionsDAO dao;

    public SaveSessionsTask(SessionsDAO dao) {
        this.dao = dao;
    }

    @Override
    protected Void doInBackground(List<Sessions>... lists) {
        dao.addSessions(lists[0]);
        return null;
    }
}

【讨论】：