Room Database for Data Storage in Android Apps

In Android app development, data storage is a critical component. Following our previous discussion on file-based storage, this chapter focuses on the Room database, an official Android persistence library that simplifies SQLite usage—making data storage and management more accessible for developers.

Overview of Room

Room is part of the Android Architecture Components, providing an abstraction layer over SQLite to make database interactions simpler and more intuitive. With Room, you can perform database operations using Object-Relational Mapping (ORM), eliminating the need to write complex raw SQL statements manually.

Advantages of Room

• Simplified Database Operations: Automatically generates SQLite query code—no manual SQL writing required.
• Support for Schema Migration: Manages changes to data models via annotated versioning.
• Compile-Time Query Validation & Type Safety: Catches errors at compile time, reducing runtime failures.

Steps to Create a Room Database

Creating a Room database involves three core steps:

1. Define an Entity
2. Create a Data Access Object (DAO)
3. Build the Database

1. Defining an Entity

An entity represents a table in the database. You define it using the @Entity annotation.

import androidx.room.Entity;
import androidx.room.PrimaryKey;

@Entity(tableName = "user")
public class User {
    @PrimaryKey(autoGenerate = true)
    private int id;
    private String name;
    private String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
}

2. Creating a Data Access Object (DAO)

A DAO defines the interface for database operations. Annotated with @Dao, it declares SQL query methods inside an interface.

import androidx.room.Dao;
import androidx.room.Insert;
import androidx.room.Query;

import java.util.List;

@Dao
public interface UserDao {
    @Insert
    void insert(User user);

    @Query("SELECT * FROM user")
    List<User> getAllUsers();
}

3. Building the Database

Finally, define a database class using the @Database annotation—specifying associated entities and database version.

import androidx.room.Database;
import androidx.room.Room;
import androidx.room.RoomDatabase;
import android.content.Context;

@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();

    private static volatile AppDatabase INSTANCE;

    public static AppDatabase getDatabase(final Context context) {
        if (INSTANCE == null) {
            synchronized (AppDatabase.class) {
                if (INSTANCE == null) {
                    INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                            AppDatabase.class, "app_database")
                            .build();
                }
            }
        }
        return INSTANCE;
    }
}

Using the Room Database

Using Room typically involves initializing the database, inserting data, and querying data. The example below demonstrates integration within an Activity.

Example: Using Room in MainActivity

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProvider;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private UserViewModel userViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        userViewModel = new ViewModelProvider(this).get(UserViewModel.class);

        // Insert user data
        userViewModel.insert(new User("Zhang San", "zhangsan@example.com"));

        // Query and observe user data
        userViewModel.getAllUsers().observe(this, new Observer<List<User>>() {
            @Override
            public void onChanged(List<User> users) {
                // Update UI display
                for (User user : users) {
                    System.out.println(user.getName());
                }
            }
        });
    }
}

In this example, the UserViewModel decouples Room logic from UI components—ensuring data persistence and real-time updates.

Implementation of UserViewModel

import androidx.lifecycle.LiveData;
import androidx.lifecycle.ViewModel;
import java.util.List;

public class UserViewModel extends ViewModel {
    private UserDao userDao;
    private LiveData<List<User>> allUsers;

    public UserViewModel(Application application) {
        AppDatabase db = AppDatabase.getDatabase(application);
        userDao = db.userDao();
        allUsers = userDao.getAllUsers();
    }

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

    void insert(User user) {
        userDao.insert(user);
    }
}

Summary

This chapter introduced how to use the Room database for persistent data storage, covering its fundamental concepts, step-by-step setup, and practical usage patterns—including data insertion and querying. Room significantly streamlines database integration, boosting developer productivity and code reliability.

In the next chapter, we’ll explore Network Access via HTTP Requests, learning how to fetch and persist data over the network.