Implementing the Room Database (Android)

Question

I like to know how to properly integrate the Room Library within an Android Application. Some articles I have seen uses a Singleton approach using a Respository for database calls, while other uses some form of Dependecy Injection (Dagger 2). I like to know the proper integration of this library?

Thanks

Answer 1

Room Basics

The Room library acts as an abstract layer for underlying SQLite database. Thus, Room annotations are used:

1. To Database and Entities where entities are POJO classes representing table structures.
2. To specify operation for retrieval, updation and deletion.
3. To add constraints, such as foreign keys.
4. Support for LiveData.

There are 3 major components in Room

1. Entity : A class annotated with the @Entity annotation is mapped to a table in database. Every entity is persisted in its own table and every field in class represents the column name.

tableName attribute is used to define the name of the table Every entity class must have at-least one Primary Key field, annotated with @PrimaryKey Fields in entity class can be annotated with @ColumnInfo(name = “name_of_column”) annotation to give specific column names

2. DAO : Data Access Object is either be an interface or an abstract class annotated with @Doa annotation, containing all the methods to define the operations to be performed on data. The methods can be annotated with

@Query to retrieve data from database

@Insert to insert data into database

@Delete to delete data from database

@Update to update data in database

3. Database : Database is a container for tables. An abstract class annotated with @Database annotation is used to create a database with given name along with database version.

Add these dependencies :

    dependencies {
    // Room dependencies
      compile 'android.arch.persistence.room:runtime:1.0.0'
      annotationProcessor 'android.arch.persistence.room:compiler:1.0.0'
    }

Create Entity

Before creating a database, Let's create an Entity, named as Note and later, Objects of this class will be added to database.

    @Entity
public class Note {

    @PrimaryKey(autoGenerate = true)
    private int note_id;

    @ColumnInfo(name = "note_content") // column name will be "note_content" instead of "content" in table
    private String content;

    private String title;

    private

    public Note(int note_id, String content, String title) {
        this.note_id = note_id;
        this.content = content;
        this.title = title;
    }

    public int getNote_id() {
        return note_id;
    }

    public void setNote_id(int note_id) {
        this.note_id = note_id;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Note)) return false;

        Note note = (Note) o;

        if (note_id != note.note_id) return false;
        return title != null ? title.equals(note.title) : note.title == null;
    }



    @Override
    public int hashCode() {
        int result = note_id;
        result = 31 * result + (title != null ? title.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "Note{" +
                "note_id=" + note_id +
                ", content='" + content + '\'' +
                ", title='" + title + '\'' +
                '}';
    }}

Creating DAOs

DAOs define all methods to access database, annotated with @Dao annotation. The DAO acts as a contract to perform CRUD operations on data within a database.

    @Dao
public interface NoteDao {
  @Query("SELECT * FROM user "+ Constants.TABLE_NAME_NOTE)
  List<Note> getAll();


  /*
  * Insert the object in database
  * @param note, object to be inserted
  */
  @Insert
  void insert(Note note);

  /*
  * update the object in database
  * @param note, object to be updated
  */
  @Update
  void update(Note repos);

  /*
  * delete the object from database
  * @param note, object to be deleted
  */
  @Delete
  void delete(Note note);

  /*
  * delete list of objects from database
  * @param note, array of objects to be deleted
  */
  @Delete
  void delete(Note... note);      // Note... is varargs, here note is an array

}

Create Database

Now, we have table defined as Entity and CRUD methods defined via NoteDao. The last piece of the database puzzle is the database itself.

@Database(entities = { Note.class }, version = 1)
public abstract class NoteDatabase extends RoomDatabase {

public abstract NoteDao getNoteDao();

private static NoteDatabase noteDB;

public static NoteDatabase getInstance(Context context) {
if (null == noteDB) {
noteDB = buildDatabaseInstance(context);
}
return noteDB;
}

private static NoteDatabase buildDatabaseInstance(Context context) {
return Room.databaseBuilder(context,
NoteDatabase.class,
Constants.DB_NAME)
.allowMainThreadQueries().build();
}

public void cleanUp(){
noteDB = null;
}

}

Implement Database Interactions

The below snippet will demonstrate the working of insert, update, and delete functionality using the Room database.

public class AddNoteActivity extends AppCompatActivity {

private TextInputEditText et_title,et_content;
private NoteDatabase noteDatabase;
private Note note;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_add_note);
et_title = findViewById(R.id.et_title);
et_content = findViewById(R.id.et_content);
noteDatabase = NoteDatabase.getInstance(AddNoteActivity.this);
Button button = findViewById(R.id.but_save);

      button.setOnClickListener(new View.OnClickListener() {
          @Override
          public void onClick(View view) {
            // fetch data and create note object
                note = new Note(et_content.getText().toString(),
                        et_title.getText().toString());

                // create worker thread to insert data into database
                new InsertTask(AddNoteActivity.this,note).execute();
          }
      });

}

private void setResult(Note note, int flag){
setResult(flag,new Intent().putExtra("note",note));
finish();
}

private static class InsertTask extends AsyncTask<Void,Void,Boolean> {

      private WeakReference<AddNoteActivity> activityReference;
      private Note note;

      // only retain a weak reference to the activity
      InsertTask(AddNoteActivity context, Note note) {
          activityReference = new WeakReference<>(context);
          this.note = note;
      }

      // doInBackground methods runs on a worker thread
      @Override
      protected Boolean doInBackground(Void... objs) {
          activityReference.get().noteDatabase.getNoteDao().insertNote(note);
          return true;
      }

        // onPostExecute runs on main thread
      @Override
      protected void onPostExecute(Boolean bool) {
          if (bool){
              activityReference.get().setResult(note,1);
          }
      }

}

}

Retrieve And Display NoteList

public class NoteListActivity extends AppCompatActivity implements NotesAdapter.OnNoteItemClick{

private TextView textViewMsg;
private RecyclerView recyclerView;
private NoteDatabase noteDatabase;
private List<Note> notes;
private NotesAdapter notesAdapter;
private int pos;

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

private void displayList(){
// initialize database instance
noteDatabase = NoteDatabase.getInstance(NoteListActivity.this);
// fetch list of notes in background thread
new RetrieveTask(this).execute();
}

private static class RetrieveTask extends AsyncTask<Void,Void,List<Note>>{

      private WeakReference<NoteListActivity> activityReference;

      // only retain a weak reference to the activity
      RetrieveTask(NoteListActivity context) {
          activityReference = new WeakReference<>(context);
      }

      @Override
      protected List<Note> doInBackground(Void... voids) {
          if (activityReference.get()!=null)
              return activityReference.get().noteDatabase.getNoteDao().getNotes();
          else
              return null;
      }

      @Override
      protected void onPostExecute(List<Note> notes) {
          if (notes!=null && notes.size()>0 ){
              activityReference.get().notes = notes;

              // hides empty text view
              activityReference.get().textViewMsg.setVisibility(View.GONE);

              // create and set the adapter on RecyclerView instance to display list
              activityReference.get().notesAdapter = new NotesAdapter(notes,activityReference.get());
              activityReference.get().recyclerView.setAdapter(activityReference.get().notesAdapter);
          }
      }

}

private void initializeVies(){
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
textViewMsg = (TextView) findViewById(R.id.tv\_\_empty);

      // Action button to add note
      FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
      fab.setOnClickListener(listener);
      recyclerView = findViewById(R.id.recycler_view);
      recyclerView.setLayoutManager(new LinearLayoutManager(NoteListActivity.this));

}

}

Update Note

public class AddNoteActivity extends AppCompatActivity {

    private TextInputEditText et_title,et_content;
    private NoteDatabase noteDatabase;
    private Note note;
    private boolean update;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_add_note);
        et_title = findViewById(R.id.et_title);
        et_content = findViewById(R.id.et_content);
        noteDatabase = NoteDatabase.getInstance(AddNoteActivity.this);
        Button button = findViewById(R.id.but_save);
        if ( (note = (Note) getIntent().getSerializableExtra("note"))!=null ){
            getSupportActionBar().setTitle("Update Note");
            update = true;
            button.setText("Update");
            et_title.setText(note.getTitle());
            et_content.setText(note.getContent());
        }

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
            note.setContent(et_content.getText().toString());
            note.setTitle(et_title.getText().toString());
            noteDatabase.getNoteDao().updateNote(note);
            }
        });
    }

}

Delete Note

noteDatabase.getNoteDao().deleteNote(notes.get(pos));
adapterObj.notifyDataSetChanged();

Answer 2

咨询官方文档怎么样。

Answer 3

ROOM Database

• Room is an ORM (Object Relational Mapper) for SQLite database in Android developement and part of Android Jetpack.
• Provides an abstraction layer over SQLite database
• Amount of boilerplate code is reduced
• Compile-time verification of SQL queries

ROOM Database components

• It has 3 main components Entity, Database, DAO.
• Entity is data class annotated with @Entity is like creating a table in SQLite and the variables in the model class are like columns in the table.
• Database is an abstract class which extends RoomDatabase and has list of entities associated with the database.
• DAO(Data Access Object) is an interface which defines the operations to be performed in our database.

ROOM Database Implementation

• Step 1 creating Entity data class

  @Entity(tableName = "yourOwnTableName")

  data class LocalData(

   val column1: String?, val column2: String?, @PrimaryKey(autoGenerate = true) val product_local_id: Int?= null

  )

• Step 2 creating Database

  @Database(entities = [LocalData::class], version = 1, exportSchema = false) @TypeConverters

  abstract class LocalDB : RoomDatabase() {

   abstract fun localDataDao() : LocalDataDAO companion object{ private var instance : LocalDB ? = null fun getInstance(context: Context) : LocalDB ?{ if(instance == null){ synchronized(LocalDB ::class){ instance = Room.databaseBuilder(context.applicationContext, LocalDB::class.java, "localBD.db").allowMainThreadQueries().build() } } return instance } fun destroyInstance(){ instance = null } }

  }

• Step 3 creating DAO

  @Dao interface LocalDAO {

   @Insert fun insertData(productEntity: LocalData) : Long @Delete fun deleteData(productEntity: LocalData) : Int @Query("Select * from yourOwnTableName") fun showAllProducts(): List<LocalData> @Query("SELECT COUNT(*) FROM yourOwnTableName") fun totalProducts(): Long

  }

• Step 4 is optional is creating repository

class ProductRepository(context: Context) {

var dbms : LocalDAO = LocalDB.getInstance(context)?.localDataDao()!!

fun insertData(productEntity: LocalData) : Long{
    return dbms.insertData(productEntity)
}

fun deleteData(productEntity: LocalData) : Int{
    return dbms.deleteData(productEntity)
}

fun getAllData() : List<LocalData> {
    return dbms.showAllProducts()
}

fun checkProductExist(id : Int) : Boolean{
    return dbms.exists(id)
}

fun totalProductsInCart() : Long{
    return dbms.totalProducts()
}

}

Answer 4

step1 add the dependency in your build.gradle

def room_version = "2.2.5"

//better to replace new version
implementation "android.arch.lifecycle:extensions:1.1.0"
implementation "androidx.room:room-runtime:$room_version"
implementation "androidx.room:room-rxjava2:$room_version"
implementation "androidx.room:room-guava:$room_version"

// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel:2.3.1"
// LiveData
implementation "androidx.lifecycle:lifecycle-livedata:2.3.1"


annotationProcessor "androidx.room:room-compiler:$room_version"
testImplementation "androidx.room:room-testing:$room_version"

Answer 5

I think the best place is codelabs, it has a simple implementation, as well as a more complex one. All using Room.

Edit: Above links seems to be removed. Here are a couple of resources to replace that:

1. Android room with a view
2. Room + LiveData + ViewModel