JetPack--Room数据库

aruba

发布于 2021-12-06 17:28:33

1.5K0

发布于 2021-12-06 17:28:33

文章被收录于专栏：android技术

JetPack提供了Room数据库，和GreenDAO等开源库一样，在SQLite做了封装

Room主要使用三个注解：

1.Entity：实体类，对应一张表

2.Dao：包含操作表的一些列方法

3.Database：数据库持有者，数据库驱动。需要满足：定义的类是一个继承RoomDatabase的抽象类，注解中定义包含实体类列表，包含一个没有参数的抽象方法并返回Dao对象

一、Room上手

首先添加依赖：

    implementation 'androidx.room:room-runtime:2.3.0-rc01'
    annotationProcessor 'androidx.room:room-compiler:2.3.0-rc01'

定义一个实体类，在class上使用 @Entity注解 ，还需要一个构造方法，Room会根据这个构造将表里的数据转化为实体类，对于其他我们代码里使用的构造方法，可以使用@Ignore注解表示Room将忽略它，属性也可以使用这个注解，表示这个属性将不会生成数据库字段使用@PrimaryKey注解指定主键并且是自增长的属性还可以指定在数据库的字段等，使用@ColumnInfo注解：

package com.aruba.room;

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

/**
 * Created by aruba on 2021/9/12.
 */
@Entity
public class User {
    @PrimaryKey(autoGenerate = true)
    public int id;
    public String name;
    @ColumnInfo(name = "age", typeAffinity = ColumnInfo.INTEGER)
    public int age;
    @Ignore
    public boolean flag;

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

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

    @Ignore
    public User() {
        
    }
}

定义Dao接口来对刚刚的User表进行操作，对接口使用@Dao注解 @Query、@Insert、@Delete、@Update注解，分别表示：查询、新增、删除、更新 增删改操作内部会自动使用主键进行操作

package com.aruba.room;

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

import java.util.List;

/**
 * Created by aruba on 2021/9/12.
 */
@Dao
public interface UserDao {
    //查询
    @Query("SELECT * FROM user")
    List<User> getUsers();

    //根据id查询
    @Query("SELECT * FROM user WHERE id = :id")
    User getUserById(int id);

    //插入一条数据
    @Insert
    void insertUser(User user);

    //删除一条数据
    @Delete
    void deleteUser(User user);

    //更新一条数据
    @Update
    void updateUser(User user);
}

定义抽象类，继承于RoomDatabase，并使用@Database注解，注解中指定表的实体类、数据库版本、是否输出日志使用单例模式时，构造方法不能私有化，因为Room内部会调用构造方法定义获取Dao对象的抽象函数

package com.aruba.room;

import android.content.Context;

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

/**
 * Created by aruba on 2021/9/12.
 */
@Database(entities = {User.class}, version = 1, exportSchema = false)
public abstract class MyDataBase extends RoomDatabase {
    private static final String DBNAME = MyDataBase.class.getSimpleName();
    private static MyDataBase instance;

    public static MyDataBase getInstance() {
        if (instance == null) throw new NullPointerException("database not init!!");
        return instance;
    }

    public static synchronized MyDataBase init(Context context) {
        if (instance == null)
            instance = Room.databaseBuilder(context.getApplicationContext()
                    , MyDataBase.class, DBNAME)
                    .build();

        return instance;
    }

    //获取Dao对象
    public abstract UserDao getUserDao();
}

界面中使用一个RecyclerView展示User表内的数据，并使用四个按钮分别进行查询，新增，删除，修改操作。效果：

不过每次我们做了操作后，还需要手动查询下，有没有可以自动刷新数据的方法呢？

二、ViewModel+LiveData+Room

Room支持返回LiveData类型，结合ViewModel、DataBinding，就可以改造成一个非常棒的MVVM架构

package com.aruba.room;

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

import java.util.List;

/**
 * Created by aruba on 2021/9/12.
 */
@Dao
public interface UserDao {
    //查询
    @Query("SELECT * FROM user")
    LiveData<List<User>> getUsers();

    //根据id查询
    @Query("SELECT * FROM user WHERE id = :id")
    User getUserById(int id);

    //插入一条数据
    @Insert
    void insertUser(User user);

    //删除一条数据
    @Delete
    void deleteUser(User user);

    //删除所有数据
    @Query("DELETE  FROM user")
    void deleteAllUser();

    //更新一条数据
    @Update
    void updateUser(User user);
}

首先定义Repository层，里面实现对数据库的操作

package com.aruba.room;

import android.content.Context;
import android.os.AsyncTask;
import android.view.View;

import androidx.lifecycle.LiveData;

import java.util.List;

/**
 * Created by aruba on 2021/9/12.
 */
public class UserRepository {
    private UserDao userDao;

    public UserRepository(Context context) {
        this.userDao = MyDataBase.init(context).getUserDao();
    }

    public void insert(User user) {
        new AsyncTask<Void, Void, Void>() {

            @Override
            protected Void doInBackground(Void... voids) {
                userDao.insertUser(user);
                return null;
            }
        }.execute();
    }

    public void update(User user) {
        new AsyncTask<Void, Void, Void>() {

            @Override
            protected Void doInBackground(Void... voids) {
                userDao.updateUser(user);
                return null;
            }
        }.execute();
    }

    public void delete(User user) {
        new AsyncTask<Void, Void, Void>() {

            @Override
            protected Void doInBackground(Void... voids) {
                userDao.deleteUser(user);
                return null;
            }
        }.execute();
    }

    public void deleteAllUser(){
        new AsyncTask<Void, Void, Void>() {

            @Override
            protected Void doInBackground(Void... voids) {
                userDao.deleteAllUser();
                return null;
            }
        }.execute();
    }
    
    public LiveData<List<User>> query() {
        return userDao.getUsers();
    }
}

定义ViewModel

package com.aruba.room;

import android.app.Application;
import android.view.View;

import androidx.annotation.NonNull;
import androidx.lifecycle.AndroidViewModel;
import androidx.lifecycle.LiveData;

import java.util.List;

/**
 * Created by aruba on 2021/9/12.
 */
public class UserViewModel extends AndroidViewModel {
    private UserRepository userRepository;

    public UserViewModel(@NonNull Application application) {
        super(application);
        userRepository = new UserRepository(application);
    }

    public void insert(View v) {
        userRepository.insert(new User("张三", 12));
    }

    public void update(View v) {
        User user = new User("赵四", 18);
        user.id = 1;
        userRepository.update(user);
    }

    public void delete(View v) {
        User user = new User();
        user.id = 2;
        userRepository.delete(user);
    }

    public void deleteAll(View v) {
        userRepository.deleteAllUser();
    }
    
    public LiveData<List<User>> getUsers() {
        return userRepository.query();
    }
}

Activity中使用：

package com.aruba.room;

import androidx.appcompat.app.AppCompatActivity;
import androidx.databinding.DataBindingUtil;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProvider;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import android.os.Bundle;

import com.aruba.room.databinding.ActivityMainBinding;

import java.util.List;

public class MainActivity extends AppCompatActivity {

    private RecyclerViewAdapter recyclerViewAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityMainBinding activityMainBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);
        UserViewModel userViewModel = new ViewModelProvider(this, ViewModelProvider.AndroidViewModelFactory.getInstance(getApplication())).get(UserViewModel.class);
        activityMainBinding.setUserViewModel(userViewModel);
        activityMainBinding.setLifecycleOwner(this);

        userViewModel.getUsers().observe(this, new Observer<List<User>>() {
            @Override
            public void onChanged(List<User> users) {
                recyclerViewAdapter.setDatas(users);
                recyclerViewAdapter.notifyDataSetChanged();
            }
        });
        recyclerViewAdapter = new RecyclerViewAdapter();
        activityMainBinding.recyclerview.setAdapter(recyclerViewAdapter);
        activityMainBinding.recyclerview.setLayoutManager(new LinearLayoutManager(this, RecyclerView.VERTICAL, false));
    }
}

效果：

三、升级与填充

1.使用Migration升级数据库

定义Migration，构造时需要低版本号和高版本号，初始化数据库时，通过addMigrations方法传入

package com.aruba.room;

import android.content.Context;

import androidx.annotation.NonNull;
import androidx.room.Database;
import androidx.room.Room;
import androidx.room.RoomDatabase;
import androidx.room.migration.Migration;
import androidx.sqlite.db.SupportSQLiteDatabase;

/**
 * Created by aruba on 2021/9/12.
 */
@Database(entities = {User.class}, version = 3, exportSchema = false)
public abstract class MyDataBase extends RoomDatabase {
    private static final String DBNAME = MyDataBase.class.getSimpleName();
    private static MyDataBase instance;

    public static MyDataBase getInstance() {
        if (instance == null) throw new NullPointerException("database not init!!");
        return instance;
    }

    public static synchronized MyDataBase init(Context context) {
        if (instance == null)
            instance = Room.databaseBuilder(context.getApplicationContext()
                    , MyDataBase.class, DBNAME)
                    .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
                    .build();

        return instance;
    }

    static final Migration MIGRATION_1_2 = new Migration(1, 2) {
        @Override
        public void migrate(@NonNull SupportSQLiteDatabase database) {
            database.execSQL("ALTER TABLE user ADD COLUMN sex INTEGER NOT NULL DEFAULT 1");
        }
    };

    static final Migration MIGRATION_2_3 = new Migration(2, 3) {
        @Override
        public void migrate(@NonNull SupportSQLiteDatabase database) {
            database.execSQL("ALTER TABLE user ADD COLUMN height INTEGER NOT NULL DEFAULT 1");
        }
    };

    //获取Dao对象
    public abstract UserDao getUserDao();
}

2.异常处理

如果我们将版本升级到3，但是没有写相应的Migration，那么会出现一个IIlegalStateException异常，使用fallbackToDestructiveMigration方法，出现异常时，会重新构造表，当然以前的数据会丢失

3.Schema文件

我们在使用@Database注解时exportSchema指定为true，那么每次升级时，都会导出一个Schema文件，里面包含的数据库的创建信息，方便排查问题同时我们也需要在gradle里指定下导出文件夹位置

    defaultConfig {
        applicationId "com.aruba.room"
        minSdk 21
        targetSdk 30
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        dataBinding {
            enabled = true
        }
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = ["room.schemaLocation": "$projectDir/schemas".toString()]
            }
        }
    }

{
  "formatVersion": 1,
  "database": {
    "version": 3,
    "identityHash": "5a971aace7f8ede39ea6eb469ab90b10",
    "entities": [
      {
        "tableName": "User",
        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT, `age` INTEGER NOT NULL, `sex` INTEGER NOT NULL, `height` INTEGER NOT NULL)",
        "fields": [
          {
            "fieldPath": "id",
            "columnName": "id",
            "affinity": "INTEGER",
            "notNull": true
          },
          {
            "fieldPath": "name",
            "columnName": "name",
            "affinity": "TEXT",
            "notNull": false
          },
          {
            "fieldPath": "age",
            "columnName": "age",
            "affinity": "INTEGER",
            "notNull": true
          },
          {
            "fieldPath": "sex",
            "columnName": "sex",
            "affinity": "INTEGER",
            "notNull": true
          },
          {
            "fieldPath": "height",
            "columnName": "height",
            "affinity": "INTEGER",
            "notNull": true
          }
        ],
        "primaryKey": {
          "columnNames": [
            "id"
          ],
          "autoGenerate": true
        },
        "indices": [],
        "foreignKeys": []
      }
    ],
    "views": [],
    "setupQueries": [
      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '5a971aace7f8ede39ea6eb469ab90b10')"
    ]
  }
}

4.销毁与重建策略

SQLite中修改表结构比较麻烦，如果想要将sex字段从INTEGER改为TEXT，最好的方式是采用销毁与重建策略，将数据复制到一个临时表，在删除原表，再将临时表重命名成原表名，可以参考schema文件

    static final Migration MIGRATION_3_4 = new Migration(3, 4) {
        @Override
        public void migrate(@NonNull SupportSQLiteDatabase database) {
            //"createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` 
            // (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT
            // , `age` INTEGER NOT NULL, `sex` INTEGER NOT NULL, `height` INTEGER NOT NULL)",
            //根据schema文件创建新表，注意TEXT不需要加上NOT NULL
            database.execSQL(
                    "CREATE TABLE temp_user (" +
                            "id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
                            "name TEXT, " +
                            "age INTEGER NOT NULL, " +
                            "sex TEXT DEFAULT 'M', " +
                            "height INTEGER NOT NULL )"
            );
            //数据导入临时表
            database.execSQL("INSERT INTO temp_user (name,age,sex,height)" +
                    "SELECT name,age,sex,height FROM user");
            //丢弃原表
            database.execSQL("DROP TABLE user");
            //临时表重命名
            database.execSQL("ALTER TABLE temp_user RENAME TO user");
        }
    };

5.预填充数据库

我们可以将数据库文件放入assets目录下，初始化数据库时，通过createFromAsset方法或createFromFile方法导入

    public static synchronized MyDataBase init(Context context) {
        if (instance == null)
            instance = Room.databaseBuilder(context.getApplicationContext()
                    , MyDataBase.class, DBNAME)
                    .addMigrations(MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4)
                    .fallbackToDestructiveMigration()
                    .createFromAsset("mem.db")
                    .build();

        return instance;
    }