【Android】Room—数据库的基本操纵

花瓣小跑  金牌会员 | 2024-10-20 09:54:15 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 806|帖子 806|积分 2418

引言

在Android开辟中，数据长期化是一个不可或缺的部分。随着应用的复杂度增加，选择合适的数据存储方式变得尤为重要。Room数据库作为Android Jetpack架构组件之一，提供了一种抽象层，使得开辟者能够以更简洁、更安全的方式操纵SQLite数据库。本文将带你深入了解Room数据库的基本概念、使用方式以及最佳实践。
核心组件

Room是一个长期化库，它提供了一个抽象层，用于在SQLite数据库中存储和查询数据。它通过注解处置惩罚器和编译时查抄，确保数据库操纵的类型安全，淘汰了运行时错误的可能性。
Entity（实体）：



  • Entity 是一个注解，用于标记一个类作为数据库中的一个表。
  • 每个 Entity 都映射到数据库中的一个表。
  • 你可以使用注解来定义表的名称（@PrimaryKey 用于定义主键，@Entity(tableName = "name")），以及定义列（@Column）。
  • 一个 Entity 类通常包含数据字段和适当的 getter 和 setter 方法。
Dao（数据访问对象）：



  • Dao 是一个接口，它定义了对数据库的操纵，如插入、查询、更新和删除。
  • 每个 Dao 都与一个 Entity 相干联，并且定义了与该 Entity 相干的数据库操纵。
  • 你可以在 Dao 接口中使用注解来定义 SQL 语句，如 @Query、@Insert、@Update、@Delete 等。
  • Room 会根据 Dao 接口自动天生实现代码。
Database（数据库）：



  • Database 是一个抽象类，它定义了整个数据库的结构，包括所有的 Dao。
  • 它使用 @Database 注解来标记，并且可以定义版本号和包含的实体。
  • 你可以使用 Room.databaseBuilder() 方法来创建数据库实例。
  • 通常，一个应用中只有一个数据库类，它包含了所有的 Dao。

示例

只说概念可能会觉得抽象照旧没有明白，接下来就通过一个示例来看看吧！
在使用room之前一定不要忘记它是要添加依赖的
  1. implementation("androidx.room:room-runtime:2.4.3")
  2. annotationProcessor("androidx.room:room-compiler:2.4.3")
复制代码
我们就设置一个学生示例吧，举行学生信息的增删改查操纵，我们将学生的信息展示在页面上，设置增删改查操纵的按钮，这部分的代码就不做说明了，你一定非常熟悉了。

  • 定义Entity：我们要存放的是学生信息，先创建一个学生类：
  1. @Entity(tableName = "student")
  2. public class student {
  3.     @PrimaryKey(autoGenerate = true)
  4.     @ColumnInfo(name = "id", typeAffinity = ColumnInfo.INTEGER)
  5.     int id;
  6.     @ColumnInfo(name = "name", typeAffinity = ColumnInfo.TEXT)
  7.     String name;
  8.     @ColumnInfo(name = "age", typeAffinity = ColumnInfo.INTEGER)
  9.     int age;
  10.     public student(int id, String name, int age) {
  11.         this.id = id;
  12.         this.name = name;
  13.         this.age = age;
  14.     }
  15.     @Ignore //告诉Room不要用这个构造方法，这是我们所用的方法
  16.     public student(String name, int age) {
  17.         this.name = name;
  18.         this.age = age;
  19.     }
  20.     @Ignore
  21.     public student(int id) {
  22.         this.id = id;
  23.     }
  24.     public int getAge() {
  25.         return age;
  26.     }
  27. }
复制代码
里面的方法大家已经写了许多遍了，接下来就给大家表明里面的注解：


  • @Entity(tableName = "student")：

    • 这个注解标记了这个类是一个数据库表的映射。tableName属性指定了数据库中表的名称，这里是"student"。

  • @PrimaryKey(autoGenerate = true)：

    • 这个注解标记了一个字段作为表的主键。autoGenerate = true表示主键值是自动天生的，通常是自增的。

  • @ColumnInfo(name = "id", typeAffinity = ColumnInfo.INTEGER)：

    • 这个注解提供了字段的额外信息。name属性指定了数据库中列的名称，这里是"id"。typeAffinity属性指定了列的数据类型，这里是ColumnInfo.INTEGER，表示这个字段在数据库中是整型。

   

  • ColumnInfo.INTEGER：表示列的数据类型为整型。
  • ColumnInfo.TEXT：表示列的数据类型为文本。
  • ColumnInfo.REAL：表示列的数据类型为浮点数。
  • ColumnInfo.BLOB：表示列的数据类型为二进制数据（比方图片或文件）。
  • ColumnInfo.FLOAT：表示列的数据类型为浮点数，与REAL类似，但更明白表示为浮点数。
  • ColumnInfo.LONG：表示列的数据类型为长整型。
  • ColumnInfo.SHORT：表示列的数据类型为短整型。
  • ColumnInfo.BOOLEAN：表示列的数据类型为布尔值。
  

  • @Ignore：

    • 这个注解用于告诉Room忽略接下来的构造函数，不将其作为数据库操纵的一部分。这通常用于那些仅用于应用逻辑，而不是数据库操纵的构造函数。


  • 定义DAO：创建一个接口来定义数据访问对象（DAO），使用@Dao注解标记。在这个接口中，定义方法来执行数据库操纵，如插入、查询、更新和删除。
  1. @Dao
  2. public interface StudentDao {
  3.     @Insert
  4.     void insertStudent(student... students);
  5.     @Delete
  6.     void deleteStudent(student... students);
  7.     @Update
  8.     void updateStudent(student... students);
  9.     @Query("SELECT * FROM student")
  10.     List<student> getAllStudent();
  11.     @Query("SELECT * FROM student WHERE id = :id")
  12.     List<student> getStudentById(int id);
  13. }
复制代码
都是接口当中定义的方法名，这里的注解大家也都见过，在学习SQLite的时间对这四个方法用了许多次了，这里是直接使用注解，来标记这个方法。看末了一个注解就是为了告诉它根据表的id来寻找你所要查找的学生信息。

  • 定义Database：创建一个抽象类来继续RoomDatabase，并使用@Database注解标记。在这个类中，定义数据库的版本和包含的实体和DAO。
  1. @Database(entities = {student.class}, version = 1, exportSchema = false)
  2. public abstract class MyDataBase extends RoomDatabase {
  3.     private static MyDataBase mInstance;
  4.     private static final String DATABASE_NAME = "my_db.db";
  5.     public static synchronized MyDataBase getInstance(Context context) {
  6.         if (mInstance == null) {
  7.             mInstance = Room.databaseBuilder(context.getApplicationContext(), MyDataBase.class, DATABASE_NAME).build();
  8.         }
  9.         return mInstance;
  10.     }
  11.     public abstract StudentDao getStudentDao(); //Room会帮我们自动实现
  12. }
复制代码


  • @Database(entities = {student.class}, version = 1, exportSchema = false)：

    • @Database注解用于定义数据库的设置。它告诉Room这个数据库包含哪些实体（entities），数据库的版本（version），以及其他一些设置项。
    • entities = {student.class}：指定了这个数据库包含的实体类。在这个例子中，它包含student实体。
    • version = 1：指定了数据库的版本号。当数据库结构发生变革时（比方添加、删除或修改实体），必要增加这个版本号。
    • exportSchema = false：指定是否答应Room导出数据库的schema文件。如果设置为true，Room会在编译时天生一个包含数据库schema的文件，这有助于调试和测试。在这个例子中，它被设置为false，意味着不导出schema文件。

  • public abstract class MyDataBase extends RoomDatabase：

    • 定义了一个名为MyDataBase的抽象类，它继续自RoomDatabase。这个类将作为数据库的顶层接口，用于创建和管理数据库实例。

  • private static MyDataBase mInstance;：

    • 定义了一个静态的MyDataBase实例，用于实现数据库的单例模式。这样可以确保整个应用步伐中只有一个数据库实例。

  • private static final String DATABASE_NAME = "my_db.db";：

    • 定义了一个常量，指定了数据库文件的名称。在这个例子中，数据库文件将被命名为my_db.db。

  • public static synchronized MyDataBase getInstance(Context context)：

    • 定义了一个静态方法，用于获取数据库的单例实例。这个方法使用了synchronized关键字来确保线程安全，避免在多线程环境下创建多个数据库实例。
    • context.getApplicationContext()：获取应用步伐级别的上下文，用于创建数据库实例。

  • if (mInstance == null) { mInstance = Room.databaseBuilder(...).build(); }：

    • 如果mInstance为null，则使用Room.databaseBuilder()方法创建一个新的数据库实例。这个方法链式调用了多个设置方法，包括指定数据库类、数据库名称、以及数据库构建的其他设置。

  • public abstract StudentDao getStudentDao();：

    • 定义了一个抽象方法，用于获取StudentDao的实例。Room在编译时会为这个方法天生实现代码，这样你就可以在应用步伐中通过调用getStudentDao()来获取StudentDao的实例，进而执行数据库操纵。


  • 接下来就可以为按钮注册点击事件，运行步伐看数据的更改了
  1. public class MainActivity extends AppCompatActivity {
  2.     StudentDao studentDao;
  3.     @Override
  4.     protected void onCreate(Bundle savedInstanceState) {
  5.         //......获取按钮，页面的滚动控件
  6.         buttonAdd.setOnClickListener(new View.OnClickListener() {
  7.             @Override
  8.             public void onClick(View v) {
  9.                 student s1 = new student("Jack", 20);
  10.                 student s2 = new student("Rose", 30);
  11.                 new InsertStudentTask(studentDao).execute(s1, s2);
  12.             }
  13.         });
  14.         buttonResearch.setOnClickListener(new View.OnClickListener() {
  15.             @Override
  16.             public void onClick(View v) {
  17.                 new GetAllStudentTask(studentDao).execute();
  18.             }
  19.         });
  20.         buttonUpdata.setOnClickListener(new View.OnClickListener() {
  21.             @Override
  22.             public void onClick(View v) {
  23.                 student s1 = new student(3,"Tason", 21);
  24.                 new UpdataStudentTask(studentDao).execute(s1);
  25.             }
  26.         });
  27.         buttonDelete.setOnClickListener(new View.OnClickListener() {
  28.             @Override
  29.             public void onClick(View v) {
  30.                 student s1 = new student(2);
  31.                 new DeleteStudentTask(studentDao).execute(s1);
  32.             }
  33.         });
  34.     }
  36.     class DeleteStudentTask extends AsyncTask<student, Void, Void> {
  37.         private StudentDao studentDao;
  38.         public DeleteStudentTask(StudentDao studentDao) {
  39.             this.studentDao = studentDao;
  40.         }
  42.         @Override
  43.         protected Void doInBackground(student... students) {
  44.             studentDao.deleteStudent(students);
  45.             return null;
  46.         }
  47.     }
  48.     class UpdataStudentTask extends AsyncTask<student, Void, Void> {
  49.         private StudentDao studentDao;
  50.         public UpdataStudentTask(StudentDao studentDao) {
  51.             this.studentDao = studentDao;
  52.         }
  54.         @Override
  55.         protected Void doInBackground(student... students) {
  56.             studentDao.updateStudent(students);
  57.             return null;
  58.         }
  59.     }
  60.     class InsertStudentTask extends AsyncTask<student, Void, Void> {
  61.         private StudentDao studentDao;
  63.         public InsertStudentTask(StudentDao studentDao) {
  64.             this.studentDao = studentDao;
  65.         }
  67.         @Override
  68.         protected Void doInBackground(student... students) {
  69.             studentDao.insertStudent(students);
  70.             return null;
  71.         }
  72.     }
  73.     class GetAllStudentTask extends AsyncTask<Void, Void, List<student>> {
  74.         private StudentDao studentDao;
  76.         public GetAllStudentTask(StudentDao studentDao) {
  77.             this.studentDao = studentDao;
  78.         }
  79.         @Override
  80.         protected List<student> doInBackground(Void... voids) {
  81.             return studentDao.getAllStudent();
  82.         }
  84.         @Override
  85.         protected void onPostExecute(List<student> students) {
  86.             super.onPostExecute(students);
  87.             studentRecyclerViewAdapter.setstudent(students);
  88.             studentRecyclerViewAdapter.notifyDataSetChanged();
  89.         }
  90.     }
  91. }
复制代码
注意我们不在主线程举行数据库的相干操纵，
接下来就运行一下：

当我们举行增加操纵，页面没有发生变革，我们点击查询操纵，我们在上面的代码当中知道没当按下查询操纵就会获取所有的学生信息，并将其展示在页面的滚动控件当中：

再看看删除和修改操纵吧，上面的代码我们将2号学生删除，并修改3号学生的信息，操纵后按下查询按钮：

优化

我们看到数据库的信息已经修改了。每次修改都要举行查询才能看到更新的信息就很麻烦，而且你也不知道到底有没有跟新就要举行查询操纵，在之前我们学习了LiveData每当数据变革，就会自动告诉View，使其自动更新，那不就大大优化了步伐吗

官方给出的架构指南，Model当中使用Room访问SQLite的内容。接下来就看看如何使用吧！
1、2、3步是一样的，这里就不多说了，只是对于数据库的操纵有轻微的修改，第一次学习写的就不修改了，大家看看吧
  1. @Dao
  2. public interface StudentDao {
  3.     @Insert
  4.     void insertStudent(student... students);
  5.     @Delete
  6.     void deleteStudent(student... students);
  7.     @Update
  8.     void updateStudent(student... students);
  9.     @Query("DELETE FROM student")
  10.     void deleteAllAtudent();
  11.     @Query("SELECT * FROM student")
  12.     LiveData<List<student>> getAllStudentsLive();
  13. }
复制代码

  • 创建Repository：Repository作为数据层的抽象，封装了数据来源，它可以是一个类，包含了一系列方法来执行数据库操纵。这些方法通常会调用DAO中定义的操纵，并将结果包装成LiveData或Flow对象，以便ViewModel可以观察数据变革。
  1. public class StudentRepository {
  2.     private StudentDao studentDao;
  4.     public StudentRepository(Context context) {
  5.         MyDataBase dataBase = MyDataBase.getInstance(context);
  6.         this.studentDao = dataBase.getStudentDao();
  7.     }
  8.     //对数据进行添加
  9.     public void insertStudent(student... students) {
  10.         new InsertStudentTask(studentDao).execute(students);
  11.     }
  12.     class InsertStudentTask extends AsyncTask<student, Void, Void> {
  13.         private StudentDao studentDao;
  14.         public InsertStudentTask(StudentDao studentDao) {
  15.             this.studentDao = studentDao;
  16.         }
  17.         @Override
  18.         protected Void doInBackground(student... students) {
  19.             studentDao.insertStudent(students);
  20.             return null;
  21.         }
  22.     }
  23.     //对数据进行修改
  24.     public void updateStudent(student... students) {
  25.         new UpdataStudentTask(studentDao).execute(students);
  26.     }
  27.     class UpdataStudentTask extends AsyncTask<student, Void, Void> {
  28.         private StudentDao studentDao;
  29.         public UpdataStudentTask(StudentDao studentDao) {
  30.             this.studentDao = studentDao;
  31.         }
  33.         @Override
  34.         protected Void doInBackground(student... students) {
  35.             studentDao.updateStudent(students);
  36.             return null;
  37.         }
  38.     }
  39.     //对数据进行删除
  40.     public void deleteStudent(student... students) {
  41.         new DeleteStudentTask(studentDao).execute(students);
  42.     }
  43.     class DeleteStudentTask extends AsyncTask<student, Void, Void> {
  44.         private StudentDao studentDao;
  45.         public DeleteStudentTask(StudentDao studentDao) {
  46.             this.studentDao = studentDao;
  47.         }
  48.         @Override
  49.         protected Void doInBackground(student... students) {
  50.             studentDao.deleteStudent(students);
  51.             return null;
  52.         }
  53.     }
  54.     //对数据进行查找
  55.     public LiveData<List<student>> getAllStudentsLive() {
  56.         return studentDao.getAllStudentsLive();
  57.     }
  58.     //将所有数据都删除
  59.     public void deleteAllStudent() {
  60.         new DeleteAllStudentTask(studentDao).execute();
  61.     }
  62.     class DeleteAllStudentTask extends AsyncTask<Void, Void, Void> {
  63.         private StudentDao studentDao;
  64.         public DeleteAllStudentTask(StudentDao studentDao) {
  65.             this.studentDao = studentDao;
  66.         }
  67.         @Override
  68.         protected Void doInBackground(Void... voids) {
  69.             studentDao.deleteAllAtudent();
  70.             return null;
  71.         }
  72.     }
  73. }
复制代码


  • 构造函数：

    • StudentRepository的构造函数吸收一个Context对象，用它来获取数据库的实例。MyDataBase.getInstance(context)是一个单例模式的数据库实例获取方法，确保整个应用中只有一个数据库实例。

  • 异步使命（AsyncTask）：

    • InsertStudentTask、UpdataStudentTask、DeleteStudentTask和DeleteAllStudentTask是内部类，它们继续自AsyncTask。这些类用于在后台线程上执行数据库操纵，以避免阻塞主线程。
    • AsyncTask已经被标记为过期，推荐使用java.util.concurrent包中的类、Kotlin Coroutines或者其他现代的并发办理方案。

  • doInBackground方法：

    • 在AsyncTask的doInBackground方法中执行实际的数据库操纵。这个方法在后台线程上运行，吸收的参数是传递给execute方法的参数。

  • LiveData：

    • getAllStudentsLive方法返回一个LiveData对象，它包含了数据库中所有学生数据的列表。LiveData是一个可观察的数据存储器，它具有生命周期感知能力，只会在观察者处于活泼状态时发送数据更新。


  • 使用ViewModel：ViewModel负责管理UI相干的数据，它可以调用Repository中的方法来获取数据，并根据数据变革更新UI。ViewModel使用LiveData或Flow作为数据的载体，这样当数据发生变革时，UI可以自动更新。
  1. public class StudentViewModel extends AndroidViewModel {
  2.     //当要使用上下文的时候使用AndroidViewModel
  3.     private StudentRepository repository;
  4.     public StudentViewModel(@NonNull Application application) {
  5.         super(application);
  6.         this.repository = new StudentRepository(application);
  7.     }
  8.     public void insertStudent(student... students) {
  9.         repository.insertStudent(students);
  10.     }
  11.     public void deleteStudent(student... students) {
  12.         repository.deleteStudent(students);
  13.     }
  14.     public void deleteAllStudent() {
  15.         repository.deleteAllStudent();
  16.     }
  17.     public void updateStudent(student... students) {
  18.         repository.updateStudent(students);
  19.     }
  20.     public LiveData<List<student>> research() {
  21.         return repository.getAllStudentsLive();
  22.     }
  23. }
复制代码

  • 观察数据变革：在UI层（如Activity或Fragment），观察ViewModel中的LiveData或Flow对象。当数据发生变革时，UI层会收到通知并更新界面。
  1. studentViewModel = new ViewModelProvider(this, new ViewModelProvider.AndroidViewModelFactory(getApplication())).get(StudentViewModel.class);
  2. studentViewModel.research().observe(this, new Observer<List<student>>() {
  3.     @Override
  4.     public void onChanged(List<student> students) {
  5.         studentRecyclerViewAdapter.setstudent(students);
  6.         studentRecyclerViewAdapter.notifyDataSetChanged();
  7.     }
  8. }); //为其注册监听，到获取到的数据库内容进行变化，就更新UI
  9. buttonAdd.setOnClickListener(new View.OnClickListener() {
  10.     @Override
  11.     public void onClick(View v) {
  12.         student s1 = new student("Jack", 20);
  13.         student s2 = new student("Rose", 30);
  14.         studentViewModel.insertStudent(s1,s2);
  15.     }
  16. }); //只展示一个按钮的点击事件，其他的你也肯定会写了
复制代码
接下来就运行步伐看看吧！
我们举行了增加删除修改操纵，页面直接自己更新了，带来了很大的便利

按下清空页面就没有了，数据库就被清空了！
本篇内容介绍了数据库的基本操纵，感谢你的阅读！
文章到这里就竣事了！

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

花瓣小跑

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表