Android --- Room数据库(Java)

概念 

Room 是一个长期性库，属于 Android Jetpack 的一部门。Room 是 SQLite 数据库之上的一个抽象层。SQLite 使用一种专门的语言 (SQL) 来实行数据库操作。Room 并不直接使用 SQLite，而是负责简化数据库设置和设置以及与数据库交互方面的噜苏工作。此外，Room 还提供 SQLite 语句的编译时检查。
添加 Room 库

• 打开模块级 gradle 文件 build.gradle (Module: InventoryApp.app)。在 dependencies 块中，为 Room 库添加以下依赖项。
  

1. // Room
2. implementation ("androidx.room:room-runtime:2.2.6")
3. implementation ("androidx.room:room-ktx:2.2.6")
4. testImplementation ("androidx.room:room-testing:2.2.6")

复制代码

Room 三大组件

• 数据实体 Entry 表示应用的数据库中的表。数据实体用于更新表中的行所存储的数据以及创建新行供插入。
  
• 数据访问对象 (DAO) 提供应用在数据库中检索、更新、插入和删除数据所用的方法。
  
• 数据库类持有数据库，并且是应用数据库底层毗连的重要访问点。数据库类为应用提供与该数据库关联的 DAO 的实例。
  

创建数据实体 Entry

实体类界说了一个表，该类的每个实例表示数据库表中的一行。实体类以映射告知 Room 它打算如何呈现数据库中的信息并与之交互。
   @Entry 注解用于将某个类标记为数据库实体类。对于每个实体类，系统都会创建一个数据库表来生存相关项。除非另行阐明，否则实体的每个字段在数据库中都表示为一列（如需了解详情，请参阅实体文档）。
  存储在数据库中的每个实体实例都必须有一个主键。主键用于唯一标识数据库表中的每个记录/条目。主键一旦赋值就不能修改，只要它还存在于数据库中，它就表示相应的实体对象。
  

• 在 数据类声明的上方，为该数据类添加 @Entity 注解。使用 tableName 参数为这个实体类指定 SQLite 表的名称。
  
• 如需将 id 标识为主键，请为 id 属性添加 @PrimaryKey 注解。将参数 autoGenerate 设为 true，让 Room 为每个实体天生 ID。这样做可以包管每个商品的 ID 一定是唯一的。
  
• 为其余属性添加 @ColumnInfo 注解。ColumnInfo 注解用于自界说与特定字段关联的列。例如，使用 name 参数时，您可以为字段指定差别的列名称，而不是变量名称。如下所示，使用参数自界说属性名称。此方法类似于使用 tableName 为数据库指定差别的名称。
  

1. // 账单数据类
2. @Entity(tableName = "AccountListItemTable")
3. public class AccountDataItem {
4.     @PrimaryKey(autoGenerate = true)
5.     private int id = 0;
6.     private String money; // 账单金额
7.     private String type; // 消费类别 -餐饮类
8.     private String detail; // 消费详情(备注)
9.     private String data; //消费时间
10.     private int in; // 1.收入 2.支出
12.     public AccountDataItem(String money, String type, String detail, String data, int in) {
13.         this.money = money;
14.         this.type = type;
15.         this.detail = detail;
16.         this.data = data;
17.         this.in = in;
18.     }
20.     public int getId() {
21.         return id;
22.     }
24.     public void setId(int id) {
25.         this.id = id;
26.     }
28.     public String getMoney() {
29.         return money;
30.     }
32.     public void setMoney(String money) {
33.         this.money = money;
34.     }
36.     public String getType() {
37.         return type;
38.     }
40.     public void setType(String type) {
41.         this.type = type;
42.     }
44.     public String getDetail() {
45.         return detail;
46.     }
48.     public void setDetail(String detail) {
49.         this.detail = detail;
50.     }
52.     public String getData() {
53.         return data;
54.     }
56.     public void setData(String data) {
57.         this.data = data;
58.     }
60.     public int getIn() {
61.         return in;
62.     }
64.     public void setIn(int in) {
65.         this.in = in;
66.     }
68.     @NonNull
69.     @Override
70.     public String toString() {
71.         return getId()+getDetail()+getMoney();
72.     }
73. }

复制代码

创建数据访问对象 DAO

数据访问对象 (DAO) 是一种模式，其作用是通过提供抽象接口将长期性层与应用的其余部门分离。这种分离依照您曾在之前的 Codelab 中打仗过的单一责任原则。
DAO 的功能在于，让在底层长期性层实行数据库操作所涉及的所有复杂性都不波及应用的其余部门。这样就可以独立于使用数据的代码更改数据访问层。

1. public interface AccountDao{
2.     @Insert
3.     void insertAccount(AccountDataItem AccountDataItem);
5.     @Update
6.     void update(AccountDataItem AccountDataItem);
7.    
8.     @Query("SELECT * FROM AccountListItemTable")
9.     List<AccountDataItem> getAllData();
10.    
11.     @Query("DELETE FROM AccountListItemTable")
12.     void delete();
13. }

复制代码

创建数据库实例

在此任务中，您将创建一个 RoomDatabase，它将使用您在上一个任务中创建的 Entity 和 DAO。该数据库类用于界说实体和数据访问对象的列表。它也是底层毗连的重要访问点。

• Room 是 SQLite 数据库之上的数据库层。
  
• Room 可以帮您处置惩罚以前必要用 SQLiteOpenHelper 处置惩罚的一样平常任务 SQLiteOpenHelper。
  
• Room 使用 DAO 向其数据库发出查询。
  
• 默认情况下，为了避免糟糕的 UI 性能，Room 不允许您在主线程上发出查询。当 Room 查询返回 LiveData 时，查询会自动在后台线程上异步运行。
  

   在LiveData的官方文档中有提到LiveData可以和Room数据库一起使用
  也就是说Room查询时可以直接返回一个LiveData对象，给这个LiveData对象添加观察者之后只要数据库数据发生改变都可以收到回调。
  

• Room 提供 SQLite 语句的编译时检查。
  

1. package com.example.accountapp.data;
3. import android.content.Context;
4. import androidx.room.Database;
5. import androidx.room.Room;
6. import androidx.room.RoomDatabase;
7. import com.example.accountapp.data.Dao.AccountListDao;
8. import com.example.accountapp.data.Entry.AccountDataItem;
9. import java.util.concurrent.ExecutorService;
10. import java.util.concurrent.Executors;
12. @Database(entities = {AccountDataItem.class},version = 1,exportSchema = false)
13. public abstract class AppRoomDataBase extends RoomDatabase {
14.     private static volatile AppRoomDataBase INSTANCE;
15.     public abstract AccountListDao accountListDao();
17.     static final ExecutorService databaseWriteExecutor = Executors.newFixedThreadPool(4);
19.     // 单例模式
20.     public static AppRoomDataBase getDataBase(Context context){
21.         if (INSTANCE == null) {
22.             synchronized (AppRoomDataBase.class) {
23.                 if (INSTANCE == null) {
24.                     INSTANCE = Room.databaseBuilder(
25.                                    context.getApplicationContext(),
26.                                     AppRoomDataBase.class,
27.                                     "记账数据库"
28.                             )
29.                             .build();
30.                 }
31.             }
32.         }
33.         return INSTANCE;
34.     }
35. //    public abstract AccountDao accountDao();
36. }

复制代码

  

• Room 数据库类必须是 abstract 并扩展 RoomDatabase。通常，整个应用程序只必要一个 Room 数据库实例,数据库应该使用单例模式。
  
• 创建一个抽象 RoomDatabase 类，使用 @Database 注解将该类注释为 Room 数据库并在其中声明属于数据库的实体并设置版本号。
  
• 每个实体对应于将在数据库中创建的表。数据库迁移超出了本代码实验室的范围，因此我们exportSchema在此处将其设置为 false 以避免出现构建警告。在实际应用中，您应该思量为 Room 设置一个目次以用于导出架构，以便您可以将当前架构签入版本控制系统。
  
• 通过每个@Dao的抽象“getter”方法来公开 DAO。
  
• 创建了一个ExecutorService固定的线程池，您可以使用它在后台线程上异步运行数据库操作。 
  

  数据存储库 

   抽象了对多个数据源的访问。存储库不是架构组件库的一部门，但它是代码分离和架构的最佳实践。
为应用程序其余部门的数据访问提供了干净的 API。
  

使用

1. public class DataRepository {
2.     private AccountDao accountDao;
3.     private AccountListDao accountListDao;
4.     private Context context;
5.     AppRoomDataBase appRoomDataBase;
7.     public DataRepository(Context context) {
8.         this.context = context;
9.         appRoomDataBase = AppRoomDataBase.getDataBase(context);
10.         accountDao = appRoomDataBase.accountDao();
11.         accountListDao = appRoomDataBase.accountListDao();
12.     }
14.     public void insert(AccountDataItem accountDataItem) {
15.         AppRoomDataBase.databaseWriteExecutor.execute(new Runnable() {
16.             @Override
17.             public void run() {
18.                 accountDao.insertAccount(accountDataItem);
19.             }
20.         });
21.     }
23.     public interface ListDataLoadListener {
24.         void onDataLoaded(List<AccountData> data);
25.     }
27.     public interface DataLoadListener {
28.         void onDataLoaded(List<AccountDataItem> data);
29.     }
30.     public void getData(DataLoadListener listener){
31.         AppRoomDataBase.databaseWriteExecutor.execute(() -> {
32.             List<AccountDataItem> accountDataItems = new ArrayList<>();
33.             accountDataItems.addAll(accountDao.getAllData());
34.             if(listener != null){
35.                 listener.onDataLoaded(accountDataItems);
36.             }
37.         });
38.     }
39. }

复制代码

• DAO 被传递到存储库构造函数中，而不是整个数据库。这是由于您只必要访问 DAO，由于它包罗数据库的所有读/写方法。无需将整个数据库公开给存储库。
  
• 我们不必要在主线程上运行插入，所以我们使用ExecutorService在中创建的WordRoomDatabase在后台线程上实行插入
  

LiveData 

在数据存储库中的代码可见，每次数据库中的数据发生变化后，我们都必要开启一个工作线程去获取数据库中的内容，这不太方便，因此可以使用LiveData
LiveData，一个 用于数据观察的生命周期库类，解决了这个题目。在方法描述中使用LiveData范例的返回值 ，Room 会在数据库更新时天生所有必要的代码来更新LiveData。
   留意：如果您LiveData独立于 Room 使用，则必须管理数据更新。LiveData没有公开可用的方法来更新存储的数据。
  如果要更新存储在 LiveData中的数据，则必须使用 MutableLiveData而不是LiveData。该类MutableLiveData有两个公共方法允许您设置对象的值LiveData， setValue(T)和 postValue(T)。通常，MutableLiveData在 中使用 ViewModel，然后仅向观察者ViewModel公开不可变对象，LiveData
  存储库 

1. public class DataRepository {
2.     private AccountDao accountDao;
3.     private AccountListDao accountListDao;
4.     private Context context;
5.     AppRoomDataBase appRoomDataBase;
7.     public DataRepository(Context context) {
8.         this.context = context;
9.         appRoomDataBase = AppRoomDataBase.getDataBase(context);
10.         accountDao = appRoomDataBase.accountDao();
11.         accountListDao = appRoomDataBase.accountListDao();
12.     }
14.     public void insert(AccountDataItem accountDataItem) {
15.         AppRoomDataBase.databaseWriteExecutor.execute(new Runnable() {
16.             @Override
17.             public void run() {
18.                 accountDao.insertAccount(accountDataItem);
19.             }
20.         });
21.     }
23.     public LiveData<List<AccountDataItem>> getData() {
24.         return accountDao.getAllData();
25.     }
26. }

复制代码

 Dao

1. @Dao
2. public interface AccountDao{
3.     @Insert
4.     void insertAccount(AccountDataItem AccountDataItem);
6.     @Update
7.     void update(AccountDataItem AccountDataItem);
9.     @Query("SELECT * FROM AccountListItemTable")
10.     LiveData<List<AccountDataItem>> getAllData();
12.     @Query("DELETE FROM AccountListItemTable")
13.     void delete();
14. }

复制代码

使用：

1. private void initData() {
2.         DataRepository dataRepository = new DataRepository(getContext());
3.         dataRepository.getData().observe(getViewLifecycleOwner(), new Observer<List<AccountDataItem>>() {
4.             @Override
5.             public void onChanged(List<AccountDataItem> accountDataItems) {
6.                 System.out.println("数据更新了"+accountDataItems.size());
7.             }
8.         })

复制代码

ViewModel

什么是 ViewModel？

ViewModel的作用是向 UI 提供数据并在设置更改后继续存在。ViewModel充当 Repository 和 UI 之间的通信中心。可以使用ViewModel在 Fragment 之间共享数据。ViewModel 是 生命周期库的一部门。

在 ViewModel中，使用LiveData表示 UI 将使用或表现的可更改数据。使用LiveData有几个好处：

• 您可以将观察者放在数据上（而不是轮询更改），并且仅在数据实际更改时更新 UI。
  
• 存储库和 UI 完全由 ViewModel分开。
  
• 没有来自的数据库调用ViewModel（这一切都在存储库中处置惩罚），从而使代码更易于测试。
  

1. public class AccountViewModel extends AndroidViewModel {
2.     private DataRepository dataRepository;
3.     private LiveData<List<AccountDataItem>> listLiveData;
5.     public AccountViewModel(@NonNull Application application) {
6.         super(application);
7.         dataRepository = new DataRepository(application);
8.         listLiveData = dataRepository.getData();
9.     }
11.     public LiveData<List<AccountDataItem>> getListLiveData() {
12.         return listLiveData;
13.     }
14.     public void insert(AccountDataItem accountDataItem){
15.         dataRepository.insert( accountDataItem);
16.     }
17. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。