java Android ROOM如何编写包含多个实体的查询，这是在哪里完成的？

Question

我第一次使用room persistence library，我正在尝试构建一个家庭锻炼跟踪器应用程序

Entity Relations Diagram of Database

基本上，我需要运行一个查询，返回：

1. exercise_Name (from exercises entity)
2. number_Of_Sets (from workout_goals entity)
3. min_Reps (from workout_goals entity)
4. max_reps (from workout_goals entity)

对于连接表中的每一行

I would then like to display this in a custom list view.

(So far I have only worked out how to display values stored in the junction table)

如何运行从多个不同的相关实体返回变量值的查询

练习实体

@Entity
@Entity(tableName = "exercises_table")
public class Exercises {

    @PrimaryKey(autoGenerate = true)
    int exercises_id;

    private String exercise_name;

    @ForeignKey(entity = ExerciseType.class, parentColumns = "exercise_type_id", childColumns = "exercise_type_id")
    private int exercise_type_id;

    @ForeignKey(entity = ExerciseEquipment.class, parentColumns = "exercise_equipment_id", childColumns = "exercise_equipment_id")
    private int exercise_equipment_id;



    public Exercises(String exercise_name, int exercise_type_id, int exercise_equipment_id ) {
        this.exercise_name = exercise_name;
        this.exercise_type_id = exercise_type_id;
        this.exercise_equipment_id = exercise_equipment_id;
    }

    public int getExercise_equipment_id() {
        return exercise_equipment_id;
    }

    public void setExercises_id(int exercise_equipment_id) {
        this.exercises_id = exercises_id;
    }

    public int getExercises_id() {
        return exercises_id;
    }

    public String getExercise_name() {
        return exercise_name;
    }

    public int getExercise_type_id() {
        return exercise_type_id;
    }
}

连接实体

@Entity
@Entity(tableName = "exercise_workout_junction_table")
public class Junction {

    @PrimaryKey(autoGenerate = true)
    private int exercise_workout_id;

    @ForeignKey(entity = Exercises.class, parentColumns = "exercises_id", childColumns = "exercise_id")
    int exercise_id;

    @ForeignKey(entity = Workouts.class, parentColumns = "workout_id", childColumns = "workout_id")
    private int workout_id;

    public Junction(int exercise_id, int workout_id) {
        this.exercise_id = exercise_id;
        this.workout_id = workout_id;
    }

    public void setExercise_workout_id(int exercise_workout_id) {
        this.exercise_workout_id = exercise_workout_id;
    }

    public int getExercise_workout_id() {
        return exercise_workout_id;
    }

    public int getExercise_id() {
        return exercise_id;
    }

    public int getWorkout_id() {
        return workout_id;
    }
}

锻炼目标实体

@Entity
@Entity(tableName = "exercise_workout_goals_table")
public class Exercise_Workout_Goals {

    @PrimaryKey(autoGenerate = true)
    private int exercise_workout_goal_id;

    @ForeignKey(entity = Junction.class, parentColumns = "exercise_workout_id", childColumns = "junction_id")
    private int junction_id;

    private int set_number;
    private int min_reps;
    private int max_reps;



    public Exercise_Workout_Goals(int junction_id, int set_number, int min_reps, int max_reps ) {
        this.junction_id = junction_id;
        this.set_number = set_number;
        this.min_reps = min_reps;
        this.max_reps = max_reps;
    }

    public int getExercise_workout_goal_id() {
        return exercise_workout_goal_id;
    }

    public void setExercise_workout_goal_id(int exercise_workout_goal_id) {
        this.exercise_workout_goal_id = exercise_workout_goal_id;
    }

    public int getJunction_id() {
        return junction_id;
    }

    public int getSet_number() {
        return set_number;
    }

    public int getMin_reps() {
        return min_reps;
    }

    public int getMax_reps() {
        return max_reps;
    }
}

联合存储库

public class JunctionRepository {
    private JunctionDao junctionDao;
    private LiveData<List<Junction>> allJunctionExercises;


    public JunctionRepository(Application application){
        ExerciseDatabase database = ExerciseDatabase.getInstance(application);
        junctionDao = database.junctionDao();
        allJunctionExercises = junctionDao.getAllFromJunction();
    }

    public void insert(Junction junction ){
        new InsertExerciseAsyncTask(junctionDao).execute(junction);
    }
    public void update(Junction junction){
        new UpdateExerciseAsyncTask(junctionDao).execute(junction);
    }
    public void delete(Junction junction){
        new DeleteExerciseAsyncTask(junctionDao).execute(junction);
    }
    public void deleteAllExercises() {
        new DeleteAllExerciseAsyncTask(junctionDao).execute();
    }



    public LiveData<List<Junction>> getAllExercises(){
        return allJunctionExercises;
    }




    private static class  InsertExerciseAsyncTask extends AsyncTask<Junction, Void, Void> {
        private JunctionDao junctionDao;
        private InsertExerciseAsyncTask( JunctionDao junctionDao){
            this.junctionDao = junctionDao;
        }

        @Override
        protected Void doInBackground(Junction... exercises) {


            junctionDao.insert(exercises[0]);
            return null;
        }
    }


    private static class  UpdateExerciseAsyncTask extends AsyncTask<Junction, Void, Void> {
        private JunctionDao junctionDao;
        private UpdateExerciseAsyncTask( JunctionDao junctionDao){
            this.junctionDao = junctionDao;
        }

        @Override
        protected Void doInBackground(Junction... exercises) {


            junctionDao.update(exercises[0]);
            return null;
        }
    }


    private static class  DeleteExerciseAsyncTask extends AsyncTask<Junction, Void, Void> {
        private JunctionDao junctionDao;
        private DeleteExerciseAsyncTask( JunctionDao junctionDao){
            this.junctionDao = junctionDao;
        }

        @Override
        protected Void doInBackground(Junction... exercises) {


            junctionDao.delete(exercises[0]);
            return null;
        }
    }


    private static class  DeleteAllExerciseAsyncTask extends AsyncTask<Junction, Void, Void> {
        private JunctionDao junctionDao;
        private DeleteAllExerciseAsyncTask( JunctionDao junctionDao){
            this.junctionDao = junctionDao;
        }

        @Override
        protected Void doInBackground(Junction... exercises) {
            args

            junctionDao.deleteAllExercises();
            return null;
        }
    }
}

数据库

                      Exercises.class, ExerciseType.class, Workouts.class, WorkoutType.class}, version = 4, exportSchema = false)

public abstract class ExerciseDatabase extends RoomDatabase {

    private static ExerciseDatabase instance;

    public abstract JunctionDao junctionDao();
    public abstract ExerciseEquipmentDao exerciseEquipmentDao();
    public abstract WorkoutTypeDao workoutTypeDao();
    public abstract ExercisesDao exercisesDao();
    public abstract WorkoutsDao workoutsDao();
    public abstract ExerciseWorkoutGoalsDao exerciseWorkoutGoalsDao();
    public abstract ExerciseTypeDao exerciseTypeDao();



    public static synchronized ExerciseDatabase getInstance(Context context){

        if(instance == null){

            instance = Room.databaseBuilder(context.getApplicationContext(),
                    ExerciseDatabase.class, "exercise_database")

                    .fallbackToDestructiveMigration()
                    //this adds the pre-populated database values
                    .addCallback(roomCallback)
                    .build();

        }
        return instance;
    }

    private static RoomDatabase.Callback roomCallback = new RoomDatabase.Callback(){
        @Override
        public void onCreate(@NonNull SupportSQLiteDatabase db) {
            super.onCreate(db);
            new PopulateDbAsyncTask(instance).execute();
        }
    };

    private static class PopulateDbAsyncTask extends AsyncTask<Void,Void,Void> {
        private JunctionDao junctionDao;





        private PopulateDbAsyncTask(ExerciseDatabase db){
            junctionDao = db.junctionDao();
        }

        @Override
        protected Void doInBackground(Void... voids) {
            junctionDao.insert(new Junction(1,1));
            junctionDao.insert(new Junction(2,1));
            junctionDao.insert(new Junction(3,1));
            junctionDao.insert(new Junction(4,1));
            junctionDao.insert(new Junction(5,1));
            junctionDao.insert(new Junction(6,1));
            junctionDao.insert(new Junction(7,1));
            junctionDao.insert(new Junction(8,1));

            junctionDao.insert(new Junction(11,2));
            junctionDao.insert(new Junction(9,2));
            junctionDao.insert(new Junction(1,2));
            junctionDao.insert(new Junction(2,2));
            junctionDao.insert(new Junction(12,2));
            junctionDao.insert(new Junction(13,2));
            junctionDao.insert(new Junction(15,2));
            junctionDao.insert(new Junction(16,2));

            junctionDao.insert(new Junction(9,3));
            junctionDao.insert(new Junction(2,3));
            junctionDao.insert(new Junction(1,3));
            junctionDao.insert(new Junction(5,3));
            junctionDao.insert(new Junction(10,3));
            junctionDao.insert(new Junction(6,3));
            junctionDao.insert(new Junction(7,3));
            junctionDao.insert(new Junction(8,3));

            junctionDao.insert(new Junction(2,4));
            junctionDao.insert(new Junction(1,4));
            junctionDao.insert(new Junction(11,4));
            junctionDao.insert(new Junction(3,4));
            junctionDao.insert(new Junction(12,4));
            junctionDao.insert(new Junction(13,4));
            junctionDao.insert(new Junction(14,4));
            junctionDao.insert(new Junction(15,4));
            junctionDao.insert(new Junction(16,4));
            return null;
        }
    }
}

连接适配器

    private List<Junction> junctions = new ArrayList<>();

    @NonNull
    @Override
    public JunctionHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.exercise_item,parent,false);
        return new JunctionHolder(itemView);
    }

    // This is where we take care of getting the data for the single exercise java objects
    @Override
    public void onBindViewHolder(@NonNull JunctionHolder holder, int position) {
        //
        //
        //
        Junction currentExercise = junctions.get(position);
        holder.textViewewID.setText(String.valueOf(currentExercise.getExercise_workout_id()));
        holder.textViewexerciseID.setText(String.valueOf(currentExercise.getExercise_id()));
        holder.textViewworkoutID.setText(String.valueOf(currentExercise.getWorkout_id()));

    }

    @Override
    public int getItemCount() {
        return junctions.size();
    }


    public void setExercises(List<Junction> exercises){
        this.junctions = exercises;
        notifyDataSetChanged();
    }

    class JunctionHolder extends RecyclerView.ViewHolder{
        private TextView textViewewID;
        private TextView textViewexerciseID;
        private TextView textViewworkoutID;

        public JunctionHolder(@NonNull View itemView) {
            super(itemView);
            textViewewID = itemView.findViewById(R.id.text_view_weID);
            textViewexerciseID = itemView.findViewById(R.id.text_view_exerciseID);
            textViewworkoutID = itemView.findViewById(R.id.text_view_workoutID);
        }
    }
}

主要活动

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        RecyclerView recyclerView = findViewById(R.id.recycler_view);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));
        recyclerView.setHasFixedSize(true);

        final JunctionAdapter adapter = new JunctionAdapter();
        recyclerView.setAdapter(adapter);

        junctionViewModel = ViewModelProviders.of(this).get(JunctionViewModel.class);
        junctionViewModel.getAllExercises().observe(this, new Observer<List<Junction>>() {
            @Override
            public void onChanged(List<Junction> junctions) {
                adapter.setExercises(junctions);
            }
        });
    }
}

查看模型

    public JunctionViewModel(@NonNull Application application) {
        super(application);
        repository = new JunctionRepository(application);
        allExercises = repository.getAllExercises();
    }

    public void insert(Junction junction){
        repository.insert(junction);

    }
    public void update(Junction junction){
        repository.update(junction);
    }
    public void delete(Junction junction){
        repository.delete(junction);
    }
    public void deleteAllExercises(){
        repository.deleteAllExercises();
    }

    public LiveData<List<Junction>> getAllExercises() {
        return allExercises;
    }


}