[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() {

                    }
                });
    }
}