2-2.Jetpack 之 Room 简单编码模板（优化版）（Entity、DAO、Database、Repository）

最新推荐文章于 2024-11-01 12:20:35 发布
最新推荐文章于 2024-11-01 12:20:35 发布
阅读量1.6k 收藏 14
点赞数 40
分类专栏： Android - Jetpack 简化编程 文章标签： 数据库 android-studio android studio android jetpack android sqlite 安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52173250/article/details/142679299
版权

一、Room

1、Room 概述
  • Room 是 Jetpack 中的一个重要成员，它是一个持久化库，它为管理数据库提供了简单强大的方法
2、Room 引入
  • 在模块级 build.gradle 中引入相关依赖
implementation "androidx.room:room-runtime:2.2.5"
annotationProcessor "androidx.room:room-compiler:2.2.5"

二、Room 简单案例

1、Application
  • MyApplication.java
package com.my.room.application;

import android.app.Application;
import android.content.Context;

public class MyApplication extends Application {

    public static final String TAG = MyApplication.class.getSimpleName();

    private static Context context;

    @Override
    public void onCreate() {
        super.onCreate();

        context = this;
    }

    public static Context getContext() {
        return context;
    }
}
2、Entity
  • Staff.java
package com.my.room.entity;

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

@Entity(tableName = "Staff")
public class Staff {

    @PrimaryKey(autoGenerate = true)
    public Long id;

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

    @ColumnInfo(name = "age")
    public Integer age;

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

    @Override
    public String toString() {
        return "Staff{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", cardNum='" + cardNum + '\'' +
                '}';
    }
}
3、DAO
  • StaffDAO.java
package com.my.room.dao;

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

import com.my.room.entity.Staff;

import java.util.List;

@Dao
public interface StaffDAO {

    @Insert
    void insert(Staff staff);

    @Delete
    void delete(Staff staff);

    @Update
    void update(Staff staff);

    @Query("SELECT * FROM Staff")
    List<Staff> queryAll();
}
4、Database
  • MyDatabase.java
package com.my.room.database;

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

import com.my.room.application.MyApplication;
import com.my.room.dao.StaffDAO;
import com.my.room.entity.Staff;

@Database(entities = {Staff.class}, version = 1, exportSchema = false)
public abstract class MyDatabase extends RoomDatabase {

    public static final String TAG = MyDatabase.class.getSimpleName();

    public static final String DATABASE_NAME = "test.db";

    private static MyDatabase myDatabase;

    public static MyDatabase getInstance() {
        if (myDatabase == null) {
            myDatabase = Room.databaseBuilder(MyApplication.getContext(), MyDatabase.class, DATABASE_NAME)
                    .build();
        }
        return myDatabase;
    }

    public abstract StaffDAO getStaffDAO();
}
5、Repository Observer
  1. InsertObserver.java
package com.my.room.repository.observer;

public interface InsertObserver {
    void onSuccess();
    void onError(String msg);
}
  1. DeleteObserver.java
package com.my.room.repository.observer;

public interface DeleteObserver {
    void onSuccess();
    void onError(String msg);
}
  1. UpdateObserver.java
package com.my.room.repository.observer;

public interface UpdateObserver {
    void onSuccess();
    void onError(String msg);
}
  1. QueryAllObserver.java
package com.my.room.repository.observer;

import java.util.List;

public interface QueryAllObserver<T> {
    void onResult(List<T> ts);
}
6、Repository
  1. RepositoryItem.java
package com.my.room.repository;

public class RepositoryItem<T> {
    public static final int CODE_SUCCESS = 1;
    public static final int CODE_ERROR = 2;

    private int code;
    private String msg;
    private T data;

    public RepositoryItem(int code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "RepositoryItem{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}
  1. StaffRepository.java
package com.my.room.repository;

import android.os.AsyncTask;

import com.my.room.dao.StaffDAO;
import com.my.room.database.MyDatabase;
import com.my.room.entity.Staff;
import com.my.room.repository.observer.DeleteObserver;
import com.my.room.repository.observer.InsertObserver;
import com.my.room.repository.observer.QueryAllObserver;
import com.my.room.repository.observer.UpdateObserver;

import java.util.List;

public class StaffRepository {
    private MyDatabase myDatabase;
    private StaffDAO staffDAO;

    public StaffRepository() {
        myDatabase = MyDatabase.getInstance();
        staffDAO = myDatabase.getStaffDAO();
    }

    // ====================================================================================================

    public void insert(Staff staff, InsertObserver insertObserver) {
        new InsertAsyncTask(staff, insertObserver).execute();
    }

    public void delete(Staff staff, DeleteObserver deleteObserver) {
        new DeleteAsyncTask(staff, deleteObserver).execute();
    }

    public void update(Staff staff, UpdateObserver updateObserver) {
        new UpdateAsyncTask(staff, updateObserver).execute();
    }

    public void queryAll(QueryAllObserver<Staff> queryAllObserver) {
        new QueryAllAsyncTask(queryAllObserver).execute();
    }

    // ====================================================================================================

    private class InsertAsyncTask extends AsyncTask<Void, Void, RepositoryItem<Object>> {

        private Staff staff;
        private InsertObserver insertObserver;

        public InsertAsyncTask(Staff staff, InsertObserver insertObserver) {
            this.staff = staff;
            this.insertObserver = insertObserver;
        }

        @Override
        protected RepositoryItem doInBackground(Void... voids) {
            try {
                staffDAO.insert(staff);
                return new RepositoryItem(RepositoryItem.CODE_SUCCESS, null, null);
            } catch (Exception e) {
                e.printStackTrace();
                return new RepositoryItem(RepositoryItem.CODE_ERROR, e.getMessage(), null);
            }
        }

        @Override
        protected void onPostExecute(RepositoryItem repositoryItem) {
            super.onPostExecute(repositoryItem);

            if (repositoryItem.getCode() == RepositoryItem.CODE_SUCCESS) {
                insertObserver.onSuccess();
            } else {
                insertObserver.onError(repositoryItem.getMsg());
            }
        }
    }

    private class DeleteAsyncTask extends AsyncTask<Void, Void, RepositoryItem<Object>> {

        private Staff staff;
        private DeleteObserver deleteObserver;

        public DeleteAsyncTask(Staff staff, DeleteObserver deleteObserver) {
            this.staff = staff;
            this.deleteObserver = deleteObserver;
        }

        @Override
        protected RepositoryItem<Object> doInBackground(Void... voids) {
            try {
                staffDAO.delete(staff);
                return new RepositoryItem(RepositoryItem.CODE_SUCCESS, null, null);
            } catch (Exception e) {
                e.printStackTrace();
                return new RepositoryItem(RepositoryItem.CODE_ERROR, e.getMessage(), null);
            }
        }

        @Override
        protected void onPostExecute(RepositoryItem<Object> repositoryItem) {
            super.onPostExecute(repositoryItem);

            if (repositoryItem.getCode() == RepositoryItem.CODE_SUCCESS) {
                deleteObserver.onSuccess();
            } else {
                deleteObserver.onError(repositoryItem.getMsg());
            }
        }
    }

    private class UpdateAsyncTask extends AsyncTask<Void, Void, RepositoryItem<Object>> {

        private Staff staff;
        private UpdateObserver updateObserver;

        public UpdateAsyncTask(Staff staff, UpdateObserver updateObserver) {
            this.staff = staff;
            this.updateObserver = updateObserver;
        }

        @Override
        protected RepositoryItem<Object> doInBackground(Void... voids) {
            try {
                staffDAO.update(staff);
                return new RepositoryItem(RepositoryItem.CODE_SUCCESS, null, null);
            } catch (Exception e) {
                e.printStackTrace();
                return new RepositoryItem(RepositoryItem.CODE_ERROR, e.getMessage(), null);
            }
        }

        @Override
        protected void onPostExecute(RepositoryItem<Object> repositoryItem) {
            super.onPostExecute(repositoryItem);

            if (repositoryItem.getCode() == RepositoryItem.CODE_SUCCESS) {
                updateObserver.onSuccess();
            } else {
                updateObserver.onError(repositoryItem.getMsg());
            }
        }
    }

    private class QueryAllAsyncTask extends AsyncTask<Void, Void, RepositoryItem<List<Staff>>> {

        private QueryAllObserver<Staff> queryAllObserver;


        public QueryAllAsyncTask(QueryAllObserver<Staff> queryAllObserver) {
            this.queryAllObserver = queryAllObserver;
        }

        @Override
        protected RepositoryItem<List<Staff>> doInBackground(Void... voids) {
            try {
                List<Staff> staffs = staffDAO.queryAll();
                return new RepositoryItem(RepositoryItem.CODE_SUCCESS, null, staffs);
            } catch (Exception e) {
                e.printStackTrace();
                return new RepositoryItem(RepositoryItem.CODE_ERROR, e.getMessage(), null);
            }
        }

        @Override
        protected void onPostExecute(RepositoryItem<List<Staff>> repositoryItem) {
            super.onPostExecute(repositoryItem);

            queryAllObserver.onResult(repositoryItem.getData());
        }
    }
}
7、Activity Layout
  • activity_staff.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".StaffActivity">

    <Button
        android:id="@+id/btn_insert"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="增"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:id="@+id/btn_delete"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="删"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/btn_insert" />

    <Button
        android:id="@+id/btn_update"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="改"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/btn_delete" />

    <Button
        android:id="@+id/btn_query_all"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="查"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/btn_update" />
</androidx.constraintlayout.widget.ConstraintLayout>
8、Activity Code
  • StaffActivity.java
package com.my.room;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;
import android.widget.Button;

import com.my.room.entity.Staff;
import com.my.room.repository.StaffRepository;
import com.my.room.repository.observer.DeleteObserver;
import com.my.room.repository.observer.InsertObserver;
import com.my.room.repository.observer.UpdateObserver;

public class StaffActivity extends AppCompatActivity {

    public static final String TAG = StaffActivity.class.getSimpleName();

    private StaffRepository staffRepository;

    private Button btnInsert;
    private Button btnDelete;
    private Button btnUpdate;
    private Button btnQueryAll;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_staff);

        staffRepository = new StaffRepository();

        btnInsert = findViewById(R.id.btn_insert);
        btnDelete = findViewById(R.id.btn_delete);
        btnUpdate = findViewById(R.id.btn_update);
        btnQueryAll = findViewById(R.id.btn_query_all);

        btnInsert.setOnClickListener(v -> {
            Staff staff = new Staff();
            staff.name = "jack";
            staff.age = 20;
            staff.cardNum = "staff-001";

            staffRepository.insert(staff, new InsertObserver() {
                @Override
                public void onSuccess() {
                    Log.i(TAG, "------------------------------ insert success");
                }

                @Override
                public void onError(String msg) {
                    Log.i(TAG, "------------------------------ insert error - " + msg);
                }
            });
        });

        btnDelete.setOnClickListener(v -> {
            Staff staff = new Staff();
            staff.id = 1L;

            staffRepository.delete(staff, new DeleteObserver() {
                @Override
                public void onSuccess() {
                    Log.i(TAG, "------------------------------ delete success");
                }

                @Override
                public void onError(String msg) {
                    Log.i(TAG, "------------------------------ delete error - " + msg);
                }
            });
        });

        btnUpdate.setOnClickListener(v -> {
            Staff staff = new Staff();
            staff.id = 1L;
            staff.name = "jack";
            staff.age = 30;
            staff.cardNum = "staff-002";

            staffRepository.update(staff, new UpdateObserver() {
                @Override
                public void onSuccess() {
                    Log.i(TAG, "------------------------------ update success");
                }

                @Override
                public void onError(String msg) {
                    Log.i(TAG, "------------------------------ update error - " + msg);
                }
            });
        });

        btnQueryAll.setOnClickListener(v -> {
            staffRepository.queryAll(staffs -> {
                if (staffs == null) {
                    Log.i(TAG, "------------------------------ queryAll - staffs is null");
                    return;
                }
                if (staffs.size() == 0) {
                    Log.i(TAG, "------------------------------ queryAll - staffs is empty");
                    return;
                }

                for (Staff staff : staffs)
                    Log.i(TAG, "------------------------------ queryAll - " + staff);
            });
        });
    }
}
Test
  • 增 -> 查 -> 改 -> 查 -> 删 -> 查，输出结果
I/StaffActivity: ------------------------------ insert success
I/StaffActivity: ------------------------------ queryAll - Staff{id=1, name='jack', age=20, cardNum='staff-001'}
I/StaffActivity: ------------------------------ update success
I/StaffActivity: ------------------------------ queryAll - Staff{id=1, name='jack', age=30, cardNum='staff-002'}
I/StaffActivity: ------------------------------ delete success
I/StaffActivity: ------------------------------ queryAll - staffs is empty

三、Room 简单案例解析

1、Entity 解析
@Entity(tableName = "Staff")
public class Staff {

    @PrimaryKey(autoGenerate = true)
    public Long id;

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

    @ColumnInfo(name = "age")
    public Integer age;

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

    @Override
    public String toString() {
        return "Staff{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", cardNum='" + cardNum + '\'' +
                '}';
    }
}
  • @Entity(tableName = "Staff")：指定 Staff 类为 Room 数据库中 Staff 表对应的实体类

  1. @PrimaryKey(autoGenerate = true)：指定 id 字段为主键，并且它的值是自动生成的

  2. @ColumnInfo(name = "name")：指定 name 字段映射到表中的 name 列，@ColumnInfo(name = "age") 和 @ColumnInfo(name = "cardNum") 同理

  • Staff 表会在 APP 首次安装时由 Room 根据 Staff 类创建，SQL 语句如下
CREATE TABLE IF NOT EXISTS Staff (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT,
    age INTEGER,
    cardNum TEXT
);
2、DAO 解析
@Dao
public interface StaffDAO {

    @Insert
    void insert(Staff staff);

    @Delete
    void delete(Staff staff);

    @Update
    void update(Staff staff);

    @Query("SELECT * FROM Staff")
    List<Staff> queryAll();
}
  • @Dao：指定 StaffDAO 接口与 Room 数据库进行交互，以操作 Staff 类，该接口使用 Room 相关注解来定义操作方法

  1. @Insert：插入数据，这里传递一个 Staff 对象作为参数，Room 将这个对象插入到数据库中

  2. @Delete：删除数据，这里传递一个 Staff 对象作为参数，Room 基于该对象的 id 字段来删除相应的行

  3. @Update：修改数据，这里传递一个 Staff 对象作为参数，Room 基于该对象的 id 字段来修改相应的行

  4. @Query("SELECT * FROM Staff")：查询数据，查询表中的所有行

3、Database 解析
@Database(entities = {Staff.class}, version = 1, exportSchema = false)
public abstract class MyDatabase extends RoomDatabase {

    public static final String TAG = MyDatabase.class.getSimpleName();

    public static final String DATABASE_NAME = "test.db";

    private static MyDatabase myDatabase;

    public static MyDatabase getInstance() {
        if (myDatabase == null) {
            myDatabase = Room.databaseBuilder(MyApplication.getContext(), MyDatabase.class, DATABASE_NAME)
                    .build();
        }
        return myDatabase;
    }

    public abstract StaffDAO getStaffDAO();
}
（1）注解解析
  • @Database：指定 MyDatabase 抽象类为 Room 数据库

  1. entities = {Staff.class}：指定这个数据库包含 Staff 类

  2. version = 1：指定数据库的版本号，当实体或数据库结构发生变化时，需要增加这个版本号

  3. exportSchema = false：指定不导出数据库的 schema

（2）思路解析

  1. 单例模式确保整个应用程序中只有一个 MyDatabase 实例对象

  2. 通过 Room.databaseBuilder 方法构建数据库，该方法需要三个参数，分别为上下文、数据库类、数据库名称

  3. 定义获取 StaffDao 实例对象的抽象方法，Room 将自动生成这个方法的实现

4、Repository 解析
package com.my.room.repository;

import android.os.AsyncTask;

import com.my.room.dao.StaffDAO;
import com.my.room.database.MyDatabase;
import com.my.room.entity.Staff;
import com.my.room.repository.observer.DeleteObserver;
import com.my.room.repository.observer.InsertObserver;
import com.my.room.repository.observer.QueryAllObserver;
import com.my.room.repository.observer.UpdateObserver;

import java.util.List;

public class StaffRepository {
    private MyDatabase myDatabase;
    private StaffDAO staffDAO;

    public StaffRepository() {
        myDatabase = MyDatabase.getInstance();
        staffDAO = myDatabase.getStaffDAO();
    }

    // ====================================================================================================

    public void insert(Staff staff, InsertObserver insertObserver) {
        new InsertAsyncTask(staff, insertObserver).execute();
    }

    public void delete(Staff staff, DeleteObserver deleteObserver) {
        new DeleteAsyncTask(staff, deleteObserver).execute();
    }

    public void update(Staff staff, UpdateObserver updateObserver) {
        new UpdateAsyncTask(staff, updateObserver).execute();
    }

    public void queryAll(QueryAllObserver<Staff> queryAllObserver) {
        new QueryAllAsyncTask(queryAllObserver).execute();
    }

    // ====================================================================================================

    private class InsertAsyncTask extends AsyncTask<Void, Void, RepositoryItem<Object>> {

        private Staff staff;
        private InsertObserver insertObserver;

        public InsertAsyncTask(Staff staff, InsertObserver insertObserver) {
            this.staff = staff;
            this.insertObserver = insertObserver;
        }

        @Override
        protected RepositoryItem doInBackground(Void... voids) {
            try {
                staffDAO.insert(staff);
                return new RepositoryItem(RepositoryItem.CODE_SUCCESS, null, null);
            } catch (Exception e) {
                e.printStackTrace();
                return new RepositoryItem(RepositoryItem.CODE_ERROR, e.getMessage(), null);
            }
        }

        @Override
        protected void onPostExecute(RepositoryItem repositoryItem) {
            super.onPostExecute(repositoryItem);

            if (repositoryItem.getCode() == RepositoryItem.CODE_SUCCESS) {
                insertObserver.onSuccess();
            } else {
                insertObserver.onError(repositoryItem.getMsg());
            }
        }
    }

    private class DeleteAsyncTask extends AsyncTask<Void, Void, RepositoryItem<Object>> {

        private Staff staff;
        private DeleteObserver deleteObserver;

        public DeleteAsyncTask(Staff staff, DeleteObserver deleteObserver) {
            this.staff = staff;
            this.deleteObserver = deleteObserver;
        }

        @Override
        protected RepositoryItem<Object> doInBackground(Void... voids) {
            try {
                staffDAO.delete(staff);
                return new RepositoryItem(RepositoryItem.CODE_SUCCESS, null, null);
            } catch (Exception e) {
                e.printStackTrace();
                return new RepositoryItem(RepositoryItem.CODE_ERROR, e.getMessage(), null);
            }
        }

        @Override
        protected void onPostExecute(RepositoryItem<Object> repositoryItem) {
            super.onPostExecute(repositoryItem);

            if (repositoryItem.getCode() == RepositoryItem.CODE_SUCCESS) {
                deleteObserver.onSuccess();
            } else {
                deleteObserver.onError(repositoryItem.getMsg());
            }
        }
    }

    private class UpdateAsyncTask extends AsyncTask<Void, Void, RepositoryItem<Object>> {

        private Staff staff;
        private UpdateObserver updateObserver;

        public UpdateAsyncTask(Staff staff, UpdateObserver updateObserver) {
            this.staff = staff;
            this.updateObserver = updateObserver;
        }

        @Override
        protected RepositoryItem<Object> doInBackground(Void... voids) {
            try {
                staffDAO.update(staff);
                return new RepositoryItem(RepositoryItem.CODE_SUCCESS, null, null);
            } catch (Exception e) {
                e.printStackTrace();
                return new RepositoryItem(RepositoryItem.CODE_ERROR, e.getMessage(), null);
            }
        }

        @Override
        protected void onPostExecute(RepositoryItem<Object> repositoryItem) {
            super.onPostExecute(repositoryItem);

            if (repositoryItem.getCode() == RepositoryItem.CODE_SUCCESS) {
                updateObserver.onSuccess();
            } else {
                updateObserver.onError(repositoryItem.getMsg());
            }
        }
    }

    private class QueryAllAsyncTask extends AsyncTask<Void, Void, RepositoryItem<List<Staff>>> {

        private QueryAllObserver<Staff> queryAllObserver;


        public QueryAllAsyncTask(QueryAllObserver<Staff> queryAllObserver) {
            this.queryAllObserver = queryAllObserver;
        }

        @Override
        protected RepositoryItem<List<Staff>> doInBackground(Void... voids) {
            try {
                List<Staff> staffs = staffDAO.queryAll();
                return new RepositoryItem(RepositoryItem.CODE_SUCCESS, null, staffs);
            } catch (Exception e) {
                e.printStackTrace();
                return new RepositoryItem(RepositoryItem.CODE_ERROR, e.getMessage(), null);
            }
        }

        @Override
        protected void onPostExecute(RepositoryItem<List<Staff>> repositoryItem) {
            super.onPostExecute(repositoryItem);

            queryAllObserver.onResult(repositoryItem.getData());
        }
    }
}
  • StaffRepository 类是对 StaffDAO 的封装，封装的主要目的是异步任务处理
（1）异步任务处理
  • 对于每种 StaffDAO 实例对象的操作都定义了一个继承 AsyncTask 的内部类，它用于安排操作在后台线程中执行，然后使用观察者模式来通知调用者

  1. InsertAsyncTask：负责在后台线程中执行插入操作，完成后（无论成功还是失败）通过 InsertObserver 通知调用者

  2. DeleteAsyncTask：负责在后台线程中执行删除操作，完成后（无论成功还是失败）通过 DeleteObserver 通知调用者

  3. UpdateAsyncTask：负责在后台线程中执行插入操作，完成后（无论成功还是失败）通过 UpdateObserver 通知调用者

  4. QueryAllAsyncTask：负责在后台线程中执行查询操作，完成后（无论成功还是失败）通过 QueryAllObserver 通知调用者

（2）补充

  1. 线程调度：数据库操作不能在 UI 线程执行，操作在后台线程中（doInBackground 方法）执行完成后，然后回到 UI 线程中（onPostExecute 方法）执行后续操作

  2. 异常处理：在异步任务种，捕获可能抛出的异常，例如，执行插入操作时主键冲突会抛出异常

我命由我12345
关注
专栏目录
【Android进阶】11、操作数据库：Room 库、Entity 实体、Dao 层、repository 模式和 LiveData
呆呆的猫的博客
09-15 889
Room基于你定义的实体为应用构建数据库表。实体是你创建的模型类，使用@Entity注解。使用@Entity注解一个类，然后交给Room处理，一张数据库表就诞生了。要想在数据库里保存Crime对象，你需要把Crime类改造为Room实体。在database包里，添加一个名为CrimeDao.kt的新文件。}
2-1.Jetpack 之 Room 简单编码模板（Entity、DAO、Database、Repository）
weixin_52173250的博客
09-23 1776
Room 是 Jetpack 中的一个重要成员，它是一个持久化库，它为管理数据库提供了简单强大的方法
Android jetpack Room的简单使用
ljp345775的博客
06-22 1147
在项目中你会遇到如下 黄色警告，可以点击下面的replace，它会自动的给你替换成使用。注意，因为ksp插件 是跟项目中使用的kotlin的版本要保持一致的，否则会报错的。注意： 如果我们在同步项目的时候发现报如下错误的时候，我们可以在。文件，如下，我们看到我们使用的kotlin版本是。，所以我们需要把kotlin的版本升级成。文件中配置阿里的maven。2. 我们打开项目的。
Android Jetpack学习系列——Room
邵旺运的博客
04-16 1291
*** 用户类，用于表示用户信息*/// 主键，自动生成// 用户名// 年龄// 性别/*** 构造函数，用于创建一个新的用户实例* @param name 用户名* @param age 年龄* @param sex 性别*//*** 获取用户ID* @return 用户ID*/return id;/*** 设置用户ID* @param id 用户ID*//*** 获取用户名* @return 用户名*//*** 设置用户名。
Android JetPack之ROOM(一)
Mr_Tony的专栏
05-05 464
Android JetPack之ROOM(一) 前言： ​ ROOM是JetPack框架中的数据库操作部分，是对Android数据库SQLite的封装。使用户能够更方便的对数据库进行操作。 ​ 由于AndroidX和kotlin的原因，所以ROOM在版本上分为support版本和AndroidX版本，在语言上分为kotlin和java版本。本系列脱胎于实际开发经验，所以侧重于support版本和A...
Jetpack - Room
HugMua的博客
11-26 875
Object Relational Mapping（对象关系映射），将面向对象的编程语言和面向关系的数据库之间建立一种映射关系。
JetPack之Room使用介绍
grpc
04-27 1095
文章目录1.导入依赖2.使用实体类定义数据3.使用DAO访问数据4.进行数据库迁移5.关于数据库迁移的几个错误 1.导入依赖 apply plugin: 'kotlin-kapt' implementation "androidx.room:room-runtime:2.2.6" kapt "androidx.room:room-compiler:2.2.6" //room扩展库 支持通过协程操作数据库 implementation "androidx.room:room-ktx:
Android---Jetpack之Room
qq_44950283的博客
04-03 617
Android 采用 SQLite 作为数据库存储，开源社区常见的 ORM(Object Relational Mapping)库有ORMLite、GreenDAO等。Room 和其它库一样，也是在 SQLite 上提供了一层封装。Entity：实体类，对应的是数据库的一张表结构，使用注解 @Entity 标记。相当于 JavaBeanDao：包含访问数据库的一些列方法，使用注解 @Dao 标记。DataBase：数据库持有者，作为与应用持久化相关数据的底层连接的主要接入点。
Android Jetpack架构组件之Room
特立独行的博客
04-22 3419
Room Room重要概念: Entity:实体类，对应的是数据库的一张表结构，使用注解@Entity标记> Dao:包含访问一系列访问数据库的方法，使用注解@Dao标记。//Data Access Objects Database:数据库持有者，作为与应用持久化相关数据的底层连接的主要接入点。使用注解@Database标记，另外需满足以下条件:定义的类必须是一个继承于RoomDatabase的抽象类，在注解中需要定义与数据库相关联的实体类列表。包含一个没有参数的抽象方法并且返回一个Dao对象。 a
android-room-with-a-view.7z
10-12
- Room是Android Jetpack组件之一，是一个抽象层，它使得开发者可以使用更加面向对象的方式来与SQLite数据库进行交互，同时保持编译时的错误检查和类型安全。 - 它提供了DAO（Data Access Object）接口，通过注解...
Jetpack架构组件库：Room
川峰的博客
01-26 1958
默认表名与类名相同，如需显示指定表名，使用如需显示指定表中的列名，使用每个 Room 实体都必须定义一个主键，用于唯一标识相应数据库表中的每一行。执行此操作的最直接方式是使用@Entity data class User(@PrimaryKey // 主键 val id : Int , val name : String , val age : Int)如需设置主键自动生成，使用。
Jetpack系列之Room----入门（三）
aha_jasper的博客
12-23 250
翻译自android官网，可直接去官网观看 Jetpack系列之Room----入门（三）迁移 Room 数据库测试迁移导出架构测试单次迁移测试所有迁移妥善处理缺失的迁移路径升级到 Room 2.2.0 时处理列默认值测试和调试数据库测试您的数据库在 Android 设备上测试数据库在主机上测试数据库调试数据库使用 Room 引用复杂数据使用类型转换器了解 Room 为何不允许对象引用使用 SQLite 保存数据定义架构和协定使用 SQL 帮助程序创建数据库将信息添加到数据库从数据库中读取信息从数据库中删除
JetPack中的Room
Huang兄
10-31 491
2018年谷歌I/O 发布了一系列辅助android开发者的实用工具，合称Jetpack，以帮助开发者构建出色的 Android 应用。 这次发布的 Android Jetpack 组件覆盖以下 4 个方面：Architecture、Foundation、Behavior 以及 UI。该系列博客介绍一下Jetpack中常用组件，本篇介绍Room，结合ViewModel和LiveData完成上图的结构。最后借助于https://github.com/android/sunflower 来写一个完整的应用
13-高级程序开发组件-Jetpack
m0_46355846的博客
03-20 3191
高级程序开发组件-Jetpack 优秀的项目开发框架 MVP MVC MVVM(Google最为推荐) Google官方架构组件-jetpack jetpack jetpack大部分不依赖于任何Android系统版本,而是通常定义在Androidx中 拥有好的向下兼容性 主要有四个部分组成 基础 架构 行为 界面 ViewModel ViewModel的一个重要作用就是帮助Activity分担一部分工作，它是专门用于存放与界面相关的数据的，也就是说只要是界面上能看到的数据，他的相关变量都应该存放
oceanbase V4.2.2社区版集群离线部署
最新发布
king_harry的专栏
11-01 671
版本，选择是上传文件，包含oceanbase-ce、oceanbase-ce-libs、oceanbase-ce-utils。关闭时展示，为 OBProxy 集群的访问地址，仅用于生成租户的连接串，不影响实际使用，需要自主配置负载均衡，如果是 VIP 地址，还需要您自主申请并绑定到 OBProxy Server。集群配置选项卡—更多配置—更改系统内存保留选项，默认是30G，如果测试机内存只有16G，则需要调小，本测试调整为2G，这样ocp-server安装不会失败。自定义待管理的集群的名称。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1364
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 840
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
JAVA中的MVC三层架构
楠寻寻的博客
10-30 1002
MVC（Model-View-Controller）是一种软件设计模式，用于将应用程序分为主要的部分：模型（Model）、视图（View）和控制器（Controller）。这种架构有助于提高代码的可维护性和可扩展性。Spring框架通过@Controller@Service和注解清晰地划分了MVC三层架构的各个层次，使得开发人员能够更高效地构建和维护复杂的Web应用。POJO类：用于表示业务实体，通常包含属性和相关的getter/setter方法。DAO类：用于封装对数据库的操作，提供数据访问的接口。
第2章 Android App开发基础
L念安dd的博客
10-29 1082
本章介绍基于Android系统的App开发常识，包括以下几个方面：App开发与其他软件开发有什么不一 样，App工程是怎样的组织结构又是怎样配置的，App开发的前后端分离设计是如何运作实现的，App的活动页面是如何创建又是如何跳转的。
android-studio-2022.2.1.20-windows.exe
12-04
在Android Studio 2022.2.1.20中，用户可以利用全新的Jetpack Compose工具，通过直观的方式构建用户界面，提高开发效率。同时，内置的调试工具使得用户可以方便地进行应用程序的调试和性能优化。另外，IntelliJ IDEA...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值