[Android][數據庫][room] room的使用

引入依賴

build.gradle文件中引入依賴

def room_version = "1.1.1"
implementation "android.arch.persistence.room:runtime:$room_version"
annotationProcessor "android.arch.persistence.room:compiler:$room_version" // use kapt for Kotlin
// optional - RxJava support for Room
implementation "android.arch.persistence.room:rxjava2:$room_version"
// optional - Guava support for Room, including Optional and ListenableFuture
implementation "android.arch.persistence.room:guava:$room_version"
// Test helpers
testImplementation "android.arch.persistence.room:testing:$room_version"

 

定義實體

package com.szyh.cache.db.entity;

import androidx.room.ColumnInfo;
import androidx.room.Entity;
import androidx.room.Ignore;
import androidx.room.PrimaryKey;

@Entity(tableName = "user", indices = {})
public class User {

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "uid")
    private int uid;

    @ColumnInfo(name = "first_name")
    private String firstName;

    @ColumnInfo(name = "last_name")
    private String lastName;

    @ColumnInfo(name = "age")
    private int age;
    // Getters and setters are ignored for brevity,
    // but they're required for Room to work.

    public User() {
    }

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    @Ignore
    public User(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Ignore
    public User(int uid) {
        this.uid = uid;
    }

    @Ignore
    public User(int uid, String firstName, String lastName) {
        this.uid = uid;
        this.firstName = firstName;
        this.lastName = lastName;
    }
    @Ignore
    public User(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    @Ignore
    public User(int uid, String firstName, String lastName, int age) {
        this.uid = uid;
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

}

定義Dao

package com.szyh.cache.db.dao;

import com.szyh.cache.db.entity.User;
import java.util.List;

import androidx.room.Dao;
import androidx.room.Delete;
import androidx.room.Insert;
import androidx.room.OnConflictStrategy;
import androidx.room.Query;
import androidx.room.Update;

//註解配置sql語句
@Dao
public interface UserDao {
    //所有的CURD根據primary key進行匹配
    // ------------------------query------------------------
    // 簡單sql語句，查詢user表所有的column
    @Query("SELECT * FROM user")
    List<User> getAll();

    //根據條件查詢，方法參數和註解的sql語句參數一一對應
    @Query("SELECT * FROM user WHERE uid IN (:userIds)")
    List<User> loadAllByIds(int[] userIds);

    //同上
    @Query("SELECT * FROM user WHERE first_name LIKE :first AND "
            + "last_name LIKE :last LIMIT 1")
    User findByName(String first, String last);

    //同上
    @Query("SELECT * FROM user WHERE uid = :uid")
    User findByUid(int uid);

    //-----------------------insert----------------------
    // OnConflictStrategy.REPLACE表示如果已經有數據，那麼就覆蓋掉
    // 數據的判斷通過主鍵進行匹配，也就是uid，非整個user對象
    // 返回Long數據表示，插入條目的主鍵值（uid）
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    Long insert(User user);

    //返回List<Long>數據表示被插入數據的主鍵uid列表
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    List<Long> insertAll(User... users);
    //返回List<Long>數據表示被插入數據的主鍵uid列表
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    List<Long> insertAll(List<User> users);

    //---------------------update------------------------
    // 更新已有數據，根據主鍵（uid）匹配，而非整個user對象
    // 返回類型int代表更新的條目數目，而非主鍵uid的值。
    // 表示更新了多少條目
    @Update()
    int update(User user);
    //同上
    @Update()
    int updateAll(User... user);
    //同上
    @Update()
    int updateAll(List<User> user);

    //-------------------delete-------------------
    // 刪除user數據，數據的匹配通過主鍵uid實現。
    // 返回int數據表示刪除了多少條。非主鍵uid值。
    @Delete
    int delete(User user);
    //同上
    @Delete
    int deleteAll(List<User> users);
    //同上
    @Delete
    int deleteAll(User... users);
}

定義數據庫

package com.szyh.cache.db.Database;


import com.szyh.cache.db.dao.InteriorDao;
import com.szyh.cache.db.dao.UserDao;


import androidx.room.Database;
import androidx.room.RoomDatabase;
import androidx.room.migration.Migration;
import androidx.sqlite.db.SupportSQLiteDatabase;
import com.szyh.cache.db.entity.User;
import com.szyh.cache.db.entity.Interior;

@Database(entities = {User.class, Interior.class}, version = 2, exportSchema = false)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
    public abstract InteriorDao interiorDao();

    //數據庫變動添加Migration
    public static final Migration MIGRATION_1_2 = new Migration(1, 2) {
        @Override
        public void migrate(SupportSQLiteDatabase database) {

        }
    };
}

初始化room

    private void initDB(){
        db = Room.databaseBuilder(getApplicationContext(),
                AppDatabase.class, "roomDemo-database")
                //添加數據庫的變動遷移支持(當前狀態從version1到version2的變動處理)
                //主要在user裏面加入了age字段,大家可以git reset --hard <commit> 到第一個版本
                //然後debug 手動生成一些數據。然後debug 該版本查看數據庫升級體現。
                .addMigrations(AppDatabase.MIGRATION_1_2)
                //下面註釋表示允許主線程進行數據庫操作，但是不推薦這樣做。
                //他可能造成主線程lock以及anr
//                .allowMainThreadQueries()
                .build();
    }

數據庫curd操作，結合rxjava進行線程切換

package com.szyh.cache.db.operate;

import android.util.Log;

import com.szyh.cache.db.Database.AppDatabase;
import com.szyh.cache.db.dao.UserDao;
import com.szyh.cache.db.entity.User;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;

public class UserOperate {

    private String TAG = "UserOperate";

    private UserDao mUserDao;

    public void init(AppDatabase db){
        mUserDao = db.userDao();
    }

    public void insert(final User user){
        Observable.create(new ObservableOnSubscribe<Long>() {
            @Override
            public void subscribe(ObservableEmitter<Long> emitter) {
                Log.d(TAG, "insert aLong");
                //返回的是插入元素的primary key index
                Long aLong = mUserDao.insert(user);
                emitter.onNext(aLong);
            }
        })
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.d(TAG, "insert aLong " + aLong);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "insert e" + e.getMessage());
                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

    public void insertAll(final ArrayList<User> users){
        Observable.create(new ObservableOnSubscribe<List<Long>>() {
            @Override
            public void subscribe(ObservableEmitter<List<Long>> emitter) {
                Log.d(TAG, "insertAll");
                //返回的是插入元素的primary key index
                List<Long> longs = mUserDao.insertAll(users);
                emitter.onNext(longs);
            }
        })
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<List<Long>>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(List<Long> longs) {
                        Log.d(TAG, "insertAll size" + longs.size());
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

    public void getAll(){
        Observable.create(new ObservableOnSubscribe<List<User>>() {
            @Override
            public void subscribe(ObservableEmitter<List<User>> emitter) {
                Log.d(TAG, "getAll");
                //返回的是插入元素的primary key index
                List<User> list = mUserDao.getAll();;
                emitter.onNext(list);
            }
        })
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<List<User>>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(List<User> list) {
                        Iterator it1 = list.iterator();
                        while(it1.hasNext()){
                            Log.d(TAG, "getAll " + it1.next().toString());
                        }
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

    public void deleteAll(){
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) {
                Log.d(TAG, "deleteAll ");
                Integer i = -1;
                List<User> all = mUserDao.getAll();
                if (all != null && all.size() > 0) {
                    i = mUserDao.deleteAll(all);
                }
                emitter.onNext(i);
            }
        })
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer i) {
                        Log.d(TAG, "deleteAll " + i);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }
}