Android Room数据库，用过你才知道好
这里写目录标题
- 一. 初识Room
- 1. DataBase
- 2. Entity（实体）
- 3. Dao（数据访问对象）
- 二. 如何使用Room
- 1.依赖引入
- 2. 方法调用
- 三、使用注意事项
- 1. 数据库关闭异常
- 2. SQL用Integer
- 3. schemas的导出
- 使用场景
- 总结
Room是一个数据持久化库，它是 Architecture Component的一部分。它让SQLiteDatabase的使用变得简单，大大减少了重复的代码，并且把SQL查询的检查放在了编译时。
Room官方文档介绍:https://developer.android.google.cn/training/data-storage/room?
一. 初识Room
Room主要由3个重要的组件组成：DataBase、Entity、Dao。三者的关系如下：
1. DataBase
数据库持有者，并作为与应用持久关联数据的底层连接的主要访问点。在运行时，通过Room.databaseBuilder() 或者 Room.inMemoryDatabaseBuilder()获取Database实例。
DataBase需要满足下面几个条件：
- 必须是abstract类而且的extends RoomDatabase。
- 必须在类头的注释中包含与数据库关联的实体列表(Entity对应的类)。
- 包含一个具有0个参数的抽象方法，并返回用@Dao注解的类。
/**
* 使用中 annotationProcessor 'androidx.room:room-compiler:2.2.2'
* 改为kapt 'androidx.room:room-compiler:2.2.2' ，如果项目中使用了kotlin
*
* @author 罗发新
* TypeConverters({Converters.class}) TODO 类型转化 有待研究其作用
*/
@Database(entities = {
UpImage.class
// , Book.class
// , Loan.class
}, version = 3, exportSchema = false)
public abstract class AbstractAppDataBase extends RoomDatabase {
public abstract UpImageDao upImageDao();
// public abstract BookDao bookDao();
private static volatile AbstractAppDataBase INSTANCE;
/**
* 关于AppDataBase 的使用：
* 1）如果database的版本号不变。app操作数据库表的时候会直接crash掉。(错误的做法)
* 2）如果增加database的版本号。但是不提供Migration。app操作数据库表的时候会直接crash掉。（错误的做法）
* 3）如果增加database的版本号。同时启用fallbackToDestructiveMigration。这个时候之前的数据会被清空掉。
* 如下fallbackToDestructiveMigration()设置。(不推荐的做法)
*/
public static AbstractAppDataBase getDatabase(Context context) {
if (INSTANCE == null) {
synchronized (AbstractAppDataBase.class) {
if (INSTANCE == null) {
INSTANCE = Room.databaseBuilder(context.getApplicationContext(), AbstractAppDataBase.class, "android_room_dev.db")
// 设置是否允许在主线程做查询操作
.allowMainThreadQueries()
// 设置数据库升级(迁移)的逻辑
.addMigrations(MIGRATION_1_2, MIGRATION_2_3)
// setJournalMode(@NonNull JournalMode journalMode) 设置数据库的日志模式
// 设置迁移数据库如果发生错误，将会重新创建数据库，而不是发生崩溃
// .fallbackToDestructiveMigration() 会清理表中的数据 ，不建议这样做
//设置从某个版本开始迁移数据库如果发生错误，将会重新创建数据库，而不是发生崩溃
//.fallbackToDestructiveMigrationFrom(int... startVersions);
.addCallback(new RoomDatabase.Callback() {
// 进行数据库的打开和创建监听
@Override
public void onCreate(@NonNull SupportSQLiteDatabase db) {
super.onCreate(db);
}
@Override
public void onOpen(@NonNull SupportSQLiteDatabase db) {
super.onOpen(db);
}
})
//默认值是FrameworkSQLiteOpenHelperFactory，设置数据库的factory。
// 比如我们想改变数据库的存储路径可以通过这个函数来实现
// .openHelperFactory(SupportSQLiteOpenHelper.Factory factory);
.build();
}
}
}
return INSTANCE;
}
/**
* 数据库版本 1->2 user表格新增了age列
*/
private final static Migration MIGRATION_1_2 = new Migration(1, 2) {
@Override
public void migrate(SupportSQLiteDatabase database) {
database.execSQL("ALTER TABLE User ADD COLUMN age integer");
}
};
/**
* 数据库版本 2->3 新增book表格
*/
private final static Migration MIGRATION_2_3 = new Migration(2, 3) {
@Override
public void migrate(SupportSQLiteDatabase database) {
database.execSQL("CREATE TABLE IF NOT EXISTS `book` (`uid` INTEGER PRIMARY KEY autoincrement, `name` TEXT , `userId` INTEGER, 'time' INTEGER)");
}
};
}
事实上Database有两种生成方式：
- Room.databaseBuilder()：生成Database对象，并且创建一个存在文件系统中的数据库。
- Room.inMemoryDatabaseBuilder()：生成Database对象并且创建一个存在内存中的数据库。当应用退出的时候(应用进程关闭)数据库也消失。
2. Entity（实体）
代表数据库中某个表的实体类。默认情况下Room会把Entity里面所有的字段对应到表上的每一列。
Entity类中需要映射到表中的字段需要保证外部能访问到，所以每个字段要么Public,要么实现getter和setter方法。
/**
* 作者：罗发新
* 时间：2019/12/2 0002 星期一
* 邮件：[email protected]
* 说明：Room 测试类
* Entity注解包含的属性有：
* tableName：设置表名字。默认是类的名字,不区分大小写。
* indices：设置索引。
* inheritSuperIndices：父类的索引是否会自动被当前类继承。
* primaryKeys：设置主键。
* foreignKeys：设置外键。
*/
//@Entity(primaryKeys = {"firstName", "lastName"}) 也可以这样设置多个主键
//@Entity(indices = {@Index("firstName"), @Index(value = {"last_name", "address"},unique = true)}) unique 设置是否唯一索引
@Entity(tableName = "UserBean")
public class User {
@Ignore
public User(String userName) {
// id = UUID.randomUUID().toString();
mUserName = userName;
}
public User( ) {
}
@Ignore
public User(int id, String userName) {
this.id = id;
this.mUserName = userName;
}
//设置主键自增， 每个类需要一个主键
@PrimaryKey(autoGenerate = true)
public int id;
@ColumnInfo(name = "username")
public String mUserName;
//自定义设置列名
@ColumnInfo(name = "first_name")
public String firstName;
@ColumnInfo(name = "last_name")
public String lastName;
public int age;
/**
* 如果有多个相同类型的嵌入字段，则可以设置前缀属性来保持每个列的唯一性。
* 然后Room会将提供的值添加到嵌入对象中每个列名的开头。
*/
@Embedded(prefix = "first")
public Address address;
@Embedded(prefix = "second")
public Address address2;
public String school;
/**
* @Ignore 默认每个字段队列数据库中的一列，除非用 @Ignore注解不添加进入数据表中
*
*/
@Ignore
public Bitmap picture;
}
/**
* onDelete即当parent中有删除操作时，onUpdate即当parent中有更新操作时，
*
* child对应响应的动作有四种：
* 1. NO_ACTION：当parent中的key有变化的时候child不做任何动作,默认动作
* 2. RESTRICT：当parent中的key有依赖的时候禁止对parent做动作，做动作就会报错。
* 3. SET_NULL：当paren中的key有变化的时候child中依赖的key会设置为NULL。
* 4. SET_DEFAULT：当parent中的key有变化的时候child中依赖的key会设置为默认值。
* 5. CASCADE：当parent中的key有变化的时候child中依赖的key会跟着变化
*
* deferred：默认值false，在事务完成之前，是否应该推迟外键约束。
* 比如当我们启动一个事务插入很多数据的时候，事务还没完成之前，parent引起key变化的时候。
* 可以设置deferred为ture,让key立即改变。为false时，事务完成后child的key才会统一进行相应处理
*
*/
@Entity(foreignKeys = @ForeignKey(entity = User.class,
parentColumns = "id",
childColumns = "user_id",
onDelete = CASCADE,
onUpdate = NO_ACTION,
deferred = false
))
class Book {
@PrimaryKey
public int bookId;
public String title;
@ColumnInfo(name = "user_id")
public int userId;
}
public class Address {
public String street;
public String state;
public String city;
@ColumnInfo(name = "post_code")
public int postCode;
}
3. Dao（数据访问对象）
Data Access Objects 是Room的主要组件，负责定义访问数据库的方法，Room在编译时创建每个DAO实例。
DAO抽象地以一种干净的方式去访问数据库，它可以是一个接口也可以是一个抽象类。如果它是一个抽象类，它可以有一个构造函数，它将RoomDatabase作为其唯一参数。
/**
* dao 在编译期就会自动报错，强大的一匹
* Data Access Object for the users table.
*
* @author 罗发新
*/
@Dao
public interface UserDao {
/**
* 当DAO里面的某个方法添加了@Insert注解。Room会生成一个实现，将所有参数插入到数据库中的一个单个事务。
*
* onConflict：表示当插入有冲突的时候的处理策略。OnConflictStrategy封装了Room解决冲突的相关策略：
* OnConflictStrategy.REPLACE：冲突策略是取代旧数据同时继续事务。
* OnConflictStrategy.ROLLBACK：冲突策略是回滚事务。
* OnConflictStrategy.ABORT：冲突策略是终止事务。默认策略
* OnConflictStrategy.FAIL：冲突策略是事务失败。
* OnConflictStrategy.IGNORE：冲突策略是忽略冲突。
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
long[] insertUsers(User... users);
/**
* 当参数只有一个时，返回值只可以是long
*
* @param user 参数
* @return 表示插入的rowId
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
long insertUser(User user);
/**
* 有多个参数时，返回值可以是long[]或者List，
*
* @param users 参数
* @return long表示插入的rowId
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
List<Long> insertUser(User... users);
@Update(onConflict = OnConflictStrategy.REPLACE)
int updateUsers(User... users);
/**
* Room会把对应的参数信息更新到数据库里面
* @param users 操作参数
* @return 表示更新成功了多少行
*/
@Update()
int updateAll(User... users);
@Update
int updateAll(List<User> user);
/**
* Room会把对应的参数信息指定的行删除掉
* @param users 操作参数
* @return 表示删除了多少行
*/
@Delete
int deleteUsers(User... users);
/**
* Delete all users.
*/
@Query("DELETE FROM " + TABLE_NAME)
void deleteAll();
//所有的CURD根据primary key进行匹配
String TABLE_NAME = "UserBean";
//------------------------query------------------------
// 简单sql语句，查询user表所有的column
@Query("SELECT * FROM " + TABLE_NAME)
List<User> loadAllUsers();
/**
* 它允许您对数据库执行读/写操作。@Query在编译的时候会验证准确性，
* 所以如果查询出现问题在编译的时候就会报错。比如字段名称不匹配，没有该字段
* @param firstName 条件插叙
* @return 查询返回的列表
*/
@Query("SELECT * FROM UserBean WHERE first_name == :firstName")
User[] loadAllUsersByFirstName(String firstName);
@Query("SELECT * FROM UserBean WHERE age BETWEEN :minAge AND :maxAge")
List<User> loadAllUsersBetweenAges(int minAge, int maxAge);
@Query("SELECT * FROM UserBean WHERE first_name LIKE :search " + "OR last_name LIKE :search")
List<User> findUserWithName(String search);
// /**
// * 只查询特定列信息
// */
// @Query("SELECT first_name, last_name FROM UserBean")
// List loadFullName();
/**
* 传递一组的参数，返回的对象可以用单独的对象接收
*/
@Query("SELECT first_name, last_name FROM UserBean WHERE school IN (:regions)")
List<NameTuple> loadUsersFromRegions(List<String> regions);
/**
* LiveData
*/
@Query("SELECT first_name, last_name FROM UserBean WHERE school IN (:regions)")
LiveData<List<NameTuple>> loadUsersFromRegionsSync(List<String> regions);
/**
* Rxjava2 中的 对象
*/
@Query("SELECT * from UserBean")
Flowable<List<User>> loadUser();
/**
* 直接返回cursor
*/
@Query("SELECT * FROM userbean WHERE age > :minAge LIMIT 5")
Cursor loadRawUsersOlderThan(int minAge);
/*
* 多表联查
*/
// @Query("SELECT UserBean.* FROM book "
// + "INNER JOIN loan ON loan.bookId = book.bookId "
// + "INNER JOIN UserBean ON userbean.id = loan.userId "
// + "WHERE userbean.last_name LIKE :lastName")
// List findBooksBorrowedByNameSync(String lastName);
// @Query("SELECT userbean.last_name AS userName, book.name AS bookName "
// + "FROM userbean, book "
// + "WHERE :userId = book.user_id")
// LiveData> loadUserAndPetNames(int userId);
/**
* 返回第一个用户
*
* @return the user from the table
*/
@Query("SELECT * FROM " + TABLE_NAME + " LIMIT 1")
Flowable<User> getUser();
/**
* Insert a user in the database. If the user already exists, replace it.
*
* @param user the user to be inserted.
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
Completable insertUserSingle(User user);
/**
* 多表联查
*/
@Dao
public interface MyDao {
@Query("SELECT * FROM book "
+ "INNER JOIN loan ON loan.book_id = book.id "
+ "INNER JOIN user ON user.id = loan.user_id "
+ "WHERE user.name LIKE :userName")
public List<Book> findBooksBorrowedByNameSync(String userName);
}
/**
* 查询指定列的 多表联查
* @return
*/
@Query("SELECT user.name AS userName, pet.name AS petName "
+ "FROM user, pet "
+ "WHERE user.id = pet.user_id")
public LiveData<List<UserPet>> loadUserAndPetNames();
}
二. 如何使用Room
1.依赖引入
在app.module中配置依赖。
implementation 'androidx.room:room-runtime:2.2.5'
// room 配合 RxJava
implementation 'androidx.room:room-rxjava2:2.2.5'
kapt 'androidx.room:room-compiler:2.2.5'
2. 方法调用
AbstractAppDataBase.getDatabase(sysApplication).upImageDao().insert(upImage);
AbstractAppDataBase.getDatabase(MyBaseApplication.getInstance()).upImageDao().queryAll();
AbstractAppDataBase.getDatabase(MyBaseApplication.getInstance()).upImageDao();
三、使用注意事项
1. 数据库关闭异常
E/SQLiteLog: (283) recovered 9 frames from WAL file /data/data/com.*/databases/android_room_dev.db-wal
出现此消息表明数据库在退出之前尚未关闭,因此未正确清理WAL文件.当应用程序启动时，如果发现数据库的连接还未关闭。当程序重新打开时，它会想办法清理WAL文件，此时会发出错误信息提示出现了严重问题。
if (AbstractAppDataBase.getDatabase(MyBaseApplication.getInstance()).isOpen()) {
AbstractAppDataBase.getDatabase(MyBaseApplication.getInstance()).close();
}
要解决此问题,您需要在数据库使用完毕后关闭Room数据库.
2. SQL用Integer
在进行SQL 拼写是要用Integer,不要用int ,特别是Migrating中，否则会报出现异常。
3. schemas的导出
如果在AppDataBase中配置了Schema = true才能导出schemas文件，当然Schema 默认就是true。
需要在build.gradle中配置：
android {
...
defaultConfig {
...
javaCompileOptions {
annotationProcessorOptions {
arguments = ["room.schemaLocation":
"$projectDir/schemas".toString()]
}
}
}
}
使用场景
场景描述
- 我现有个项目，可以在有网和无网状态下运行，进行的一种操作需要记录相关信息并上传至后台，操作信息不能遗漏，无网络时要保存在有网状态时上传。
- 网络环境差，网络处于无网和有网、极度弱网（请求基本超时，有时成功）状态下
常规思路
- 软件启动时，上传离线数据
- 定时上传离线数据
- 检测网络切换时触发上传离线数据
Room解决方案
- 使用Livadata获取满足上传条件的数据，一旦数据库中的该查询结果有变化，立马执行上传操作。 当然要判断有网，在弱网状态下失败后，因为Count未变化，也不会导致程序循环的进行上传操作。
@Query("SELECT COUNT(*) FROM " + TABLE_NAME + " WHERE isUp2Axe =0 ")
LiveData<Integer> queryAxeCount();
总结
之所以推荐你用Room ,和其他sqlite相比它的优点有很多
- 使用原生sql来表达对数据库的操作，会在编译时会验证SQL的正误，可扩展性非常强大
- 分层清晰，上手简单，代码相比于第三方也更加可靠
- 存储对象里嵌套对象时，可使用@Embedded注解进行自动拆分存储。
- 通过注解生成代码，减少了代码量
一般Google推出的技术绝大多数还是挺好用的，我已经弃用了ormLite，根据本人的使用体验，确实用起来会流畅的多，且使用简单，它是Google Jatpack的组成之一。
博客书写不易，如觉得文章还行，请您点个赞 ^ _ ^ !
推荐链接：
- 热更新你都知道哪些？
- ART与Dalvik、JVM之间的关系你懂了吗？
- 多项目Project共享同一个Library