Android Architecture Components: Room

Android Architecture Componentler arasında yer alan Room veritabanı kütüphanesini bu yazıda açıklamaya çalışacağım.

Room, SQLite ile yazdığımız kodları daha açık, anlaşılır ve daha az kodla yazarak database işlemlerini kolayca yapmamızı sağlayan bir kütüphanedir. Room bunun için soyut bir katman sağlar ve bunu annotationlar ile yapar.

Room çıkmadan önce Android geliştiriciler olarak zaten birçok farklı kütüphane kullanıyorduk. Bunlara en büyük örnek Realm, greenDAO, OrmLite kütüphaneleri. Peki bunlar varken neden Room kullanma ihtiyacı duyalım? Avantajları nelerdir?

Compile-time da SQL querylerinin doğrulanması. Yani siz bir query yazarken örneğin “SELECT * FRIM users” yazdınız. Burada FRIM kısmının hatalı olduğunu size compile-time’da bildirecektir. Ya da SQLite yazarken mutlaka karşılaşmışsınızdır; uzun queryler yazarken en ufak bir parantez ya da virgül hatası uygulamanın düzgün çalışmamasına neden olacaktır.
Az kod çok iş
Diğer Architecture Componentler ile (özellikle LiveData) birlikte çalışabilme

Nasıl kullanılır?

Öncelikle build.gradle dosyanıza alttaki gibi Google Maven repository ekliyoruz.

allprojects {
    repositories {
        jcenter()
        google()
    }
}

allprojects {

repositories {

jcenter()

google()

}

Sonrasında app/build.gradle dosyasına gerekli dependency leri ekliyoruz.

implementation 'android.arch.persistence.room:runtime:1.0.0'
annotationProcessor 'android.arch.persistence.room:compiler:1.0.0'

1 2	implementation 'android.arch.persistence.room:runtime:1.0.0' annotationProcessor 'android.arch.persistence.room:compiler:1.0.0'

Artık veritabanını oluşturmaya başlayabiliriz. Kullanıcı bilgilerini tutan bir veritabanı oluşturacağımızı varsayalım. Öncelikle oluşturacağımız her bir tablo için entityler oluşturmamız gerekiyor.

import android.arch.persistence.room.Entity;
import android.arch.persistence.room.PrimaryKey;
import android.support.annotation.NonNull;

@Entity
public class User {
    @PrimaryKey
    public final String id;
    public final String name;
    public final String profilePicture;

    public User(int id, String name, String profilePicture) {
        this.id = id;
        this.name = name;
        this.profilePicture = profilePicture;
    }
}

import android.arch.persistence.room.Entity;

import android.arch.persistence.room.PrimaryKey;

import android.support.annotation.NonNull;

@Entity

public class User {

@PrimaryKey

public final String id;

public final String name;

public final String profilePicture;

public User(int id, String name, String profilePicture) {

this.id = id;

this.name = name;

this.profilePicture = profilePicture;

}

Burada @Entity annotation ile bu classın bir entity yani veritabanı için bir tablo olacağını belirttik. Entity içerisinde en az bir tane PrimaryKey alanı bulunmalı. Bunu da @PrimaryKey annotation ile belirtiyoruz.

Burada 1 tane entity class yazdık. Eğer projede birden fazla tablo yer alacaksa o kadar sayıda entity yazmamız gerekecekti.

Daha sonra yazdığımız entity classları için DAO (Data Access Object) arayüzü oluşturuyoruz. Burada aslında veritabanımıza neyi nasıl yapacağımızı arayüze yazdığımız metodlarla bildiriyoruz.

import android.arch.persistence.room.Dao;
import android.arch.persistence.room.Delete;
import android.arch.persistence.room.Insert;
import android.arch.persistence.room.Query;
import android.arch.persistence.room.Update;
import java.util.List;

@Dao
public interface UserDao {

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

    @Insert
    void insert(User... users);

    @Update
    void update(User... users);

    @Delete
    void delete(User... users);
}

import android.arch.persistence.room.Dao;

import android.arch.persistence.room.Delete;

import android.arch.persistence.room.Insert;

import android.arch.persistence.room.Query;

import android.arch.persistence.room.Update;

import java.util.List;

@Dao

public interface UserDao {

@Query("SELECT * FROM user")

List<User> getAllUsers();

@Insert

void insert(User... users);

@Update

void update(User... users);

@Delete

void delete(User... users);

}

Gördüğünüz gibi normalde query olarak yazdığımız Insert, Update, Delete gibi işlemleri @Insert, @Update, @Delete annotationları ile yaptık. Bu işlemlerin dışında eğer özel queryler yazmak istersek @Query ile bu işlemi yapabiliriz. Örneğin; where sorgusu ile id değeri alan, limit değeri verebileceğimiz queryleri alttaki gibi yazabiliriz.

@Query("SELECT * FROM user WHERE name=:name")
List<User> getUsersByName(String name);

@Query("SELECT * FROM user WHERE name=:name LIMIT :lim")
List<User> getUsersByName(int lim, String... name);

@Query("SELECT * FROM user WHERE name=:name")

List<User> getUsersByName(String name);

@Query("SELECT * FROM user WHERE name=:name LIMIT :lim")

List<User> getUsersByName(int lim, String... name);

Bundan sonraki adımımız database classı oluşturmak.

import android.arch.persistence.room.Database;
import android.arch.persistence.room.Room;
import android.arch.persistence.room.RoomDatabase;
import android.content.Context;
import android.support.annotation.NonNull;

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

    private static final String DB_NAME = "userDatabase.db";
    private static volatile UserDatabase instance;

    static synchronized UserDatabase getInstance(Context context) {
        if (instance == null) {
            instance = create(context);
        }
        return instance;
    }

    private static UserDatabase create(final Context context) {
        return Room.databaseBuilder(
            context,
            UserDatabase.class,
            DB_NAME).build();
    }

    public abstract UserDao userDao();
}

import android.arch.persistence.room.Database;

import android.arch.persistence.room.Room;

import android.arch.persistence.room.RoomDatabase;

import android.content.Context;

import android.support.annotation.NonNull;

@Database(entities = { User.class }, version = 1)

public abstract class UserDatabase extends RoomDatabase {

private static final String DB_NAME = "userDatabase.db";

private static volatile UserDatabase instance;

static synchronized UserDatabase getInstance(Context context) {

if (instance == null) {

instance = create(context);

}

return instance;

}

private static UserDatabase create(final Context context) {

return Room.databaseBuilder(

context,

UserDatabase.class,

DB_NAME).build();

}

public abstract UserDao userDao();

}

Gördüğünüz gibi RoomDatabase classından extend ettiğimiz abstract classın en üstünde @Database annotation ile bu classı işaretledik ve entityleri, database versiyonu buraya yazdık. getInstance() metodu ile singleton design pattern kullanarak veritabanından bir örnek oluşturduk. (RoomDatabase classından her seferinde yeni nesne oluşturmak oldukça maliyetli bir işlem olduğu için burada singleton pattern kullanmanız yararınıza olacaktır.) En altta ise yazdığımız Dao interfaceni abstact metod olarak yazdık.

Evet artık hazırız. Gerekli classları yazdık. Son aşama olarak oluşturduğumuz veritabanını nerede kullanacaksak onu orada çağırmamız gerekiyor.

Örneğin yeni bir kullanıcı eklenecekse;

UserDatabase
        .getInstance(context)
        .getUserDao()
        .insert(new User(1, "Emre Köse", "pp url"));

UserDatabase

.getInstance(context)

.getUserDao()

.insert(new User(1, "Emre Köse", "pp url"));

ya da var olan kullanıcılar bir listeye alınacaksa;

List<User> allUsers = UserDatabase
        .getInstance(MainActivity.this)
        .getUserDao()
        .getAllUsers();

List<User> allUsers = UserDatabase

.getInstance(MainActivity.this)

.getUserDao()

.getAllUsers();

ÖNEMLİ NOT: Veritabanı işlemleri için mutlaka background thread kullanmalısınız. Bunun için AsyncTask, Handler, RxJava kullanabilirsiniz. Aksi halde uygulamanız crash olacaktır.

Nasıl kullanılır?

Bir cevap yazın Cevabı iptal et