Android_存储之DataBase之Room

概述：

 Room是Google在AndroidX中提供的一个ORM(Object Relational Mapping，对象关系映射)库。它是在SQLite上提供的一个抽象层，可以使用SQLite的全部功能，同时可以更好更便捷流畅地访问数据库。（关于AndroidX可以参考，Android_AndroidX简介&Junit4：https://www.cnblogs.com/fanglongxiang/p/11401123.html）

推荐使用Room而不是直接使用SQLite，官方的说明如下：

应用程序处理大量结构化数据 从本地持久化数据中处理是最好的。最常见的用例是缓存相关的数据片段。这样，当设备无法访问网络时，用户仍然可以在离线时浏览该内容。任何用户发起的内容更改都将在设备重新联机后同步到服务器。

Room的架构和组成：

Room主要由下面3部分组成，这里简单说明下，后面会详解。

DataBase:包含数据库容器，并作为到应用程序的持久关系数据的底层连接的主要访问点。

    通过注释@Database实现，并要继承RoomDatabase。具体见下面例子中的StudentDataBase。

Entity: 实体，相当于数据库中的表，对应表中的字段。

DAO:  data access objects，简称DAO，数据库访问对象，包含了访问数据库的方法。

应用通过RoomDatabase获取与之关联的DAOs，然后通过DAO从数据库中获取实体(Entity)并保存相应修改到数据库中，Entity是用来获取或设置数据库的表中对应字段的值。下面是对应的结构图：

下面先举一个小示例，大致了解下 Room数据库的增删改查 流程（代码中添加了说明注释，可以详细看下）；然后再详细说明知识点。

要使用Room，首先要加载依赖build.gradle(Module:)添加如下(最新信息从这里获取 https://developer.android.google.cn/jetpack/androidx/releases/room#declaring_dependencies)：

dependencies {
  def room_version = "2.2.0-beta01"

  implementation "androidx.room:room-runtime:$room_version"
  annotationProcessor "androidx.room:room-compiler:$room_version" // For Kotlin use kapt instead of annotationProcessor

  // optional - Kotlin Extensions and Coroutines support for Room
  implementation "androidx.room:room-ktx:$room_version"

  // optional - RxJava support for Room
  implementation "androidx.room:room-rxjava2:$room_version"

  // optional - Guava support for Room, including Optional and ListenableFuture
  implementation "androidx.room:room-guava:$room_version"

  // Test helpers
  testImplementation "androidx.room:room-testing:$room_version"
}

首先，创建一个实体Entity，这里创建一个叫Student的实体（它对应一个名叫students的表，表中3个字段id, student_name, age），代码如下：

package com.flx.testroom;

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

//@Entity注释一个实体 tableName 数据库中的表名
@Entity(tableName = "students")
public class Student {

    //主键 自增
    @PrimaryKey(autoGenerate = true)
    public int id;

    //student_name才是真正在表中对应的字段名，name是该对象中的变量。
    @ColumnInfo(name="student_name")
    public String name;

    public int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

然后，创建一个名为StudentsDao的DAO，代码如下：

package com.flx.testroom;

import java.util.List;

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

@Dao
public interface StudentsDao {
    @Insert//增
    public void insertStudent(Student student);

    @Insert
    public void insertStudents(Student student1, Student student2);

    @Insert
    public void insertStudentsAndMore(Student student, List<Student> classmate);

    @Update//改
    public void updateStudents(Student ... students);

    @Delete//删
    public void deleStudents(Student ... students);

    @Query( "SELECT * FROM students" )//查
    public Student[] getAllStudents();

    @Query( "SELECT * FROM students WHERE student_name LIKE:studentName" )//带参数
    public Student[] getStudentsByName(String studentName);

}

最后创建数据库类StudentDataBase，

package com.flx.testroom;

import androidx.room.Database;
import androidx.room.RoomDatabase;

//@Database注释定义数据库类， entities指明包含的实体， version表明版本 数据迁移一定需要，后面有讲到。
@Database( entities = {Student.class}, version = 1)
public abstract class StudentDataBase extends RoomDatabase {
    public abstract StudentsDao studentsDao();
}

接下来看如何调用，运行后的现象和结果。 这里编写的是一个运行在Android设备上的JUnit测试。

为了能看到具体数据库，这里创建数据库使用持久化的方法，databaseBuilder，下面有详细说明。

（关于Junit测试可以参考，Android_AndroidX简介&Junit4：https://www.cnblogs.com/fanglongxiang/p/11401123.html）

package com.flx.testroom;

import android.content.Context;
import android.util.Log;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

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

import androidx.room.Room;
import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;

@RunWith(AndroidJUnit4.class)
public class StudentsDaoTest {
    private StudentsDao studentsDao;
    private StudentDataBase studentDb;

    @Before
    public void setUp() throws Exception {
        Context context = InstrumentationRegistry.getTargetContext();
        //studentDB 数据库的名字
        studentDb = Room.databaseBuilder(context, StudentDataBase.class, "studentDB").build();
//        studentDb = Room.inMemoryDatabaseBuilder( context, StudentDataBase.class ).build();
        studentsDao = studentDb.studentsDao();
    }

    @After
    public void tearDown() throws Exception {
        studentDb.close();
    }

    @Test
    public void StudentsTest() {
　　　　 //插入了4组数据，由于id增，这里没有赋值
        List<Student> listStudents = new ArrayList<>();
        Student inStudent1 = new Student("insert1", 20);
        Student inStudnet2 = new Student( "insert2", 21 );
        Student inStudnet3 = new Student( "insert3", 22 );
        Student inStudnet4 = new Student( "insert4", 22 );
        listStudents.add( inStudnet2 );
        listStudents.add( inStudnet3 );
        listStudents.add( inStudnet4 );
        studentsDao.insertStudentsAndMore( inStudent1, listStudents );
　　　　
　　　　　//查询读取所有数据并打印log, getAllStudents after insert
        Student[] resultStudents1 = studentsDao.getAllStudents();
        for (Student st:resultStudents1 ) {
            Log.d( "test_flx", "getAllStudents after insert: id = " + st.getId() + "; name = " + st.getName() + "; age = "+st.getAge());
        }
　　　　　　
　　　　　//更新， 更新了上述查询的第一组数据 以及 id为2的数据。id为2 这里即第二组
        resultStudents1[0].setName( "update1" );
        resultStudents1[0].setAge( 111 );
        Student updateStudent = new Student("update2", 222);
        updateStudent.setId( 2 );
        studentsDao.updateStudents( resultStudents1[0], updateStudent );

　　　　 //查询读取所有数据并打印log,getAllStudents after update
        Student[] resultStudents2 = studentsDao.getAllStudents();
        for (Student st: resultStudents2) {
            Log.d( "test_flx", "getAllStudents after update: id = " + st.getId() + "; name = " + st.getName() + "; age = "+st.getAge());
        }

　　　　　//删除查询的第一个数据　　　　
        studentsDao.deleStudents( resultStudents2[0] );

　　　　  //查询读取所有数据并打印log,getAllStudents after dele
        for (Student st: studentsDao.getAllStudents()) {
            Log.d( "test_flx", "getAllStudents after dele: id = " + st.getId() + "; name = " + st.getName() + "; age = "+st.getAge());
        }
    }
}

@Before->@Test->@After。测试中，创建了叫studentDB的数据库，具体操作在StudentsTest方法中注释中详细说明了，下面看下结果。

log打印的结果如下，是符合上述操作的：

2019-07-16 10:35:12.486 32711-32730/com.flx.testroom D/test_flx: getAllStudents after insert: id = 1; name = insert1; age = 20
2019-07-16 10:35:12.486 32711-32730/com.flx.testroom D/test_flx: getAllStudents after insert: id = 2; name = insert2; age = 21
2019-07-16 10:35:12.486 32711-32730/com.flx.testroom D/test_flx: getAllStudents after insert: id = 3; name = insert3; age = 22
2019-07-16 10:35:12.487 32711-32730/com.flx.testroom D/test_flx: getAllStudents after insert: id = 4; name = insert4; age = 22
2019-07-16 10:35:12.502 32711-32730/com.flx.testroom D/test_flx: getAllStudents after update: id = 1; name = update1; age = 111
2019-07-16 10:35:12.502 32711-32730/com.flx.testroom D/test_flx: getAllStudents after update: id = 2; name = update2; age = 222
2019-07-16 10:35:12.502 32711-32730/com.flx.testroom D/test_flx: getAllStudents after update: id = 3; name = insert3; age = 22
2019-07-16 10:35:12.502 32711-32730/com.flx.testroom D/test_flx: getAllStudents after update: id = 4; name = insert4; age = 22
2019-07-16 10:35:12.516 32711-32730/com.flx.testroom D/test_flx: getAllStudents after dele: id = 2; name = update2; age = 222
2019-07-16 10:35:12.517 32711-32730/com.flx.testroom D/test_flx: getAllStudents after dele: id = 3; name = insert3; age = 22
2019-07-16 10:35:12.517 32711-32730/com.flx.testroom D/test_flx: getAllStudents after dele: id = 4; name = insert4; age = 22

　　

通过adb进入设备，读取数据库数据如下，也是符合的：

 

通过上面的例子，应该有一点了解或感觉，下面具体说一些Room相关的知识点。

 1.  创建Room数据库 Database：

创建Room数据库有两种方式，在上面代码中测试里 就有选择了其中一种，持久化的数据库。

（1）databaseBuilder (Context context, Class<T> klass, String name)

创建的是持久化的数据库，上面例子就用的这种，生成的数据库在/data/data/<packagesname>/databases下。

studentDb = Room.databaseBuilder(context, StudentDataBase.class, "studentDB").build();

（2）inMemoryDatabaseBuilder (Context context, Class<T> klass)

内存数据库，当进程结束后 数据库也相应的被释放，数据库中的信息也丢失了。

studentDb = Room.inMemoryDatabaseBuilder( context, StudentDataBase.class ).build();

　　

2. 实体 Entity:

 上述例子中，Student即是实体，可以看代码中注释，有部分说明。下面具体说明下。

• 实体对应数据库中的表，包含了表的各个字段对应成的字段，以及操作方法(如例子中的每个字段的getter和setter方法)。

注：Android Studio快速生成getter setter方法，可使用Alt+Insert调出如下界面快速构造

• 使用实体，首先保证下面的结构组件已添加到build.gradle(Project:)中（这里添加的build.gradle和上面room依赖添加的不是一个文件，注意build.gradle后面的注释），默认是添加了的。

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

• @Entity 注释，定义了一个实体。可以包含多个参数，如下tableName-表名

@Entity(tableName = "students")
public class Student {
}

• 主键使用注释@PrimaryKey定义，可以是单个字段，也可以是多个字段。如果是多个字段 在@Entity中添加，主键要可以设置自增属性autoGenerate。如：

//多个字段的主键
@Entity(primaryKeys = {"AA", "BB"})
public class Student {

}

//主键自增
@PrimaryKey(autoGenerate = true)
pulic int id;

• @ColumnInfo注释，定义一个变量对应的表中的字段，name属性即表中字段名。没有添加的，变量名即表中字段名。

@ColumnInfo(name="student_name")
public String name;

• 默认实体中每个变量都会在表中新建一列与之对应，如果不想持久化某一个，可以使用变量的注释@Ignore 或 实体的注释@Entity(ignoredColumns = "xxxx"）进行忽略。
• FTS(full-text search):全文搜索支持，使用条件是Room版本在2.1.0及以上。通过注释@Fts3 or @Fts4 定义使用。

注意：1.一般使用@Fts4, 如果应用有严格的磁盘要求 或者 要兼容旧版本的SQLite才使用@Fts3。

           2.主键必须是 INTEGER类型 名字是rowid.否则会有如下错误：

错误: The single primary key field in an FTS entity must either be named 'rowid' or must be annotated with @ColumnInfo(name = "rowid")

　简单例子：

@Fts4
@Entity(tableName = "students")
public class Student {

    @PrimaryKey
    public int rowid;

    @ColumnInfo(name="student_name")
    public String name;
}

•  索引：通过索引加快查询，通过unique属性定义唯一性。如下（包含了两项的索引，并设置了唯一）：

@Entity(tableName = "students",indices = {@Index(value = {"id", "student_name"},
        unique = true)})
public class Student {

    @PrimaryKey
    public int id;

    @ColumnInfo(name="student_name")
    public String name;
}

注意：索引不能在Fts中使用

错误: Indices not allowed in FTS Entity.

　　

• 实体类对象间的关系

Room禁止实体类之间的对象引用。

大致原因是性能和体验上的考虑：将关系从数据库映射到对象上，这种方式再客户端上存在性能问题。延迟加载（默认方式）是不可行的，它一般发生在UI线程上，UI线程查询磁盘数据有严重性能问题。Ui线程计算 绘制Activity或布局大致要16ms, 即使查询只要5ms 也可能导致没有足够时间，导致视觉上的问题。如果有事务并行或磁盘密集型操作，查询时间会更久。如果不使用延迟加载，程序获取的数据比需要的更多，造成内存消耗过多的问题，影响性能。

例如：有两个对象，Book和Author，每个Book都有一个Author对象。一个UI加载Book列表，可以通过延迟加载 获取图书检索作者的实例。第一次从数据库中查询author。一段时间后，可能UI上 还需显示作者的名字，通过下面代码添加：

authorNameTextView.setText(book.getAuthor().getName());

这个看起来没有问题。如果提前查询作者信息，而如果不再需要数据，就很难更改数据的加载方式。例如，如果您的应用程序的UI不再需要显示作者信息，应用会继续加载不再显示的数据，从而浪费宝贵的内存空间。如果Author类引用其他表(如Books)，则应用程序的效率会进一步降低。

　　(1). 一对多

下面是另一个名为Book的实体，通过注释@ForeignKey定义了它与Student的关系。

@Entity(foreignKeys = @ForeignKey(entity = Student.class,
        parentColumns = "id",
        childColumns = "student_id",
        onDelete = ForeignKey.CASCADE))//onDelete = ForeignKey.CASCADE，当Student被删除，则所有与之关联的Book都会被删除。
public class Book {
    @PrimaryKey
    public int bookId;

    public String title;

    @ColumnInfo(name = "student_id")
    public int studentId;
}

 这里的一对多，是Student对Book。通过外键student_id使多个Book实例 关联到 Student实例上。

　　(2). 嵌套对象

如下在Student中嵌套了一个Address对象，这样Student实体对象就对应包含了这些列：id, student_name, street, state, city, post_code。

public class Address {
    public String street;
    public String state;
    public String city;

    @ColumnInfo(name = "post_code")
    public int postCode;
}


@Entity(tableName = "students",indices = {@Index(value = {"id", "student_name"},
        unique = true)})
public class Student {

    @PrimaryKey
    public int id;

    @ColumnInfo(name="student_name")
    public String name;

    @Embedded public Address address;
}

　　(3). 多对多

多对多，通过下面例子（官网）来具体看看。下面包含了两个实体，Playlist 和Song，以及一个中间类 PlaylistSongJoin 保存每个播放列表中的歌曲信息。

@Entity
public class Playlist {
    @PrimaryKey public int id;

    public String name;
    public String description;
}

@Entity
public class Song {
    @PrimaryKey public int id;

    public String songName;
    public String artistName;
}

　　PlaylistSongJoin：

@Entity(tableName = "playlist_song_join",
        primaryKeys = { "playlistId", "songId" },
        foreignKeys = {
                @ForeignKey(entity = Playlist.class,
                            parentColumns = "id",
                            childColumns = "playlistId"),
                @ForeignKey(entity = Song.class,
                            parentColumns = "id",
                            childColumns = "songId")
                })
public class PlaylistSongJoin {
    public int playlistId;
    public int songId;
}

3. 数据库视图

2.1.0及更高版本才支持，和实体Entity类似，可以对视图执行SELECT，但不能执行INSERT, UPDATE, DELETE。

创建视图：使用注释@DatabaseView，注释的值设置成查询。

@DatabaseView("SELECT user.id, user.name, user.departmentId," +
              "department.name AS departmentName FROM user " +
              "INNER JOIN department ON user.departmentId = department.id")
public class UserDetail {
    public long id;
    public String name;
    public long departmentId;
    public String departmentName;
}

 关联视图到数据库：

@Database(entities = {User.class}, views = {UserDetail.class},
          version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}

4. DAO 访问数据库

 要使用Room持久化库，需要通过数据访问对象DAO(data access objects)。 它可以是一个接口，也可以是一个抽象类。

Room不支持在主线程访问数据库（在构造数据库时若调用 allowMainThreadQueries() 可绕过），因为它可能比较长时间锁定UI(主线程) 导致ANR。若要在主线程访问数据库，需要使用异步方法 或者  手动将调用移到后台线程。

最开始的例子 中的StudentsDao就是这样的类。再次给出 ：

@Dao
public interface StudentsDao {
    @Insert
    public void insertStudent(Student student);

    @Insert
    public void insertStudents(Student student1, Student student2);

    @Insert
    public void insertStudentsAndMore(Student student, List<Student> classmate);

    @Update
    public void updateStudents(Student ... students);

    @Delete
    public void deleStudents(Student ... students);

    @Query( "SELECT * FROM students" )
    public Student[] getAllStudents();

    @Query( "SELECT * FROM students WHERE student_name LIKE:studentName" )
    public Student[] getStudentsByName(String studentName);

    @Query("SELECT student_name, age FROM students")
    public List<Student> getNameAndAge();
}

 增删改查 通过注释@Insert  @Delete @Update @Query使用即可，Room已生成对应的实现。其中@Update @Delete是通过主键找到对应实体再进行操作。@Query使用SQL语句，返回对应的集合。

上面列了几种插入和查询的情况。

在上面介绍 实体对象间关系 中的 多对多 时，举的例子 两个实体，Playlist 和Song，以及一个中间类 PlaylistSongJoin ，下面是通过song查询playlist 和 通过playlist查询songs的代码，可以了解下：

@Dao
public interface PlaylistSongJoinDao {
    @Insert
    void insert(PlaylistSongJoin playlistSongJoin);

    @Query("SELECT * FROM playlist " +
           "INNER JOIN playlist_song_join " +
           "ON playlist.id=playlist_song_join.playlistId " +
           "WHERE playlist_song_join.songId=:songId")
    List<Playlist> getPlaylistsForSong(final int songId);

    @Query("SELECT * FROM song " +
           "INNER JOIN playlist_song_join " +
           "ON song.id=playlist_song_join.songId " +
           "WHERE playlist_song_join.playlistId=:playlistId")
    List<Song> getSongsForPlaylist(final int playlistId);
}

5. Room数据库 迁移

当应用添加或改变某些东西，需要修改实体Entity时，对应的数据库结构也会改变。这时需要保存已有的数据，进行数据库迁移。

数据库迁移，通过实现Migration这个迁移类，这个类构造指明了startVersion和endVersion（数据库类的@Database中添加的version值）, 实现了migrate方法。如下：

static final Migration MIGRATION_1_2 = new Migration(1, 2) {
    @Override
    public void migrate(SupportSQLiteDatabase database) {
        database.execSQL("CREATE TABLE `Fruit` (`id` INTEGER, "
                + "`name` TEXT, PRIMARY KEY(`id`))");
    }
};

static final Migration MIGRATION_2_3 = new Migration(2, 3) {
    @Override
    public void migrate(SupportSQLiteDatabase database) {
        database.execSQL("ALTER TABLE Book "
                + " ADD COLUMN pub_year INTEGER");
    }
};

Room.databaseBuilder(getApplicationContext(), MyDb.class, "database-name")
        .addMigrations(MIGRATION_1_2, MIGRATION_2_3).build();