【Android】还在用GreenDao吗?快来使用JetPack Room吧

Room的使用简示

• 1. Java使用
• • 1.1 引入
  • 1.2 使用
• 2. Kotlin的使用
• • 2.1 引入
  • 2.2 使用

1. Java使用

1.1 引入

implementation "android.arch.persistence.room:runtime:1.1.1"
annotationProcessor "android.arch.persistence.room:compiler:1.1.1"

1.2 使用

• database

LocalDataBase

@Database(
        version = 1,
        exportSchema = false,
        entities = {DbPerson.class}
)
public abstract class LocalDataBase extends RoomDatabase {
    public abstract DbPersonDao dbPersonDao();
}

• daos

DbPersonDao

@Dao
public interface DbPersonDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    long[] insert(List<DbPerson> persons);

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    long insert(DbPerson person);

    @Delete
    void delete(List<DbPerson> passPersonList);

    @Delete
    void delete(DbPerson person);

    @Query("DELETE From Person")
    void deleteAll();

    @Update
    void update(DbPerson person);

    @Query("SELECT * From Person Where person_uuid = :uuid")
    DbPerson selectDbPersonByPersonUuid(String uuid);

    @Query("SELECT * From Person")
    List<DbPerson> selectDbPersonAll();

}

• managers

DbManager

public class DbManager {

    private static volatile LocalDataBase db;

    //创建database实例
    public static LocalDataBase init(Context context) {
        if (db == null) {
            //Room和SQLCipher的桥梁
            synchronized (LocalDataBase.class) {
                if (db == null) {
                    //SafeHelperFactory factory = new SafeHelperFactory(KeyManager.getKey().toCharArray());
                    db = Room.databaseBuilder(
                            context.getApplicationContext(),
                            LocalDataBase.class, "local_db.db"
                    )
                            /*.addMigrations(MIGRATION_1_2)*///迁移升级
                            //.openHelperFactory(factory) //打开加密
                            //添加下面这一行
                            //.fallbackToDestructiveMigration()
                            .build();
                }
            }
        }
        return db;
    }

    /*val MIGRATION_1_2: Migration = object : Migration(1, 2) {
        override fun migrate(database: SupportSQLiteDatabase) {
            database.execSQL("ALTER TABLE 'PassPerson' ADD COLUMN 'person_card_no' VARCHAR(20) DEFAULT ''")
        }
    }*/

    public static LocalDataBase getDatabase() {
        return db;
    }

    //获取唯一id
    public static long getUniqueId() {
        return System.nanoTime() << 10;
    }

    //获取唯一字符串
    public static String getUniqueString() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

DbPersonManager

public class DbPersonManager {
    private static DbPersonDao dbPersonDao() {
        return DbManager.getDatabase().dbPersonDao();
    }

    /*static insert(dbPersons List<DbPerson>) LongArray {
        return dbPersonDao().insert(dbPersons)
    }*/

    public static Long insert(DbPerson dbPerson) {
        return dbPersonDao().insert(dbPerson);
    }

    public static void update(DbPerson dbPerson) {
        dbPersonDao().update(dbPerson);
    }

    public static void delete(DbPerson dbPerson) {
        dbPersonDao().delete(dbPerson);
    }

    public static void delete(List<DbPerson> dbPersonList) {
        dbPersonDao().delete(dbPersonList);
    }

    public static void deleteAll() {
        dbPersonDao().deleteAll();
    }

    public static DbPerson selectDbPersonByPersonUuid(String uuid) {
        return dbPersonDao().selectDbPersonByPersonUuid(uuid);
    }

    public static List<DbPerson> selectDbPersonAll() {
        return dbPersonDao().selectDbPersonAll();
    }
}

• mos

@Entity(tableName = "Person")
public class DbPerson {
    @NonNull
    @PrimaryKey
    @ColumnInfo(name = "person_uuid")
    private String personUuid;

    @ColumnInfo(name = "person_attribute")
    private String personAttribute;

    @ColumnInfo(name = "person_image")
    private String personImage;

    @ColumnInfo(name = "feature_status")
    private int featureStatus;

    public DbPerson(String personUuid, String personAttribute, String personImage, int featureStatus) {
        this.personUuid = personUuid;
        this.personAttribute = personAttribute;
        this.personImage = personImage;
        this.featureStatus = featureStatus;
    }

    public String getPersonUuid() {
        return personUuid;
    }

    public void setPersonUuid(String personUuid) {
        this.personUuid = personUuid;
    }

    public String getPersonAttribute() {
        return personAttribute;
    }

    public void setPersonAttribute(String personAttribute) {
        this.personAttribute = personAttribute;
    }

    public String getPersonImage() {
        return personImage;
    }

    public void setPersonImage(String personImage) {
        this.personImage = personImage;
    }

    public int getFeatureStatus() {
        return featureStatus;
    }

    public void setFeatureStatus(int featureStatus) {
        this.featureStatus = featureStatus;
    }

    @Override
    public String toString() {
        return "DbPerson{" +
                "personUuid='" + personUuid + '\'' +
                ", personAttribute='" + personAttribute + '\'' +
                ", personImage='" + personImage + '\'' +
                ", featureStatus=" + featureStatus +
                '}';
    }
}

How To Use

• 初始化

public class MainApplication extends MultiDexApplication {

    @Override
    public void onCreate() {
        super.onCreate();
        ...
        DbManager.init(this);
    }
    ...
}

• 调用方法

DbPersonManager.insert(dbPerson)

2. Kotlin的使用

2.1 引入

在app build.gradle中加入

plugins {
    ...
    id 'kotlin-kapt'
}

dependencies {
    api 'androidx.room:room-runtime:2.4.2'
    kapt 'androidx.room:room-compiler:2.4.2'
}

2.2 使用

• commons

1. database

@Database(entities = [AudioBean::class, FavouriteBean::class], version = 1, exportSchema = false)
abstract class MusicBoxDatabase : RoomDatabase() {
    abstract val favouriteDao: IFavouriteDao
    abstract val audioDao: IAudioDao

    companion object {
        @Volatile
        private var _db: MusicBoxDatabase =
            Room.databaseBuilder(UtilKGlobal.instance.getApp()!!, MusicBoxDatabase::class.java, "musicbox_db").build()

        @JvmStatic
        fun get(): MusicBoxDatabase {
            return _db
        }
    }
}

2. dao

@Dao
interface IAudioDao {
    @Query("select * from audio_bean where id = :id")
    fun selectAudioBeanById(id: String): AudioBean?

    @Query("delete from audio_bean where id = :id")
    fun deleteAudioBeanById(id: String)

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertAudioBean(audioBean: AudioBean)
}

@Dao
interface IFavouriteDao {
    @Query("select * from favourite_bean where audioId = :audioId")
    fun selectFavouriteBeanByAudioId(audioId: String): FavouriteBean?

    @Query("delete from favourite_bean where audioId = :audioId")
    fun deleteFavouriteBeanByAudioId(audioId: String)

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertFavouriteBean(favouriteBean: FavouriteBean)
}

• mos

@Entity(tableName = "audio_bean", indices = [Index(value = ["url"], unique = true)])
class AudioBean(
    @PrimaryKey
    val id: String,
    val url: String,//地址
    val name: String,//歌名
    val author: String,//作者
    val album: String,//所属专辑
    val albumInfo: String,//专辑信息
    val albumPic: String,//专辑封面
    val totalTime: String,//时长
) : Serializable

@Entity(tableName = "favourite_bean")
class FavouriteBean(
    val audioId: String
) : Serializable {
    @PrimaryKey(autoGenerate = true)
    var favouriteId: Int = 0
}

3. Biz交互

object BizDb {
    private val _audioDao = MusicBoxDatabase.get().audioDao
    private val _favouriteDao = MusicBoxDatabase.get().favouriteDao

    fun addFavouriteBean(audioBean: AudioBean) {
        _audioDao.insertAudioBean(audioBean)
        _favouriteDao.insertFavouriteBean(FavouriteBean(audioBean.id))
    }

    fun removeFavouriteBean(audioId: String) {
        _audioDao.deleteAudioBeanById(audioId)
        _favouriteDao.deleteFavouriteBeanByAudioId(audioId)
    }

    fun hasFavouriteBean(audioId: String): Boolean =
        _favouriteDao.selectFavouriteBeanByAudioId(audioId) != null
}