Room操作数据库

1. 官方架构
2. 导入资源包
3. 基本用法

1.官方架构

通过ViewModel获得Repository对象，调用Repository方法再去调用Dao层
↓
通过Repository仓库获得Dao接口，调用Dao层接口方法
↓
通过Room对数据库进行增删改查

2.导入资源包

    implementation 'androidx.room:room-runtime:2.2.5'//ROOM
    annotationProcessor 'androidx.room:room-compiler:2.2.5'//ROOM

3.基本用法

Entity层 		-> 用实体对象方式创建数据库表
Dao层   		-> 写对数据库进行增删改查的语句
DataBase层 -> 创建抽象类实例，自动生成实现类

Entity层

@Entity(tableName = "student")
public class Student {

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id",typeAffinity = ColumnInfo.INTEGER)
    public int id;

    @ColumnInfo(name = "name",typeAffinity = ColumnInfo.TEXT)
    public String name;

    @ColumnInfo(name = "age",typeAffinity = ColumnInfo.INTEGER)
    public int age;

    @ColumnInfo(name = "sex",typeAffinity = ColumnInfo.INTEGER)
    public int sex;

    @ColumnInfo(name = "bar_data",typeAffinity = ColumnInfo.INTEGER)
    public int barData;

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

    @Ignore
    public Student(int id) {
        this.id = id;
    }

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

Dao

@Dao
public interface StudentDao {


    @Insert
    public void insertStudent(Student... students);

    //要传主键id 根据id进行删除
    @Delete
    public void deleteStudent(Student... students);

    @Query("DELETE FROM student")
    public void deleteAllStudents();

    //要传主键id 根据id进行更新
    @Update
    public void updateStudent(Student... students);

    @Query("SELECT * FROM student")
    public LiveData<List<Student>> getAllStudent();

    @Query("SELECT * FROM student WHERE id =:id ")
    public List<Student> getStudentById(int id);
}

DataBase

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

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

    private static MyDatabase mInstance;

    //不能这样写 这首抽象类 会自动生成实现类，需要用到构造方法
//    private MyDatabase(){}

    public static synchronized MyDatabase getInstance(Context context){
        if (mInstance == null){
            mInstance = Room.databaseBuilder(context.getApplicationContext(),
                    MyDatabase.class,
                    DATABASE_NAME)
                    .build();
        }
        return mInstance;
    }

    public abstract StudentDao getStudentDao();

}

在Repository获取Dao接口

需要传入上下文，以获取接口对象

public class StudentRepository {


    private StudentDao studentDao;

    public StudentRepository(Context context) {
        MyDatabase database = MyDatabase.getInstance(context);
        this.studentDao = database.getStudentDao();
    }

    public void insertStudent(Student... students){
        new InsertStudentTack(studentDao).execute(students);
    }

    class InsertStudentTack extends AsyncTask<Student,Void,Void> {

        private StudentDao studentDao;

        public InsertStudentTack(StudentDao studentDao) {
            this.studentDao = studentDao;
        }

        @Override
        protected Void doInBackground(Student... students) {
            studentDao.insertStudent(students);
            return null;
        }
    }

    public void deleteStudent(Student...students){
        new DeleteStudentTack(studentDao).execute(students);
    }

    class DeleteStudentTack extends AsyncTask<Student,Void,Void>{

        private StudentDao studentDao;

        public DeleteStudentTack(StudentDao studentDao) {
            this.studentDao = studentDao;
        }

        @Override
        protected Void doInBackground(Student... students) {
            studentDao.deleteStudent(students);
            return null;
        }
    }

    public void deleteAllStudent(){
        new DeleteAllStudentTack(studentDao).execute();
    }

    class DeleteAllStudentTack extends AsyncTask<Void,Void,Void>{

        private StudentDao studentDao;

        public DeleteAllStudentTack(StudentDao studentDao) {
            this.studentDao = studentDao;
        }

        @Override
        protected Void doInBackground(Void...voids) {
            studentDao.deleteAllStudents();
            return null;
        }
    }

    public void updataStudent(Student...students){
        new UpdateStudentTack(studentDao).execute(students);
    }

    class UpdateStudentTack extends AsyncTask<Student,Void,Void>{

        private StudentDao studentDao;

        public UpdateStudentTack(StudentDao studentDao) {
            this.studentDao = studentDao;
        }

        @Override
        protected Void doInBackground(Student... students) {
            studentDao.updateStudent(students);
            return null;
        }
    }

    public LiveData<List<Student>> getAllStudent(){
        return studentDao.getAllStudent();
    }
}

在ViewModel获取Repository实例

需要用到上下文 所以要继承AndroidViewModel

public class StudentViewModel extends AndroidViewModel {

    private StudentRepository repository;

    public StudentViewModel(@NonNull Application application) {
        super(application);
        this.repository = new StudentRepository(application);
    }

    public void add(Student...students) {
        repository.insertStudent(students);
    }

    public void delete(Student...students) {
        repository.deleteStudent(students);
    }

    public void deleteAllStudent(){
        repository.deleteAllStudent();
    }

    public void updata(Student...students) {
        repository.updataStudent(students);
    }

    public LiveData<List<Student>> getAllStudent(){
        return repository.getAllStudent();
    }
}